@zcomponent/core 0.0.9 → 0.0.11

package/lib/behavior.d.ts

@@ -16,7 +16,7 @@ export declare class Behavior<InstanceType extends Component = Component> {
     private _registered;
     private _zcomponent;
     constructor(contextManager: ContextManager, instance: InstanceType);
-    getZComponentInstance<T extends ZComponent = ZComponent>(type?: ConstructorForComponent<T>): T | undefined;
+    getZComponentInstance<T extends ZComponent = ZComponent>(type?: ConstructorForComponent<T>): T;
     private _updateEnabledResolved;
     /**
      * @zprop

package/lib/behavior.js

@@ -28,9 +28,13 @@ export class Behavior {
         this.register(instance.enabledResolved, this._updateEnabledResolved);
     }
     getZComponentInstance(type) {
+        if (this._zcomponent === undefined)
+            throw new Error("getZComponentInstance called in behavior that's not part of a ZComponent");
         if (!type)
             return this._zcomponent;
-        return (type && this._zcomponent instanceof type) ? this._zcomponent : undefined;
+        if (this._zcomponent instanceof type)
+            return this._zcomponent;
+        throw new Error("getZComponentInstance called in behavior passing wrong kind of ZComponent");
     }
     register(e, fn) {
         if (e instanceof Event)

package/lib/component.js

@@ -48,16 +48,25 @@ export class Component {
     constructChildren(children, contextManager) {
         contextManager = contextManager ?? this.contextManager;
         for (const [constructor, props, ref] of children) {
-            const instance = new constructor(contextManager, props);
-            this.appendChild(instance);
-            if (ref)
-                ref.value = instance;
+            try {
+                const instance = new constructor(contextManager, props);
+                this.appendChild(instance);
+                if (ref)
+                    ref.value = instance;
+            }
+            catch (err) {
+                console.log('An error occurred when constructing component child of type:', constructor, err);
+            }
         }
     }
     getZComponentInstance(type) {
+        if (this._zcomponent === undefined)
+            throw new Error("getZComponentInstance called in component that's not part of a ZComponent");
         if (!type)
             return this._zcomponent;
-        return (type && this._zcomponent instanceof type) ? this._zcomponent : undefined;
+        if (this._zcomponent instanceof type)
+            return this._zcomponent;
+        throw new Error("getZComponentInstance called in component passing wrong kind of ZComponent");
     }
     appendChild(c) {
         c.remove();

package/lib/data.d.ts

@@ -1,27 +1,26 @@
-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;
+import { BehaviorByID, BehaviorData, ComputedHierarchy, NodeByID, NodeData, ZComponentData } from "./interfaces";
+export declare function computeNodeHierarchy(nodes: NodeByID): ComputedHierarchy;
+export declare function computeBehaviorHierarchy(behaviors: BehaviorByID): ComputedHierarchy;
+export declare function addNode(zcomp: ZComponentData, info: NodeDataCombined): void;
+export declare function addBehavior(zcomp: ZComponentData, info: BehaviorDataCombined): void;
 export declare function addEntity(zcomp: ZComponentData, id: string, info: EntityDataCombined): void;
+export declare function moveNodes(zcomp: ZComponentData, nodeIDs: string[], newParentID: string, indx: number): 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 fixAnyDuplicateIndex(zcomp: ZComponentData, hierarchy: ComputedHierarchy, nodeID: string, indx: number): void;
+export declare function fixAnyDuplicateBehaviorsIndex(zcomp: ZComponentData, behaviors: ComputedHierarchy, nodeID: string, indx: number): void;
+export declare function nodeOrderForParentIndex(zcomp: ZComponentData, parentID: string, indx?: number): string;
+export declare function behaviorOrderForParentIndex(zcomp: ZComponentData, parentID: string, indx?: number): string;
 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;

package/lib/data.js

@@ -1,32 +1,114 @@
-export function addNode(zcomp, info, parentIndex) {
+import { generateKeyBetween, generateNKeysBetween } from "./fractionalindexing";
+// Simple memoizing of computed hierarchy
+const computedHierarchies = new Map();
+const computedBehaviors = new Map();
+export function computeNodeHierarchy(nodes) {
+    let existing = computedHierarchies.get(nodes);
+    if (!existing) {
+        existing = {};
+        for (const [id, node] of Object.entries(nodes)) {
+            if (!node || !node.parent)
+                continue;
+            const parent = existing[node.parent.id] || [];
+            existing[node.parent.id] = parent;
+            parent.push(id);
+        }
+        for (const children of Object.values(existing)) {
+            children.sort((nodeAID, nodeBID) => {
+                let a = nodes[nodeAID]?.parent?.order ?? 'A0';
+                let b = nodes[nodeBID]?.parent?.order ?? 'A0';
+                if (a === b) {
+                    a = nodeAID;
+                    b = nodeBID;
+                }
+                return a < b ? -1 : 1;
+            });
+        }
+        computedHierarchies.set(nodes, existing);
+    }
+    return existing;
+}
+export function computeBehaviorHierarchy(behaviors) {
+    let existing = computedBehaviors.get(behaviors);
+    if (!existing) {
+        existing = {};
+        for (const [id, entity] of Object.entries(behaviors)) {
+            if (!entity || !entity.parent)
+                continue;
+            const parent = existing[entity.parent.id] || [];
+            existing[entity.parent.id] = parent;
+            parent.push(id);
+        }
+        for (const children of Object.values(existing)) {
+            children.sort((entityAID, entityBID) => {
+                let a = behaviors[entityAID]?.parent?.order ?? 'A0';
+                let b = behaviors[entityBID]?.parent?.order ?? 'A0';
+                if (a === b) {
+                    a = entityAID;
+                    b = entityBID;
+                }
+                return a < b ? -1 : 1;
+            });
+        }
+        computedBehaviors.set(behaviors, existing);
+    }
+    return existing;
+}
+export function addNode(zcomp, info) {
     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);
+    computedHierarchies.delete(zcomp.nodes);
 }
-export function addBehavior(zcomp, info, parentIndex) {
+export function addBehavior(zcomp, info) {
     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);
+    computedBehaviors.delete(zcomp.behaviors);
 }
 export function addEntity(zcomp, id, info) {
     zcomp.entityProps[id] = info.props;
     zcomp.entityConstructorProps[id] = info.constructorProps;
 }
+export function moveNodes(zcomp, nodeIDs, newParentID, indx) {
+    const parent = zcomp.nodes[newParentID];
+    if (!parent)
+        return;
+    const computed = computeNodeHierarchy(zcomp.nodes);
+    fixAnyDuplicateIndex(zcomp, computed, newParentID, indx - 1);
+    const parentChildren = computed[newParentID] ?? [];
+    const leftID = parentChildren[indx - 1];
+    const rightID = parentChildren[indx];
+    const leftOrder = zcomp.nodes[leftID]?.parent?.order ?? null;
+    const rightOrder = zcomp.nodes[rightID]?.parent?.order ?? null;
+    const newOrders = generateNKeysBetween(leftOrder, rightOrder, nodeIDs.length);
+    for (let i = 0; i < nodeIDs.length; i++) {
+        const nodeID = nodeIDs[i];
+        const node = zcomp.nodes[nodeID];
+        if (!node)
+            continue;
+        node.parent = { id: newParentID, order: newOrders[i] };
+    }
+}
 export function deleteNode(zcomp, id) {
-    removeNodeFromParent(zcomp, id);
+    // Delete child nodes
+    const children = computeNodeHierarchy(zcomp.nodes)[id] ?? [];
+    for (const child of children)
+        deleteNode(zcomp, child);
+    // Delete behaviors
+    const behaviors = computeBehaviorHierarchy(zcomp.behaviors)[id] ?? [];
+    for (const id of behaviors)
+        deleteBehavior(zcomp, id);
     deleteEntity(zcomp, id);
     removeNodeLabelFromRegister(zcomp, id);
     removeNodeScriptNameFromRegister(zcomp, id);
     delete zcomp.nodes[id];
+    computedHierarchies.delete(zcomp.nodes);
 }
 export function deleteBehavior(zcomp, id) {
-    removeBehaviorFromNode(zcomp, id);
     deleteEntity(zcomp, id);
     delete zcomp.behaviors[id];
+    computedBehaviors.delete(zcomp.behaviors);
 }
 export function getNodeDataCombined(zcomp, id) {
     const data = zcomp.nodes[id];
@@ -48,39 +130,69 @@ export function getBehaviorDataCombined(zcomp, id) {
         constructorProps: zcomp.entityConstructorProps[id] ?? {}
     };
 }
-export function addNodeToParent(zcomp, id, parentID, indx) {
-    const node = zcomp.nodes[id];
-    if (!node)
+export function fixAnyDuplicateIndex(zcomp, hierarchy, nodeID, indx) {
+    if (indx < 0)
         return;
-    const parent = zcomp.nodes[parentID];
-    if (typeof parent !== 'object' || !Array.isArray(parent.children))
+    const children = hierarchy[nodeID];
+    const a = children[indx];
+    const b = children[indx + 1];
+    if (!a || !b)
         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)
+    const nodeA = zcomp.nodes[a];
+    const nodeB = zcomp.nodes[b];
+    if (!nodeA?.parent || !nodeB?.parent)
         return;
-    const parent = findNodeParentAndIndex(zcomp, id);
-    if (!parent)
+    if (nodeA.parent.id !== nodeB.parent.id)
         return;
-    const parentNode = zcomp.nodes[parent[0]];
-    if (typeof parentNode !== 'object' || !Array.isArray(parentNode.children))
+    if (nodeA.parent.order !== nodeB.parent.order)
         return;
-    parentNode.children.splice(parent[1], 1);
-    delete node.parent;
+    fixAnyDuplicateIndex(zcomp, hierarchy, nodeID, indx + 1);
+    const c = children[indx + 2];
+    const corder = c ? zcomp.nodes[c]?.parent?.order : undefined;
+    nodeB.parent.order = generateKeyBetween(nodeA.parent.order, corder ?? null);
 }
-export function addBehaviorToNode(zcomp, id, nodeID, indx) {
-    const behavior = zcomp.behaviors[id];
-    if (!behavior)
+export function fixAnyDuplicateBehaviorsIndex(zcomp, behaviors, nodeID, indx) {
+    if (indx < 0)
+        return;
+    const children = behaviors[nodeID];
+    const a = children[indx];
+    const b = children[indx + 1];
+    if (!a || !b)
+        return;
+    const behaviorA = zcomp.behaviors[a];
+    const behaviorB = zcomp.behaviors[b];
+    if (!behaviorA?.parent || !behaviorB?.parent)
+        return;
+    if (behaviorA.parent.id !== behaviorB.parent.id)
         return;
-    if (!zcomp.behaviorsByNode[nodeID])
-        zcomp.behaviorsByNode[nodeID] = [];
-    if (!Array.isArray(zcomp.behaviorsByNode[nodeID]))
+    if (behaviorA.parent.order !== behaviorB.parent.order)
         return;
-    zcomp.behaviorsByNode[nodeID].splice(indx ?? zcomp.behaviorsByNode[nodeID].length, 0, id);
-    behavior.nodeId = nodeID;
+    fixAnyDuplicateBehaviorsIndex(zcomp, behaviors, nodeID, indx + 1);
+    const c = children[indx + 2];
+    const corder = c ? zcomp.nodes[c]?.parent?.order : undefined;
+    behaviorB.parent.order = generateKeyBetween(behaviorA.parent.order, corder ?? null);
+}
+export function nodeOrderForParentIndex(zcomp, parentID, indx) {
+    const computed = computeNodeHierarchy(zcomp.nodes);
+    const parentChildren = computed[parentID] ?? [];
+    indx = indx ?? parentChildren.length;
+    fixAnyDuplicateIndex(zcomp, computed, parentID, indx - 1);
+    const leftID = parentChildren[indx - 1];
+    const rightID = parentChildren[indx];
+    const leftOrder = zcomp.nodes[leftID]?.parent?.order ?? null;
+    const rightOrder = zcomp.nodes[rightID]?.parent?.order ?? null;
+    return generateKeyBetween(leftOrder, rightOrder);
+}
+export function behaviorOrderForParentIndex(zcomp, parentID, indx) {
+    const computed = computeBehaviorHierarchy(zcomp.behaviors);
+    const parentChildren = computed[parentID] ?? [];
+    indx = indx ?? parentChildren.length;
+    fixAnyDuplicateBehaviorsIndex(zcomp, computed, parentID, indx - 1);
+    const leftID = parentChildren[indx - 1];
+    const rightID = parentChildren[indx];
+    const leftOrder = zcomp.behaviors[leftID]?.parent?.order ?? null;
+    const rightOrder = zcomp.behaviors[rightID]?.parent?.order ?? null;
+    return generateKeyBetween(leftOrder, rightOrder);
 }
 export function addNodeLabelToRegister(zcomp, id) {
     const node = zcomp.nodes[id];
@@ -150,91 +262,14 @@ export function changeNodeScriptName(zcomp, id, newScriptName) {
         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)
+    if (!node || !node.parent)
         return;
-    const parent = findNodeParentAndIndex(zcomp, id);
-    fn(id, parent);
-    node.children.forEach(v => forEachNodeAndDescendant(zcomp, v.id, fn));
+    fn(node.parent.id);
+    forEachNodeAncestor(zcomp, node.parent.id, fn);
 }

package/lib/fractionalindexing.d.ts

@@ -0,0 +1,23 @@
+export declare const BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {string=} digits
+ * @return {string}
+ */
+export declare function generateKeyBetween(a: string | null, b: string | null, digits?: string): string;
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {number} n
+ * @param {string} digits
+ * @return {string[]}
+ */
+export declare function generateNKeysBetween(a: string | null, b: string | null, n: number, digits?: string): string[];

package/lib/fractionalindexing.js

@@ -0,0 +1,300 @@
+// License: CC0 (no rights reserved).
+// From https://github.com/rocicorp/fractional-indexing
+// This is based on https://observablehq.com/@dgreensp/implementing-fractional-indexing
+export const BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const SMALLEST_INTEGER = "A00000000000000000000000000";
+const INTEGER_ZERO = "a0";
+// `a` may be empty string, `b` is null or non-empty string.
+// `a < b` lexicographically if `b` is non-null.
+// no trailing zeros allowed.
+// digits is a string such as '0123456789' for base 10.  Digits must be in
+// ascending character code order!
+/**
+ * @param {string} a
+ * @param {string | null | undefined} b
+ * @param {string} digits
+ * @returns {string}
+ */
+function midpoint(a, b, digits) {
+    if (b != null && a >= b) {
+        throw new Error(a + " >= " + b);
+    }
+    if (a.slice(-1) === "0" || (b && b.slice(-1) === "0")) {
+        throw new Error("trailing zero");
+    }
+    if (b) {
+        // remove longest common prefix.  pad `a` with 0s as we
+        // go.  note that we don't need to pad `b`, because it can't
+        // end before `a` while traversing the common prefix.
+        let n = 0;
+        while ((a[n] || "0") === b[n]) {
+            n++;
+        }
+        if (n > 0) {
+            return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+        }
+    }
+    // first digits (or lack of digit) are different
+    const digitA = a ? digits.indexOf(a[0]) : 0;
+    const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+    if (digitB - digitA > 1) {
+        const midDigit = Math.round(0.5 * (digitA + digitB));
+        return digits[midDigit];
+    }
+    else {
+        // first digits are consecutive
+        if (b && b.length > 1) {
+            return b.slice(0, 1);
+        }
+        else {
+            // `b` is null or has length 1 (a single digit).
+            // the first digit of `a` is the previous digit to `b`,
+            // or 9 if `b` is null.
+            // given, for example, midpoint('49', '5'), return
+            // '4' + midpoint('9', null), which will become
+            // '4' + '9' + midpoint('', null), which is '495'
+            return digits[digitA] + midpoint(a.slice(1), null, digits);
+        }
+    }
+}
+/**
+ * @param {string} int
+ * @return {void}
+ */
+function validateInteger(int) {
+    if (int.length !== getIntegerLength(int[0])) {
+        throw new Error("invalid integer part of order key: " + int);
+    }
+}
+/**
+ * @param {string} head
+ * @return {number}
+ */
+function getIntegerLength(head) {
+    if (head >= "a" && head <= "z") {
+        return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
+    }
+    else if (head >= "A" && head <= "Z") {
+        return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
+    }
+    else {
+        throw new Error("invalid order key head: " + head);
+    }
+}
+/**
+ * @param {string} key
+ * @return {string}
+ */
+function getIntegerPart(key) {
+    const integerPartLength = getIntegerLength(key[0]);
+    if (integerPartLength > key.length) {
+        throw new Error("invalid order key: " + key);
+    }
+    return key.slice(0, integerPartLength);
+}
+/**
+ * @param {string} key
+ * @return {void}
+ */
+function validateOrderKey(key) {
+    if (key === SMALLEST_INTEGER) {
+        throw new Error("invalid order key: " + key);
+    }
+    // getIntegerPart will throw if the first character is bad,
+    // or the key is too short.  we'd call it to check these things
+    // even if we didn't need the result
+    const i = getIntegerPart(key);
+    const f = key.slice(i.length);
+    if (f.slice(-1) === "0") {
+        throw new Error("invalid order key: " + key);
+    }
+}
+// note that this may return null, as there is a largest integer
+/**
+ * @param {string} x
+ * @param {string} digits
+ * @return {string | null}
+ */
+function incrementInteger(x, digits) {
+    validateInteger(x);
+    const [head, ...digs] = x.split("");
+    let carry = true;
+    for (let i = digs.length - 1; carry && i >= 0; i--) {
+        const d = digits.indexOf(digs[i]) + 1;
+        if (d === digits.length) {
+            digs[i] = "0";
+        }
+        else {
+            digs[i] = digits[d];
+            carry = false;
+        }
+    }
+    if (carry) {
+        if (head === "Z") {
+            return "a0";
+        }
+        if (head === "z") {
+            return null;
+        }
+        const h = String.fromCharCode(head.charCodeAt(0) + 1);
+        if (h > "a") {
+            digs.push("0");
+        }
+        else {
+            digs.pop();
+        }
+        return h + digs.join("");
+    }
+    else {
+        return head + digs.join("");
+    }
+}
+// note that this may return null, as there is a smallest integer
+/**
+ * @param {string} x
+ * @param {string} digits
+ * @return {string | null}
+ */
+function decrementInteger(x, digits) {
+    validateInteger(x);
+    const [head, ...digs] = x.split("");
+    let borrow = true;
+    for (let i = digs.length - 1; borrow && i >= 0; i--) {
+        const d = digits.indexOf(digs[i]) - 1;
+        if (d === -1) {
+            digs[i] = digits.slice(-1);
+        }
+        else {
+            digs[i] = digits[d];
+            borrow = false;
+        }
+    }
+    if (borrow) {
+        if (head === "a") {
+            return "Z" + digits.slice(-1);
+        }
+        if (head === "A") {
+            return null;
+        }
+        const h = String.fromCharCode(head.charCodeAt(0) - 1);
+        if (h < "Z") {
+            digs.push(digits.slice(-1));
+        }
+        else {
+            digs.pop();
+        }
+        return h + digs.join("");
+    }
+    else {
+        return head + digs.join("");
+    }
+}
+// `a` is an order key or null (START).
+// `b` is an order key or null (END).
+// `a < b` lexicographically if both are non-null.
+// digits is a string such as '0123456789' for base 10.  Digits must be in
+// ascending character code order!
+/**
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {string=} digits
+ * @return {string}
+ */
+export function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
+    if (a != null) {
+        validateOrderKey(a);
+    }
+    if (b != null) {
+        validateOrderKey(b);
+    }
+    if (a != null && b != null && a >= b) {
+        throw new Error(a + " >= " + b);
+    }
+    if (a == null) {
+        if (b == null) {
+            return INTEGER_ZERO;
+        }
+        const ib = getIntegerPart(b);
+        const fb = b.slice(ib.length);
+        if (ib === SMALLEST_INTEGER) {
+            return ib + midpoint("", fb, digits);
+        }
+        if (ib < b) {
+            return ib;
+        }
+        const res = decrementInteger(ib, digits);
+        if (res == null) {
+            throw new Error("cannot decrement any more");
+        }
+        return res;
+    }
+    if (b == null) {
+        const ia = getIntegerPart(a);
+        const fa = a.slice(ia.length);
+        const i = incrementInteger(ia, digits);
+        return i == null ? ia + midpoint(fa, null, digits) : i;
+    }
+    const ia = getIntegerPart(a);
+    const fa = a.slice(ia.length);
+    const ib = getIntegerPart(b);
+    const fb = b.slice(ib.length);
+    if (ia === ib) {
+        return ia + midpoint(fa, fb, digits);
+    }
+    const i = incrementInteger(ia, digits);
+    if (i == null) {
+        throw new Error("cannot increment any more");
+    }
+    if (i < b) {
+        return i;
+    }
+    return ia + midpoint(fa, null, digits);
+}
+/**
+ * same preconditions as generateKeysBetween.
+ * n >= 0.
+ * Returns an array of n distinct keys in sorted order.
+ * If a and b are both null, returns [a0, a1, ...]
+ * If one or the other is null, returns consecutive "integer"
+ * keys.  Otherwise, returns relatively short keys between
+ * a and b.
+ * @param {string | null | undefined} a
+ * @param {string | null | undefined} b
+ * @param {number} n
+ * @param {string} digits
+ * @return {string[]}
+ */
+export function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
+    if (n === 0) {
+        return [];
+    }
+    if (n === 1) {
+        return [generateKeyBetween(a, b, digits)];
+    }
+    if (b == null) {
+        let c = generateKeyBetween(a, b, digits);
+        const result = [c];
+        for (let i = 0; i < n - 1; i++) {
+            c = generateKeyBetween(c, b, digits);
+            result.push(c);
+        }
+        return result;
+    }
+    if (a == null) {
+        let c = generateKeyBetween(a, b, digits);
+        const result = [c];
+        for (let i = 0; i < n - 1; i++) {
+            c = generateKeyBetween(a, c, digits);
+            result.push(c);
+        }
+        result.reverse();
+        return result;
+    }
+    const mid = Math.floor(n / 2);
+    const c = generateKeyBetween(a, b, digits);
+    return [
+        ...generateNKeysBetween(a, c, mid, digits),
+        c,
+        ...generateNKeysBetween(c, b, n - mid - 1, digits),
+    ];
+}

package/lib/interfaces.d.ts

@@ -17,6 +17,9 @@ export type BehaviorByID = {
 export type Props = {
     [id: string]: Prop;
 };
+export type ComputedHierarchy = {
+    [id: string]: string[];
+};
 export type Import = string;
 export type ParsedImport = [string, string];
 export type ElementType = Import;
@@ -37,9 +40,6 @@ export interface ZComponentData {
         };
     };
     behaviors: BehaviorByID;
-    behaviorsByNode: {
-        [nodeId: string]: string[];
-    };
     animation?: Animation;
     entitiesByLabel?: {
         [id: string]: {
@@ -57,11 +57,16 @@ export interface NodeData {
     label?: string;
     scriptName?: string;
     type: ElementType;
-    parent?: string;
-    children: Child[];
+    parent?: {
+        id: string;
+        order: string;
+    };
 }
 export interface BehaviorData {
     id: string;
     type: Import;
-    nodeId?: string;
+    parent: {
+        id: string;
+        order: string;
+    };
 }

package/lib/validators.js

@@ -11,7 +11,6 @@ export const validatorZcomponentTopLevel = (url, component) => {
         typeof component.entityConstructorProps !== 'object' ||
         typeof component.entityProps !== 'object' ||
         typeof component.behaviors !== 'object' ||
-        typeof component.behaviorsByNode !== 'object' ||
         typeof component.id !== 'string' ||
         typeof component.root !== 'string') {
         return [{ text: 'Component structure is invalid' }];
@@ -23,10 +22,16 @@ export const validatorZcomponentTopLevel = (url, component) => {
     return [];
 };
 export const validatorZcomponentComponent = (node, nodeId) => {
-    if (typeof node !== 'object' || !Array.isArray(node.children))
-        return [{ text: 'Component structure ID has zero length' }];
+    if (typeof node !== 'object')
+        return [{ text: 'Node not object' }];
     if (node.id !== nodeId)
-        return [{ text: 'Component ID mismatch' }];
+        return [{ text: 'Node ID mismatch' }];
+    if (node.parent !== undefined && typeof node.parent !== 'object')
+        return [{ text: 'Node parent invalid' }];
+    if (node.parent !== undefined && typeof node.parent.id !== 'string')
+        return [{ text: 'Node parent ID invalid' }];
+    if (node.parent !== undefined && typeof node.parent.order !== 'string')
+        return [{ text: 'Node parent order invalid' }];
     const issues = validateImport(node.type);
     return issues;
 };

package/lib/zcomponent.js

@@ -3,6 +3,7 @@ import { Component } from './component';
 import { Context } from './context';
 import { isDesignTime } from './contexts/environmentcontext';
 import { TagContext } from './contexts/tagcontext';
+import { computeBehaviorHierarchy, computeNodeHierarchy } from './data';
 import { Observable } from './observable';
 import { setCurrentZComponentConstruction } from './zcomponentconstruction';
 export class ZComponentContext extends Context {
@@ -53,8 +54,9 @@ export class ZComponent extends Component {
             constructor(contextManager, constructorProps) {
                 that._opts.onConstructingNode?.(nodeId);
                 const children = constructorProps.children ?? [];
-                for (const child of node?.children ?? []) {
-                    const childInstance = that._constructorForNode(child.id);
+                const childIDs = computeNodeHierarchy(that._opts.data.nodes)[nodeId] ?? [];
+                for (const childID of childIDs) {
+                    const childInstance = that._constructorForNode(childID);
                     if (childInstance)
                         children.push([childInstance, {}]);
                 }
@@ -169,11 +171,18 @@ export class ZComponent extends Component {
         this._behaviorsToInitialize = [];
     }
     _wrapBehaviors(nodeID, impl, ctx) {
-        const behaviors = this._opts.data.behaviorsByNode?.[nodeID] ?? [];
+        const behaviors = computeBehaviorHierarchy(this._opts.data.behaviors)[nodeID] ?? [];
         for (const behaviorID of behaviors) {
-            const constructor = this._constructorForBehavior(behaviorID);
-            if (constructor)
-                new constructor(ctx, impl);
+            try {
+                const constructor = this._constructorForBehavior(behaviorID);
+                if (constructor)
+                    new constructor(ctx, impl);
+            }
+            catch (err) {
+                const nodeName = this._opts.data.nodes[nodeID]?.label ?? "Unknown node";
+                const behaviorType = this._opts.data.behaviors[behaviorID]?.type;
+                console.log('An error occurred when constructing behavior of type:', behaviorType, 'for node:', nodeName, err);
+            }
         }
     }
     notifyPropsChanged(entries) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",