|
|
import { IDestroyable } from "@implab/core-amd/interfaces";
|
|
|
import { isDestroyable } from "@implab/core-amd/safe";
|
|
|
import _WidgetBase = require("dijit/_WidgetBase");
|
|
|
import registry = require("dijit/registry");
|
|
|
|
|
|
interface _WidgetBaseConstructor {
|
|
|
new <E extends { [k in keyof E]: Event } = object>(params?: Partial<_WidgetBase<E>> & ThisType<_WidgetBase<E>>, srcNodeRef?: string | Node): _WidgetBase<E> & dojo._base.DeclareCreatedObject;
|
|
|
prototype: _WidgetBase;
|
|
|
}
|
|
|
|
|
|
export type DojoNodePosition = "first" | "after" | "before" | "last" | "replace" | "only" | number;
|
|
|
|
|
|
export type DojoNodeLocation = [Node, DojoNodePosition];
|
|
|
|
|
|
export interface Rendition<TNode extends Node = Node> {
|
|
|
getDomNode(): TNode;
|
|
|
|
|
|
placeAt(refNode: string | Node, position?: DojoNodePosition): void;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @deprecated use Rendition
|
|
|
*/
|
|
|
export type BuildContext<TNode extends Node = Node> = Rendition<TNode>;
|
|
|
|
|
|
export interface IRecursivelyDestroyable {
|
|
|
destroyRecursive(): void;
|
|
|
}
|
|
|
|
|
|
export const isNode = (el: unknown): el is Node => !!(el !== null && typeof el === "object" && (el as Node).nodeName && (el as Node).nodeType);
|
|
|
|
|
|
export const isElementNode = (el: unknown): el is Element => isNode(el) && el.nodeType === 1;
|
|
|
|
|
|
export const isTextNode = (el: unknown): el is Text => isNode(el) && el.nodeType === 3;
|
|
|
|
|
|
export const isProcessingInstructionNode = (el: unknown): el is ProcessingInstruction => isNode(el) && el.nodeType === 7;
|
|
|
|
|
|
export const isCommentNode = (el: unknown): el is Comment => isNode(el) && el.nodeType === 8;
|
|
|
|
|
|
export const isDocumentNode = (el: unknown): el is Document => isNode(el) && el.nodeType === 9;
|
|
|
|
|
|
export const isDocumentTypeNode = (el: unknown): el is DocumentType => isNode(el) && el.nodeType === 10;
|
|
|
|
|
|
export const isDocumentFragmentNode = (el: unknown): el is DocumentFragment => isNode(el) && el.nodeType === 11;
|
|
|
|
|
|
export const isWidget = (v: unknown): v is _WidgetBase => !!(v !== null && typeof v === "object" && "domNode" in (v as _WidgetBase));
|
|
|
|
|
|
export const isRendition = (v: unknown): v is Rendition => !!(v !== null && typeof v === "object" && typeof (v as Rendition).getDomNode === "function");
|
|
|
|
|
|
/**
|
|
|
* @deprecated use isRendition
|
|
|
*/
|
|
|
export const isBuildContext = isRendition;
|
|
|
|
|
|
export const isPlainObject = (v: object) => {
|
|
|
if (typeof v !== "object")
|
|
|
return false;
|
|
|
|
|
|
const vp = Object.getPrototypeOf(v) as object;
|
|
|
return !vp || vp === Object.prototype;
|
|
|
};
|
|
|
|
|
|
export const isWidgetConstructor = (v: unknown): v is _WidgetBaseConstructor =>
|
|
|
typeof v === "function" && !!v.prototype && (
|
|
|
"domNode" in v.prototype ||
|
|
|
"buildRendering" in v.prototype
|
|
|
);
|
|
|
|
|
|
|
|
|
/** Tests whether the specified node is placed in visible dom.
|
|
|
* @param {Node} node The node to test
|
|
|
*/
|
|
|
export const isInPage = (node: Node) => node === document.body ? false : document.body.contains(node);
|
|
|
|
|
|
export const isRecursivelyDestroyable = (target: unknown): target is IRecursivelyDestroyable =>
|
|
|
!!(target && typeof (target as IRecursivelyDestroyable).destroyRecursive === "function");
|
|
|
|
|
|
|
|
|
|
|
|
/** Destroys DOM Node with all contained widgets.
|
|
|
* If the specified node is the root node of a widget, then the
|
|
|
* widget will be destroyed.
|
|
|
*
|
|
|
* @param target DOM Node or widget to destroy
|
|
|
*/
|
|
|
export const destroy = (target: Node | IDestroyable | IRecursivelyDestroyable) => {
|
|
|
if (isRecursivelyDestroyable(target)) {
|
|
|
target.destroyRecursive();
|
|
|
} else if (isDestroyable(target)) {
|
|
|
target.destroy();
|
|
|
} else if (isNode(target)) {
|
|
|
if (isElementNode(target)) {
|
|
|
const w = registry.byNode(target);
|
|
|
if (w) {
|
|
|
w.destroyRecursive();
|
|
|
return;
|
|
|
} else {
|
|
|
emptyNode(target);
|
|
|
}
|
|
|
}
|
|
|
const parent = target.parentNode;
|
|
|
if (parent)
|
|
|
parent.removeChild(target);
|
|
|
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/** Empties a content of the specified node and destroys all contained widgets.
|
|
|
*
|
|
|
* @param target DOM node to empty.
|
|
|
*/
|
|
|
export const emptyNode = (target: Node) => {
|
|
|
registry.findWidgets(target).forEach(destroy);
|
|
|
|
|
|
// eslint-disable-next-line no-cond-assign
|
|
|
for (let c; c = target.lastChild;) { // intentional assignment
|
|
|
target.removeChild(c);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/** This function starts all widgets inside the DOM node if the target is a node
|
|
|
* or starts widget itself if the target is the widget. If the specified node
|
|
|
* associated with the widget that widget will be started.
|
|
|
*
|
|
|
* @param target DOM node to find and start widgets or the widget itself.
|
|
|
*/
|
|
|
export const startupWidgets = (target: Node | _WidgetBase, skipNode?: Node) => {
|
|
|
if (isNode(target)) {
|
|
|
if (isElementNode(target)) {
|
|
|
const w = registry.byNode(target);
|
|
|
if (w) {
|
|
|
if (w.startup)
|
|
|
w.startup();
|
|
|
} else {
|
|
|
registry.findWidgets(target, skipNode).forEach(x => x.startup());
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
if (target.startup)
|
|
|
target.startup();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/** Places the specified DOM node at the specified location.
|
|
|
*
|
|
|
* @param node The node which should be placed
|
|
|
* @param refNodeOrId The reference node where the created
|
|
|
* DOM should be placed.
|
|
|
* @param position Optional parameter, specifies the
|
|
|
* position relative to refNode. Default is "last" (i.e. last child).
|
|
|
*/
|
|
|
export const placeAt = (node: Node, refNodeOrId: string | Node, position: DojoNodePosition = "last") => {
|
|
|
const ref = typeof refNodeOrId == "string" ? document.getElementById(refNodeOrId) : refNodeOrId;
|
|
|
if (!ref)
|
|
|
return;
|
|
|
|
|
|
const parent = ref.parentNode;
|
|
|
|
|
|
if (typeof position == "number") {
|
|
|
if (ref.childNodes.length <= position) {
|
|
|
ref.appendChild(node);
|
|
|
} else {
|
|
|
ref.insertBefore(node, ref.childNodes[position]);
|
|
|
}
|
|
|
} else {
|
|
|
switch (position) {
|
|
|
case "before":
|
|
|
parent && parent.insertBefore(node, ref);
|
|
|
break;
|
|
|
case "after":
|
|
|
parent && parent.insertBefore(node, ref.nextSibling);
|
|
|
break;
|
|
|
case "first":
|
|
|
ref.insertBefore(node, ref.firstChild);
|
|
|
break;
|
|
|
case "last":
|
|
|
ref.appendChild(node);
|
|
|
break;
|
|
|
case "only":
|
|
|
emptyNode(ref);
|
|
|
ref.appendChild(node);
|
|
|
break;
|
|
|
case "replace":
|
|
|
if (parent)
|
|
|
parent.replaceChild(node, ref);
|
|
|
destroy(ref);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/** Collects nodes from collection to an array.
|
|
|
*
|
|
|
* @param collection The collection of nodes.
|
|
|
* @returns The array of nodes.
|
|
|
*/
|
|
|
export const collectNodes = (collection: NodeListOf<ChildNode>) => {
|
|
|
const items = [];
|
|
|
for (let i = 0, n = collection.length; i < n; i++) {
|
|
|
items.push(collection[i]);
|
|
|
}
|
|
|
return items;
|
|
|
};
|
|
|
|
|
|
|
|
|
export const isMounted = (node: Node) => {
|
|
|
if (node.parentNode) {
|
|
|
const parentWidget = registry.getEnclosingWidget(node.parentNode);
|
|
|
if (parentWidget && parentWidget._started)
|
|
|
return true;
|
|
|
}
|
|
|
if (isInPage(node))
|
|
|
return true;
|
|
|
return false;
|
|
|
};
|
