@zcomponent/core 0.0.1

package/lib/contexts/analyticscontext.js

@@ -0,0 +1,17 @@
+import { defineContextType } from '../context';
+import { Event } from '../event';
+export const AnalyticsContext = defineContextType((ctx) => {
+    const onEvent = new Event();
+    return {
+        onEvent,
+        logEvent: (name, params) => {
+            onEvent.emit(name, params);
+        }
+    };
+});
+export function logEvent(mgr, name, params) {
+    return mgr.get(AnalyticsContext).logEvent(name, params);
+}
+export function useAnalyticsOnEvent(mgr) {
+    return mgr.get(AnalyticsContext).onEvent;
+}

package/lib/contexts/canvascontext.d.ts

@@ -0,0 +1,15 @@
+import { ContextManager } from '../context';
+import { Event } from '../event';
+import { Observable } from '../observable';
+export interface CanvasContext {
+    canvas: HTMLCanvasElement;
+    onBeforeRender: Event<[number]>;
+    onAfterRender: Event<[number]>;
+    size: Observable<[number, number]>;
+    dispose: () => void;
+}
+export declare const CanvasContext: import("../context").ContextTypeWithDefault<CanvasContext, [canvas?: HTMLCanvasElement | undefined]>;
+export declare function useCanvas(mgr: ContextManager): HTMLCanvasElement;
+export declare function useCanvasSize(mgr: ContextManager): Observable<[number, number]>;
+export declare function useOnBeforeRender(mgr: ContextManager): Event<[number]>;
+export declare function useOnAfterRender(mgr: ContextManager): Event<[number]>;

package/lib/contexts/canvascontext.js

@@ -0,0 +1,45 @@
+import { defineContextType } from '../context';
+import { Event } from '../event';
+import { Observable } from '../observable';
+export const CanvasContext = defineContextType((ctx, canvas) => {
+    if (!canvas) {
+        canvas = document.createElement("canvas");
+        canvas.style.position = "fixed";
+        canvas.style.top = "0px";
+        canvas.style.left = "0px";
+        canvas.style.width = "100%";
+        canvas.style.height = "100%";
+        canvas.style.touchAction = "none";
+        document.body.append(canvas);
+    }
+    const size = new Observable([canvas.clientWidth, canvas.clientHeight]);
+    const resizeObserver = new ResizeObserver(entries => {
+        for (const entry of entries) {
+            if (entry.target !== canvas)
+                continue;
+            size.value = [entry.contentRect.width, entry.contentRect.height];
+        }
+    });
+    resizeObserver.observe(canvas);
+    return {
+        canvas,
+        onBeforeRender: new Event(),
+        onAfterRender: new Event(),
+        size,
+        dispose: () => {
+            resizeObserver.disconnect();
+        }
+    };
+});
+export function useCanvas(mgr) {
+    return mgr.get(CanvasContext).canvas;
+}
+export function useCanvasSize(mgr) {
+    return mgr.get(CanvasContext).size;
+}
+export function useOnBeforeRender(mgr) {
+    return mgr.get(CanvasContext).onBeforeRender;
+}
+export function useOnAfterRender(mgr) {
+    return mgr.get(CanvasContext).onAfterRender;
+}

package/lib/contexts/cookieconsentcontext.d.ts

@@ -0,0 +1,38 @@
+import { ContextManager } from '../context';
+import { Observable } from '../observable';
+export declare enum Status {
+    "unknown" = "unknown",
+    "initializing" = "initializing",
+    "initialized" = "initialized"
+}
+export declare enum ConsentStatus {
+    "unknown" = "unknown",
+    "granted" = "granted",
+    "rejected" = "rejected"
+}
+export interface Vendor {
+    name: string;
+    description: string;
+    privacyPolicyUrl: string;
+}
+export interface CookieConsentContext {
+    status: Observable<Status>;
+    functionalCookies: Observable<ConsentStatus>;
+    performanceCookies: Observable<ConsentStatus>;
+    marketingCookies: Observable<ConsentStatus>;
+    performanceVendors: Vendor[];
+    marketingVendors: Vendor[];
+    registerPerformanceVendor: (v: Vendor) => void;
+    registerMarketingVendor: (v: Vendor) => void;
+    showSettings: Observable<(() => void) | undefined>;
+}
+export declare const CookieConsentContext: import("../context").ContextTypeWithDefault<CookieConsentContext, []>;
+export declare function useCookieConsentFunctional(mgr: ContextManager): Observable<ConsentStatus>;
+export declare function useCookieConsentPerformance(mgr: ContextManager): Observable<ConsentStatus>;
+export declare function useCookieConsentMarketing(mgr: ContextManager): Observable<ConsentStatus>;
+export declare function useCookieConsentStatus(mgr: ContextManager): Observable<Status>;
+export declare function registerPerformanceVendor(mgr: ContextManager, vendor: Vendor): void;
+export declare function registerMarketingVendor(mgr: ContextManager, vendor: Vendor): void;
+export declare function usePerformanceVendors(mgr: ContextManager): Vendor[];
+export declare function useMarketingVendors(mgr: ContextManager): Vendor[];
+export declare function useShowCookieSettings(mgr: ContextManager): Observable<(() => void) | undefined>;

package/lib/contexts/cookieconsentcontext.js

@@ -0,0 +1,63 @@
+import { defineContextType } from '../context';
+import { Observable } from '../observable';
+export var Status;
+(function (Status) {
+    Status["unknown"] = "unknown";
+    Status["initializing"] = "initializing";
+    Status["initialized"] = "initialized";
+})(Status || (Status = {}));
+export var ConsentStatus;
+(function (ConsentStatus) {
+    ConsentStatus["unknown"] = "unknown";
+    ConsentStatus["granted"] = "granted";
+    ConsentStatus["rejected"] = "rejected";
+})(ConsentStatus || (ConsentStatus = {}));
+export const CookieConsentContext = defineContextType((ctx) => {
+    const status = new Observable(Status.unknown);
+    const functionalCookies = new Observable(ConsentStatus.unknown);
+    const performanceCookies = new Observable(ConsentStatus.unknown);
+    const marketingCookies = new Observable(ConsentStatus.unknown);
+    const showSettings = new Observable(undefined);
+    const performanceVendors = [];
+    const marketingVendors = [];
+    const registerPerformanceVendor = (v) => performanceVendors.push(v);
+    const registerMarketingVendor = (v) => marketingVendors.push(v);
+    return {
+        status,
+        functionalCookies,
+        performanceCookies,
+        marketingCookies,
+        performanceVendors,
+        marketingVendors,
+        registerPerformanceVendor,
+        registerMarketingVendor,
+        showSettings
+    };
+});
+export function useCookieConsentFunctional(mgr) {
+    return mgr.get(CookieConsentContext).functionalCookies;
+}
+export function useCookieConsentPerformance(mgr) {
+    return mgr.get(CookieConsentContext).performanceCookies;
+}
+export function useCookieConsentMarketing(mgr) {
+    return mgr.get(CookieConsentContext).marketingCookies;
+}
+export function useCookieConsentStatus(mgr) {
+    return mgr.get(CookieConsentContext).status;
+}
+export function registerPerformanceVendor(mgr, vendor) {
+    return mgr.get(CookieConsentContext).registerPerformanceVendor(vendor);
+}
+export function registerMarketingVendor(mgr, vendor) {
+    return mgr.get(CookieConsentContext).registerMarketingVendor(vendor);
+}
+export function usePerformanceVendors(mgr) {
+    return mgr.get(CookieConsentContext).performanceVendors;
+}
+export function useMarketingVendors(mgr) {
+    return mgr.get(CookieConsentContext).marketingVendors;
+}
+export function useShowCookieSettings(mgr) {
+    return mgr.get(CookieConsentContext).showSettings;
+}

package/lib/contexts/environmentcontext.d.ts

@@ -0,0 +1,9 @@
+import { ContextManager } from '../context';
+import { Observable } from '../observable';
+export interface EnvirontmentContext {
+    designTime: Observable<boolean>;
+    editTime: Observable<boolean>;
+}
+export declare const EnvironmentContext: import("../context").ContextTypeWithDefault<EnvirontmentContext, []>;
+export declare function isDesignTime(ctx: ContextManager): boolean;
+export declare function isEditTime(ctx: ContextManager): boolean;

package/lib/contexts/environmentcontext.js

@@ -0,0 +1,14 @@
+import { defineContextType } from '../context';
+import { Observable } from '../observable';
+export const EnvironmentContext = defineContextType(() => {
+    return {
+        designTime: new Observable(false),
+        editTime: new Observable(false)
+    };
+});
+export function isDesignTime(ctx) {
+    return ctx.get(EnvironmentContext).designTime.value;
+}
+export function isEditTime(ctx) {
+    return ctx.get(EnvironmentContext).editTime.value;
+}

package/lib/contexts/loadcontext.d.ts

@@ -0,0 +1,24 @@
+import { ContextManager } from '../context';
+import { Observable } from '../observable';
+export interface LoadContext {
+    isConstructed: Observable<boolean>;
+    isLoaded: Observable<boolean>;
+    isStarted: Observable<boolean>;
+    started: Promise<void>;
+    progressPercent: Observable<number>;
+    registerLoadable: (p: Promise<any>) => void;
+    start: () => void;
+    startWhenLoaded: () => void;
+}
+export declare const LoadContext: import("../context").ContextTypeWithDefault<LoadContext, []>;
+export declare function useIsLoaded(mgr: ContextManager): Observable<boolean>;
+export declare function isLoaded(mgr: ContextManager): boolean;
+export declare function useIsStarted(mgr: ContextManager): Observable<boolean>;
+export declare function isStarted(mgr: ContextManager): boolean;
+export declare function useIsConstructed(mgr: ContextManager): Observable<boolean>;
+export declare function isConstructed(mgr: ContextManager): boolean;
+export declare function useLoadPercent(mgr: ContextManager): Observable<number>;
+export declare function registerLoadable(mgr: ContextManager, p: Promise<any>): void;
+export declare function start(mgr: ContextManager): void;
+export declare function startWhenLoaded(mgr: ContextManager): void;
+export declare function started(mgr: ContextManager): Promise<void>;

package/lib/contexts/loadcontext.js

@@ -0,0 +1,94 @@
+import { defineContextType } from '../context';
+import { Observable } from '../observable';
+export const LoadContext = defineContextType((ctx) => {
+    let totalLoadables = 0;
+    let loadedCount = 0;
+    const loadables = new Set();
+    const isConstructed = new Observable(false);
+    const isLoaded = new Observable(false);
+    const isStarted = new Observable(false);
+    const startWhenLoaded = new Observable(false);
+    const progressPercent = new Observable(0);
+    let startedResolve;
+    const started = new Promise(resolve => startedResolve = resolve);
+    const start = () => {
+        if (isStarted.value)
+            return;
+        isStarted.value = true;
+        startedResolve?.();
+        if (document.body)
+            document.body.classList.add("zcomponent-started");
+    };
+    const update = () => {
+        if (loadables.size > 0 && isLoaded.value === true) {
+            isLoaded.value = false;
+            totalLoadables = loadables.size;
+            loadedCount = 0;
+        }
+        if (loadables.size === 0 && isLoaded.value === false) {
+            isLoaded.value = true;
+            if (document.body)
+                document.body.classList.add("zcomponent-loaded");
+        }
+        progressPercent.value = isLoaded.value ? 100 : (100 * loadedCount / totalLoadables);
+        if (startWhenLoaded.value && isLoaded.value && !isStarted.value) {
+            start();
+        }
+    };
+    const registerLoadable = (p) => {
+        loadables.add(p);
+        totalLoadables++;
+        p.finally(() => {
+            loadedCount++;
+            loadables.delete(p);
+            update();
+        });
+        update();
+    };
+    return {
+        isConstructed,
+        isLoaded,
+        isStarted,
+        started,
+        progressPercent,
+        registerLoadable,
+        start,
+        startWhenLoaded: () => {
+            startWhenLoaded.value = true;
+            update();
+        }
+    };
+});
+export function useIsLoaded(mgr) {
+    return mgr.get(LoadContext).isLoaded;
+}
+export function isLoaded(mgr) {
+    return mgr.get(LoadContext).isLoaded.value;
+}
+export function useIsStarted(mgr) {
+    return mgr.get(LoadContext).isStarted;
+}
+export function isStarted(mgr) {
+    return mgr.get(LoadContext).isStarted.value;
+}
+export function useIsConstructed(mgr) {
+    return mgr.get(LoadContext).isConstructed;
+}
+export function isConstructed(mgr) {
+    return mgr.get(LoadContext).isConstructed.value;
+}
+export function useLoadPercent(mgr) {
+    return mgr.get(LoadContext).progressPercent;
+}
+export function registerLoadable(mgr, p) {
+    return mgr.get(LoadContext).registerLoadable(p);
+}
+export function start(mgr) {
+    return mgr.get(LoadContext).start();
+}
+export function startWhenLoaded(mgr) {
+    return mgr.get(LoadContext).startWhenLoaded();
+}
+export function started(mgr) {
+    return mgr.get(LoadContext).started;
+}

package/lib/contexts/usereventcontext.d.ts

@@ -0,0 +1,12 @@
+import { ContextManager } from '../context';
+import { Event as EventClass } from '../event';
+import { Observable } from '../observable';
+export interface UserEventContext {
+    onUserEvent: EventClass<[Event]>;
+    nextUserEvent: Observable<Promise<Event>>;
+    registerUserEvent: (evt: Event) => void;
+}
+export declare const UserEventContext: import("../context").ContextTypeWithDefault<UserEventContext, []>;
+export declare function useOnUserEvent(mgr: ContextManager): EventClass<[Event]>;
+export declare function nextUserEvent(mgr: ContextManager): Promise<Event>;
+export declare function registerUserEvent(mgr: ContextManager, evt: Event): void;

package/lib/contexts/usereventcontext.js

@@ -0,0 +1,32 @@
+import { defineContextType } from '../context';
+import { Event as EventClass } from '../event';
+import { Observable } from '../observable';
+export const UserEventContext = defineContextType((ctx) => {
+    const onUserEvent = new EventClass();
+    let resolveNextUserEvent;
+    const nextUserEvent = new Observable(new Promise(resolve => {
+        resolveNextUserEvent = resolve;
+    }), undefined, false);
+    const registerUserEvent = (evt) => {
+        const currentResolve = resolveNextUserEvent;
+        nextUserEvent.value = new Promise(resolve => {
+            resolveNextUserEvent = resolve;
+        });
+        currentResolve(evt);
+        onUserEvent.emit(evt);
+    };
+    return {
+        onUserEvent,
+        nextUserEvent,
+        registerUserEvent
+    };
+});
+export function useOnUserEvent(mgr) {
+    return mgr.get(UserEventContext).onUserEvent;
+}
+export function nextUserEvent(mgr) {
+    return mgr.get(UserEventContext).nextUserEvent.value;
+}
+export function registerUserEvent(mgr, evt) {
+    return mgr.get(UserEventContext).registerUserEvent(evt);
+}

package/lib/data.d.ts

@@ -0,0 +1,38 @@
+import { BehaviorData, NodeData, ZComponentData } from "./interfaces";
+export declare function addNode(zcomp: ZComponentData, info: NodeDataCombined, parentIndex?: number): void;
+export declare function addBehavior(zcomp: ZComponentData, info: BehaviorDataCombined, parentIndex?: number): void;
+export declare function addEntity(zcomp: ZComponentData, id: string, info: EntityDataCombined): void;
+export declare function deleteNode(zcomp: ZComponentData, id: string): void;
+export declare function deleteBehavior(zcomp: ZComponentData, id: string): void;
+export declare function getNodeDataCombined(zcomp: ZComponentData, id: string): NodeDataCombined | undefined;
+export declare function getBehaviorDataCombined(zcomp: ZComponentData, id: string): BehaviorDataCombined | undefined;
+export declare function addNodeToParent(zcomp: ZComponentData, id: string, parentID: string, indx?: number): void;
+export declare function removeNodeFromParent(zcomp: ZComponentData, id: string): void;
+export declare function addBehaviorToNode(zcomp: ZComponentData, id: string, nodeID: string, indx?: number): void;
+export declare function addNodeLabelToRegister(zcomp: ZComponentData, id: string): void;
+export declare function removeNodeLabelFromRegister(zcomp: ZComponentData, id: string): void;
+export declare function addNodeScriptNameToRegister(zcomp: ZComponentData, id: string): void;
+export declare function removeNodeScriptNameFromRegister(zcomp: ZComponentData, id: string): void;
+export declare function changeNodeLabel(zcomp: ZComponentData, id: string, newLabel: string | undefined): void;
+export declare function changeNodeScriptName(zcomp: ZComponentData, id: string, newScriptName: string | undefined): void;
+export declare function removeBehaviorFromNode(zcomp: ZComponentData, id: string): void;
+export declare function findNodeParentAndIndex(zcomp: ZComponentData, id: string): [string, number] | undefined;
+export declare function findBehaviorNodeAndIndex(zcomp: ZComponentData, id: string): [string, number] | undefined;
+export declare function deleteEntity(zcomp: ZComponentData, id: string): void;
+export declare function changeNodeID(zcomp: ZComponentData, id: string, newID: string): void;
+export declare function forEachNodeAncestor(zcomp: ZComponentData, id: string, fn: (ancestorID: string) => void): void;
+export declare function forEachNodeAndDescendant(zcomp: ZComponentData, id: string, fn: (nodeID: string, parent: [string, number] | undefined) => void): void;
+export interface EntityDataCombined {
+    props: {
+        [id: string]: any;
+    };
+    constructorProps: {
+        [id: string]: any;
+    };
+}
+export interface NodeDataCombined extends EntityDataCombined {
+    data: NodeData;
+}
+export interface BehaviorDataCombined extends EntityDataCombined {
+    data: BehaviorData;
+}

package/lib/data.js

@@ -0,0 +1,240 @@
+export function addNode(zcomp, info, parentIndex) {
+    zcomp.nodes[info.data.id] = info.data;
+    addNodeLabelToRegister(zcomp, info.data.id);
+    addNodeScriptNameToRegister(zcomp, info.data.id);
+    addEntity(zcomp, info.data.id, info);
+    if (info.data.parent)
+        addNodeToParent(zcomp, info.data.id, info.data.parent, parentIndex);
+}
+export function addBehavior(zcomp, info, parentIndex) {
+    zcomp.behaviors[info.data.id] = info.data;
+    addEntity(zcomp, info.data.id, info);
+    if (info.data.nodeId)
+        addBehaviorToNode(zcomp, info.data.id, info.data.nodeId, parentIndex);
+}
+export function addEntity(zcomp, id, info) {
+    zcomp.entityProps[id] = info.props;
+    zcomp.entityConstructorProps[id] = info.constructorProps;
+}
+export function deleteNode(zcomp, id) {
+    removeNodeFromParent(zcomp, id);
+    deleteEntity(zcomp, id);
+    removeNodeLabelFromRegister(zcomp, id);
+    removeNodeScriptNameFromRegister(zcomp, id);
+    delete zcomp.nodes[id];
+}
+export function deleteBehavior(zcomp, id) {
+    removeBehaviorFromNode(zcomp, id);
+    deleteEntity(zcomp, id);
+    delete zcomp.behaviors[id];
+}
+export function getNodeDataCombined(zcomp, id) {
+    const data = zcomp.nodes[id];
+    if (!data)
+        return;
+    return {
+        data,
+        props: zcomp.entityProps[id] ?? {},
+        constructorProps: zcomp.entityConstructorProps[id] ?? {}
+    };
+}
+export function getBehaviorDataCombined(zcomp, id) {
+    const data = zcomp.behaviors[id];
+    if (!data)
+        return;
+    return {
+        data,
+        props: zcomp.entityProps[id] ?? {},
+        constructorProps: zcomp.entityConstructorProps[id] ?? {}
+    };
+}
+export function addNodeToParent(zcomp, id, parentID, indx) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    const parent = zcomp.nodes[parentID];
+    if (typeof parent !== 'object' || !Array.isArray(parent.children))
+        return;
+    parent.children.splice(indx ?? parent.children.length, 0, { id });
+    node.parent = parentID;
+}
+export function removeNodeFromParent(zcomp, id) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    const parent = findNodeParentAndIndex(zcomp, id);
+    if (!parent)
+        return;
+    const parentNode = zcomp.nodes[parent[0]];
+    if (typeof parentNode !== 'object' || !Array.isArray(parentNode.children))
+        return;
+    parentNode.children.splice(parent[1], 1);
+    delete node.parent;
+}
+export function addBehaviorToNode(zcomp, id, nodeID, indx) {
+    const behavior = zcomp.behaviors[id];
+    if (!behavior)
+        return;
+    if (!zcomp.behaviorsByNode[nodeID])
+        zcomp.behaviorsByNode[nodeID] = [];
+    if (!Array.isArray(zcomp.behaviorsByNode[nodeID]))
+        return;
+    zcomp.behaviorsByNode[nodeID].splice(indx ?? zcomp.behaviorsByNode[nodeID].length, 0, id);
+    behavior.nodeId = nodeID;
+}
+export function addNodeLabelToRegister(zcomp, id) {
+    const node = zcomp.nodes[id];
+    if (node?.label) {
+        if (zcomp.entitiesByLabel === undefined)
+            zcomp.entitiesByLabel = {};
+        if (zcomp.entitiesByLabel[node.label] === undefined)
+            zcomp.entitiesByLabel[node.label] = {};
+        zcomp.entitiesByLabel[node.label][node.id] = true;
+    }
+}
+export function removeNodeLabelFromRegister(zcomp, id) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    if (node.label) {
+        if (zcomp.entitiesByLabel) {
+            delete zcomp.entitiesByLabel[node.label][id];
+            if (Object.keys(zcomp.entitiesByLabel[node.label]).length === 0) {
+                delete zcomp.entitiesByLabel[node.label];
+            }
+        }
+    }
+}
+export function addNodeScriptNameToRegister(zcomp, id) {
+    const node = zcomp.nodes[id];
+    if (node?.scriptName) {
+        if (zcomp.entitiesByScriptName === undefined)
+            zcomp.entitiesByScriptName = {};
+        if (zcomp.entitiesByScriptName[node.scriptName] === undefined)
+            zcomp.entitiesByScriptName[node.scriptName] = {};
+        zcomp.entitiesByScriptName[node.scriptName][node.id] = true;
+    }
+}
+export function removeNodeScriptNameFromRegister(zcomp, id) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    if (node.scriptName) {
+        if (zcomp.entitiesByScriptName) {
+            delete zcomp.entitiesByScriptName[node.scriptName][id];
+            if (Object.keys(zcomp.entitiesByScriptName[node.scriptName]).length === 0) {
+                delete zcomp.entitiesByScriptName[node.scriptName];
+            }
+        }
+    }
+}
+export function changeNodeLabel(zcomp, id, newLabel) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    removeNodeLabelFromRegister(zcomp, id);
+    if (newLabel === undefined)
+        delete node.label;
+    else
+        node.label = newLabel;
+    addNodeLabelToRegister(zcomp, id);
+}
+export function changeNodeScriptName(zcomp, id, newScriptName) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    removeNodeScriptNameFromRegister(zcomp, id);
+    if (newScriptName === undefined)
+        delete node.scriptName;
+    else
+        node.scriptName = newScriptName;
+    addNodeScriptNameToRegister(zcomp, id);
+}
+export function removeBehaviorFromNode(zcomp, id) {
+    const behavior = zcomp.behaviors[id];
+    if (!behavior)
+        return;
+    const node = findBehaviorNodeAndIndex(zcomp, id);
+    if (!node)
+        return;
+    const nodeBehaviors = zcomp.behaviorsByNode[node[0]];
+    if (Array.isArray(nodeBehaviors))
+        nodeBehaviors.splice(node[1], 1);
+    delete behavior.nodeId;
+}
+export function findNodeParentAndIndex(zcomp, id) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    const parentID = node.parent;
+    if (!parentID)
+        return;
+    const parent = zcomp.nodes[parentID];
+    if (!parent)
+        return;
+    if (!Array.isArray(parent.children))
+        return;
+    const indx = parent.children.findIndex(val => val.id === id);
+    if (indx < 0)
+        return;
+    return [parentID, indx];
+}
+export function findBehaviorNodeAndIndex(zcomp, id) {
+    const behavior = zcomp.behaviors[id];
+    if (!behavior)
+        return;
+    const nodeID = behavior.nodeId;
+    if (!nodeID)
+        return;
+    const nodeBehaviors = zcomp.behaviorsByNode[nodeID];
+    if (!Array.isArray(nodeBehaviors))
+        return;
+    const indx = nodeBehaviors.indexOf(id);
+    if (indx < 0)
+        return;
+    return [nodeID, indx];
+}
+export function deleteEntity(zcomp, id) {
+    delete zcomp.entityProps[id];
+    delete zcomp.entityConstructorProps[id];
+}
+export function changeNodeID(zcomp, id, newID) {
+    if (id === newID)
+        return;
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    const parent = findNodeParentAndIndex(zcomp, id);
+    if (parent) {
+        const parentNode = zcomp.nodes[parent[0]];
+        if (parentNode) {
+            parentNode.children[parent[1]].id = newID;
+        }
+    }
+    node.id = newID;
+    zcomp.entityProps[newID] = zcomp.entityProps[id];
+    delete zcomp.entityProps[id];
+    zcomp.entityConstructorProps[newID] = zcomp.entityConstructorProps[id];
+    delete zcomp.entityConstructorProps[id];
+    for (const child of node.children) {
+        const childNode = zcomp.nodes[child.id];
+        if (!childNode)
+            continue;
+        childNode.parent = newID;
+    }
+}
+export function forEachNodeAncestor(zcomp, id, fn) {
+    const parent = findNodeParentAndIndex(zcomp, id);
+    if (!parent)
+        return;
+    fn(parent[0]);
+    forEachNodeAncestor(zcomp, parent[0], fn);
+}
+export function forEachNodeAndDescendant(zcomp, id, fn) {
+    const node = zcomp.nodes[id];
+    if (!node)
+        return;
+    const parent = findNodeParentAndIndex(zcomp, id);
+    fn(id, parent);
+    node.children.forEach(v => forEachNodeAndDescendant(zcomp, v.id, fn));
+}

package/lib/event.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from "./observable";
+export declare class Event<Args extends Array<any> = []> {
+    hasBindings: Observable<boolean>;
+    private _funcs;
+    private _emitting;
+    private _toUnbind;
+    clear(): void;
+    /**
+     * Bind new handler function.
+     * @param f - The callback function to be bound.
+     */
+    bindfn(f: (...args: Args) => void): void;
+    /**
+     * Unbind an existing function.
+     * @param f - The callback function to be unbound.
+     */
+    unbindfn(f: (...args: Args) => void): void;
+    /**
+     * Emit an event.
+     *
+     * @param a - The argument to pass to handler functions.
+     */
+    emit(...args: Args): void;
+}