|
|
import { TraceSource } from "@implab/core-amd/log/TraceSource";
|
|
|
import { isPromise } from "@implab/core-amd/safe";
|
|
|
import { id as mid } from "module";
|
|
|
import { IScope, Scope } from "./Scope";
|
|
|
import { isNode, isRendition, isWidget } from "./traits";
|
|
|
|
|
|
const trace = TraceSource.get(mid);
|
|
|
|
|
|
interface Context {
|
|
|
readonly scope: IScope;
|
|
|
|
|
|
readonly hooks?: (() => void)[];
|
|
|
}
|
|
|
|
|
|
let _context: Context = {
|
|
|
scope: Scope.dummy
|
|
|
};
|
|
|
|
|
|
let _renderCount = 0;
|
|
|
let _renderId = 1;
|
|
|
let _renderedHooks: (() => void)[] = [];
|
|
|
|
|
|
|
|
|
const guard = (cb: () => unknown) => {
|
|
|
try {
|
|
|
const result = cb();
|
|
|
if (isPromise(result)) {
|
|
|
const warn = (ret: unknown) => trace.error("The callback {0} competed asynchronously. result = {1}", cb, ret);
|
|
|
result.then(warn, warn);
|
|
|
}
|
|
|
} catch (e) {
|
|
|
trace.error(e);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
*
|
|
|
* @param scope
|
|
|
* @returns
|
|
|
*/
|
|
|
export const beginRender = (scope = getScope()) => {
|
|
|
const prev = _context;
|
|
|
_renderCount++;
|
|
|
const renderId = _renderId++;
|
|
|
trace.debug("beginRender [{0}], pending = {1}", renderId, _renderCount);
|
|
|
if (_renderCount === 1)
|
|
|
onRendering();
|
|
|
|
|
|
_context = {
|
|
|
scope,
|
|
|
hooks: []
|
|
|
};
|
|
|
return endRender(prev, _context, renderId);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Method for a deferred rendering. Returns a promise with `beginRender()` function.
|
|
|
* Call to `scheduleRender` will save the current context, and will increment pending
|
|
|
* operations counter.
|
|
|
*
|
|
|
* @example
|
|
|
*
|
|
|
* const begin = await scheduleRender();
|
|
|
* const end = begin();
|
|
|
* try {
|
|
|
* // do some DOM manipulations
|
|
|
* } finally {
|
|
|
* end();
|
|
|
* }
|
|
|
*
|
|
|
* @param scope
|
|
|
* @returns
|
|
|
*/
|
|
|
export const scheduleRender = async (scope = getScope()) => {
|
|
|
_renderCount++;
|
|
|
const renderId = _renderId ++;
|
|
|
trace.debug("scheduleRender [{0}], pending = {1}", renderId, _renderCount);
|
|
|
if (_renderCount === 1)
|
|
|
onRendering();
|
|
|
|
|
|
await Promise.resolve();
|
|
|
|
|
|
return () => {
|
|
|
trace.debug("beginRender [{0}], pending = {1}", renderId, _renderCount);
|
|
|
const prev = _context;
|
|
|
|
|
|
_context = {
|
|
|
scope,
|
|
|
hooks: []
|
|
|
};
|
|
|
return endRender(prev, _context, renderId);
|
|
|
};
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Completes render operation
|
|
|
*/
|
|
|
const endRender = (prev: Context, current: Context, renderId: number) => () => {
|
|
|
if (_context !== current)
|
|
|
trace.error("endRender mismatched beginRender call");
|
|
|
|
|
|
const { hooks } = _context;
|
|
|
if (hooks)
|
|
|
hooks.forEach(guard);
|
|
|
|
|
|
_renderCount--;
|
|
|
_context = prev;
|
|
|
|
|
|
trace.debug("endRender [{0}], pending = {1}", renderId, _renderCount);
|
|
|
if (_renderCount === 0)
|
|
|
onRendered();
|
|
|
};
|
|
|
|
|
|
// called when the first beginRender is called for this iteration
|
|
|
const onRendering = () => {
|
|
|
trace.log("Rendering started");
|
|
|
setTimeout(() => {
|
|
|
if (_renderCount !== 0)
|
|
|
trace.error("Rendering tasks aren't finished, currently running = {0}", _renderCount);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
// called when all render operations are complete
|
|
|
const onRendered = () => {
|
|
|
trace.log("Rendering compete");
|
|
|
_renderedHooks.forEach(guard);
|
|
|
_renderedHooks = [];
|
|
|
};
|
|
|
|
|
|
export const whenRendered = () => new Promise<void>((resolve) => {
|
|
|
if (_renderCount)
|
|
|
_renderedHooks.push(resolve);
|
|
|
else
|
|
|
resolve();
|
|
|
});
|
|
|
|
|
|
export const renderHook = (hook: () => void) => {
|
|
|
const { hooks } = _context;
|
|
|
if (hooks)
|
|
|
hooks.push(hook);
|
|
|
else
|
|
|
guard(hook);
|
|
|
};
|
|
|
|
|
|
export const refHook = <T>(value: T, ref: JSX.Ref<T>) => {
|
|
|
const { hooks, scope } = _context;
|
|
|
if (hooks)
|
|
|
hooks.push(() => ref(value));
|
|
|
else
|
|
|
guard(() => ref(value));
|
|
|
|
|
|
scope.own(() => ref(undefined));
|
|
|
};
|
|
|
|
|
|
/** Returns the current scope */
|
|
|
export const getScope = () => _context.scope;
|
|
|
|
|
|
/** Schedules the rendition to be rendered to the DOM Node
|
|
|
* @param rendition The rendition to be rendered
|
|
|
* @param scope The scope
|
|
|
*/
|
|
|
export const render = (rendition: unknown, scope = Scope.dummy) => {
|
|
|
const complete = beginRender(scope);
|
|
|
try {
|
|
|
return getItemDom(rendition);
|
|
|
} finally {
|
|
|
complete();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
const emptyFragment = document.createDocumentFragment();
|
|
|
|
|
|
/** Renders DOM element for different types of the argument. */
|
|
|
export const getItemDom = (v: unknown) => {
|
|
|
if (typeof v === "string" || typeof v === "number" || v instanceof RegExp || v instanceof Date) {
|
|
|
// primitive types converted to the text nodes
|
|
|
return document.createTextNode(v.toString());
|
|
|
} else if (isNode(v)) {
|
|
|
// nodes are kept as is
|
|
|
return v;
|
|
|
} else if (isRendition(v)) {
|
|
|
// renditions are instantiated
|
|
|
return v.getDomNode();
|
|
|
} else if (isWidget(v)) {
|
|
|
// widgets are converted to it's markup
|
|
|
return v.domNode;
|
|
|
} else if (typeof v === "boolean" || v === null || v === undefined) {
|
|
|
// null | undefined | boolean are removed
|
|
|
return emptyFragment;
|
|
|
} else if (v instanceof Array) {
|
|
|
// arrays will be translated to document fragments
|
|
|
const fragment = document.createDocumentFragment();
|
|
|
v.map(item => getItemDom(item))
|
|
|
.forEach(node => fragment.appendChild(node));
|
|
|
return fragment;
|
|
|
} else {
|
|
|
// bug: explicit error otherwise
|
|
|
throw new Error(`Invalid parameter: ${String(v)}`);
|
|
|
}
|
|
|
};
|
|
|
|
