@amodx/ncs 0.0.1 → 0.0.21

package/Nodes/NodeCursor.js

@@ -0,0 +1,348 @@
+import { NodeId } from "./NodeId";
+import { NodeEvents } from "./NodeEvents";
+import { NodeObservers } from "./NodeObservers";
+import { NodeContext } from "./NodeContext";
+import { NodeComponents } from "./NodeComponents";
+import { NodeTags } from "./NodeTags";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { TagCursor } from "../Tags/TagCursor";
+import { NCSPools } from "../Pools/NCSPools";
+export class NodeCursor {
+    static Get() {
+        const cursor = NCSPools.nodeCursor.get();
+        if (!cursor)
+            return new NodeCursor();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        cursor.clear(cursor.hasEvents, cursor.hasContexts, cursor.hasObservers, cursor.hasComponents, cursor.hasTags);
+        NCSPools.nodeCursor.addItem(cursor);
+    }
+    clear(events, context, observers, compoents, tags) {
+        if (events && this._events) {
+            NodeEvents.Retrun(this._events);
+            this._events = null;
+        }
+        if (context && this._components) {
+            NodeComponents.Retrun(this._components);
+            this._components = null;
+        }
+        if (observers && this._observers) {
+            NodeObservers.Retrun(this._observers);
+            this._observers = null;
+        }
+        if (compoents && this._components) {
+            NodeComponents.Retrun(this._components);
+            this._components = null;
+        }
+        if (tags && this._tags) {
+            NodeTags.Retrun(this._tags);
+            this._tags = null;
+        }
+    }
+    get index() {
+        return this._index;
+    }
+    get parentIndex() {
+        return this.arrays._parents[this._index];
+    }
+    get id() {
+        return this.graph._nodes._indexMap[this.index] || null;
+    }
+    get name() {
+        return this.arrays._names[this._index];
+    }
+    _events = null;
+    get events() {
+        if (!this._events) {
+            this._events = NodeEvents.Get();
+        }
+        this._events.node = this;
+        return this._events;
+    }
+    get hasEvents() {
+        return this._events !== null;
+    }
+    _context = null;
+    get context() {
+        if (!this._context) {
+            this._context = NodeContext.Get();
+        }
+        this._context.node = this;
+        return this._context;
+    }
+    get hasContexts() {
+        return this._context !== null;
+    }
+    _observers = null;
+    get observers() {
+        if (!this._observers) {
+            this._observers = NodeObservers.Get();
+        }
+        this._observers.node = this;
+        return this._observers;
+    }
+    get hasObservers() {
+        return this.arrays._hasObservers[this._index];
+    }
+    _components = null;
+    get components() {
+        if (!this._components) {
+            this._components = NodeComponents.Get();
+        }
+        this._components.node = this;
+        return this._components;
+    }
+    get hasComponents() {
+        return this._components !== null;
+    }
+    _tags = null;
+    get tags() {
+        if (!this._tags) {
+            this._tags = NodeTags.Get();
+        }
+        this._tags.node = this;
+        return this._tags;
+    }
+    get hasTags() {
+        return this._tags !== null;
+    }
+    get childrenArray() {
+        return this.arrays._children[this._index] || null;
+    }
+    get parent() {
+        return this.arrays._parents[this._index];
+    }
+    set parent(value) {
+        this.arrays._parents[this._index] = value;
+    }
+    graph;
+    get arrays() {
+        return this.graph._nodes;
+    }
+    get enabled() {
+        return this.arrays._enabled[this._index];
+    }
+    set enabled(enabled) {
+        this.arrays._enabled[this._index] = enabled;
+        if (this.hasObservers) {
+            this.observers.isEnabledSet && this.observers.enabled.notify(enabled);
+        }
+    }
+    get isDisposed() {
+        return this.arrays._disposed[this._index];
+    }
+    _index = 0;
+    constructor() { }
+    setNode(graph, index) {
+        this._index = index;
+        this.graph = graph;
+        if (this.arrays._components[index] !== undefined) {
+            this._components = NodeComponents.Get();
+            this._components.node = this;
+        }
+        else {
+            if (this._components)
+                NodeComponents.Retrun(this._components);
+            this._components = null;
+        }
+        if (this.arrays._tags[index] !== undefined) {
+            this._tags = NodeTags.Get();
+            this._tags.node = this;
+        }
+        else {
+            if (this._tags)
+                NodeTags.Retrun(this._tags);
+            this._tags = null;
+        }
+        if (this.arrays._context[index] !== undefined) {
+            this._context = NodeContext.Get();
+            this._context.node = this;
+        }
+        else {
+            if (this._context)
+                NodeContext.Retrun(this._context);
+            this._context = null;
+        }
+        return this;
+    }
+    toRef(cursor = new NodeCursor()) {
+        return cursor.setNode(this.graph, this.index);
+    }
+    /** Traverse the node's direct children */
+    *children(cursor = nodeCursor) {
+        const array = this.childrenArray;
+        if (!array)
+            return false;
+        for (let i = 0; i < array.length; i++) {
+            cursor.setNode(this.graph, array[i]);
+            yield cursor;
+        }
+        return true;
+    }
+    /** Traverse all the node's descendants */
+    *traverseChildren(cursor = nodeCursor) {
+        if (!this.childrenArray)
+            return false;
+        const children = [this.childrenArray];
+        while (children.length) {
+            const childrenArray = children.shift();
+            if (!childrenArray)
+                continue;
+            for (let i = 0; i < childrenArray.length; i++) {
+                cursor.setNode(this.graph, childrenArray[i]);
+                yield cursor;
+                if (this.arrays._children[childrenArray[i]] !== undefined) {
+                    children.push(this.arrays._children[childrenArray[i]]);
+                }
+            }
+        }
+        return true;
+    }
+    /** Traverse all the node's parents */
+    *traverseParents(cursor = nodeCursor) {
+        let parent = this.parent;
+        if (parent === undefined || parent < 0)
+            return false;
+        while (true) {
+            cursor.setNode(this.graph, parent);
+            yield cursor;
+            parent = this.arrays._parents[cursor._index];
+            if (parent === undefined || parent < 0)
+                return true;
+        }
+    }
+    /** Traverse all the node's components */
+    *traverseComponents(cursor = componentCursor) {
+        const components = this.components.components;
+        if (!components)
+            return false;
+        for (let i = 0; i < components.length; i += 2) {
+            yield cursor.setInstance(this, components[i], components[i + 1]);
+        }
+        return true;
+    }
+    /** Traverse all the node's tags */
+    *traverseTags(cursor = tagCursor) {
+        const tags = this.tags.tags;
+        if (!this.tags)
+            return false;
+        for (let i = 0; i < tags.length; i += 2) {
+            yield cursor.setTag(this, tags[i], tags[i + 1]);
+        }
+        return true;
+    }
+    dispose() {
+        if (this.isDisposed)
+            return;
+        this.hasObservers &&
+            this.observers.isDisposedSet &&
+            this.observers.disposed.notify(this);
+        if (this.parent !== undefined) {
+            nodeCursor.setNode(this.graph, this.parent);
+            nodeCursor.removeChild(this.index);
+        }
+        if (this.arrays._components[this._index]?.length) {
+            this.components.dispose();
+        }
+        if (this.arrays._tags[this._index]?.length) {
+            this.tags.dispose();
+        }
+        if (this.childrenArray) {
+            for (let i = 0; i < this.childrenArray.length; i++) {
+                nodeCursor.setNode(this.graph, this.childrenArray[i]);
+                nodeCursor.dispose();
+            }
+        }
+        this.graph.removeNode(this.index);
+        this.clear(this.hasEvents, this.hasContexts, this.hasObservers, this.hasComponents, this.hasTags);
+    }
+    hasChild(node) {
+        if (!this.childrenArray)
+            return false;
+        for (let i = 0; i < this.childrenArray.length; i++) {
+            if (this.childrenArray[i] == node.index)
+                return true;
+        }
+        return false;
+    }
+    parentTo(nodeToParentTo) {
+        if (nodeToParentTo.hasChild(this))
+            return;
+        if (this.parent !== undefined) {
+            nodeCursor.setNode(this.graph, this.parent);
+            nodeCursor.removeChild(this.index);
+        }
+        nodeToParentTo.addChild(this);
+        this.parent = nodeToParentTo.index;
+        this.hasObservers &&
+            this.observers.isParentedSet &&
+            nodeToParentTo.observers.parented.notify(nodeCursor);
+    }
+    getChild(index, cursor = NodeCursor.Get()) {
+        const childrenArray = this.childrenArray;
+        if (!childrenArray || childrenArray[index] === undefined)
+            return null;
+        return cursor.setNode(this.graph, childrenArray[index]);
+    }
+    addChild(node) {
+        if (this.hasChild(node))
+            return;
+        if (!this.childrenArray) {
+            this.arrays._children[this._index] = NCSPools.numberArray.get() || [];
+        }
+        node.parent = this.index;
+        this.childrenArray.push(node.index);
+        if (this.hasObservers) {
+            this.observers.isChildAddedSet &&
+                this.observers.childAdded.notify(node);
+            this.observers.isChildrenUpdatedSet &&
+                this.observers.childrenUpdated.notify(node);
+        }
+        if (node.hasObservers) {
+            node.observers.isParentedSet && node.observers.parented.notify(node);
+        }
+    }
+    removeChild(index) {
+        if (!this.childrenArray)
+            return;
+        for (let i = 0; i < this.childrenArray.length; i++) {
+            if (this.childrenArray[i] == index) {
+                const child = this.childrenArray.splice(i, 1)[0];
+                nodeCursor.setNode(this.graph, child);
+                if (this.hasObservers) {
+                    this.hasObservers &&
+                        this.observers.isChildRemovedSet &&
+                        this.observers.childRemoved.notify(nodeCursor);
+                    this.hasObservers &&
+                        this.observers.isChildrenUpdatedSet &&
+                        this.observers.childrenUpdated.notify(nodeCursor);
+                }
+                if (nodeCursor.hasObservers) {
+                    nodeCursor.observers.isRemovedFromParentSet &&
+                        nodeCursor.observers.removedFromParent.notify(nodeCursor);
+                }
+                return child;
+            }
+        }
+        return null;
+    }
+    addUniqueId() {
+        let id = this.graph._nodes._indexMap[this.index];
+        if (!id)
+            id = NodeId.Create();
+        this.graph._nodes.addNodeId(this.index, id);
+        return id;
+    }
+    returnCursor() {
+        return NodeCursor.Retrun(this);
+    }
+    cloneCursor(cursor) {
+        const newCursor = cursor || NodeCursor.Get();
+        newCursor.setNode(this.graph, this._index);
+        return newCursor;
+    }
+}
+const componentCursor = ComponentCursor.Get();
+const tagCursor = TagCursor.Get();
+const nodeCursor = NodeCursor.Get();

package/Nodes/NodeEvents.d.ts

@@ -1,25 +1,24 @@
-import { Observable } from "@amodx/core/Observers";
-import { NodeInstance } from "./NodeInstance";
+import { Observable, ObservableFunction } from "../Util/Observable";
+import { NodeCursor } from "./NodeCursor";
 export declare class NodeEventCursor {
     id: string;
-    node: NodeInstance;
+    node: NodeCursor;
     data: any;
 }
-declare class NodeEventsObservers {
-    eventTypeAdded: Observable<string>;
-    eventDispatched: Observable<NodeEventCursor>;
-}
 export declare class NodeEvents {
-    node: NodeInstance;
-    observers: NodeEventsObservers;
+    static Get(): NodeEvents;
+    static Retrun(cursor: NodeEvents): boolean;
+    get events(): Observable<any>[][];
+    get index(): number;
+    node: NodeCursor;
     private cursor;
-    private events;
-    constructor(node: NodeInstance);
+    private constructor();
     hasListener(id: string): boolean;
     clearListeners(id: string): false | undefined;
-    addListener<Data>(id: string, run: (data: Data) => void): void;
-    removeListener(id: string, run: Function): boolean;
+    addListener<Data>(id: string, run: (data: Data) => void, options?: {
+        once?: boolean;
+    }): void;
+    removeListener(id: string, run: ObservableFunction<any>): boolean;
     dispatch<Data>(id: string, data: Data): boolean;
     dispatchDeep<Data>(id: string, data: Data): void;
 }
-export {};

package/Nodes/NodeEvents.js

@@ -1,57 +1,87 @@
-import { Observable } from "@amodx/core/Observers";
+import { NCSPools } from "../Pools/NCSPools";
+import { Observable } from "../Util/Observable";
 export class NodeEventCursor {
     id;
     node;
     data;
 }
-class NodeEventsObservers {
-    eventTypeAdded = new Observable();
-    eventDispatched = new Observable();
-}
 export class NodeEvents {
+    static Get() {
+        const cursor = NCSPools.nodeEvents.get();
+        if (!cursor)
+            return new NodeEvents();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.nodeEvents.addItem(cursor);
+    }
+    get events() {
+        return this.node.arrays._events;
+    }
+    get index() {
+        return this.node.index;
+    }
     node;
-    observers = new NodeEventsObservers();
     cursor = new NodeEventCursor();
-    events = new Map();
-    constructor(node) {
-        this.node = node;
-    }
+    constructor() { }
     hasListener(id) {
-        return this.events.has(id);
+        const numberId = this.node.arrays._eventPalette.getNumberId(id);
+        if (numberId === undefined)
+            return false;
+        return this.node.arrays._events[numberId][this.index] !== undefined;
     }
     clearListeners(id) {
-        let observer = this.events.get(id);
+        const numberId = this.node.arrays._eventPalette.getNumberId(id);
+        if (numberId === undefined)
+            return false;
+        let observer = this.node.arrays._events[numberId]?.[this.index];
         if (!observer)
             return false;
         observer.clear();
+        NCSPools.observers.addItem(observer);
+        this.node.arrays._events[numberId][this.index] = undefined;
     }
-    addListener(id, run) {
-        let observer = this.events.get(id);
+    addListener(id, run, options) {
+        const numberId = this.node.arrays._eventPalette.isRegistered(id)
+            ? this.node.arrays._eventPalette.getNumberId(id)
+            : this.node.arrays._eventPalette.register(id);
+        let observers = this.node.arrays._events[numberId];
+        if (!observers) {
+            observers = [];
+            this.node.arrays._events[numberId] = observers;
+        }
+        let observer = observers[this.index];
         if (!observer) {
-            observer = new Observable();
-            this.events.set(id, observer);
-            this.observers.eventTypeAdded.notify(id);
+            observer = NCSPools.observers.get() || new Observable();
+            observers[this.index] = observer;
+        }
+        if (options?.once) {
+            observer.subscribeOnce(run);
+        }
+        else {
+            observer.subscribe(run);
         }
-        observer.subscribe(run);
     }
     removeListener(id, run) {
-        let observer = this.events.get(id);
-        if (!observer)
+        const numberId = this.node.arrays._eventPalette.getNumberId(id);
+        if (numberId === undefined)
             return false;
-        observer.unsubscribe(run);
+        let observers = this.node.arrays._events[numberId];
+        if (!observers || !observers[this.index])
+            return false;
+        observers[this.index].unsubscribe(run);
         return true;
     }
     dispatch(id, data) {
-        let observer = this.events.get(id);
-        if (!observer)
+        const numberId = this.node.arrays._eventPalette.getNumberId(id);
+        if (numberId === undefined)
             return false;
-        observer.notify(data);
+        let observers = this.node.arrays._events[numberId];
+        if (!observers || !observers[this.index])
+            return false;
+        observers[this.index].notify(data);
         this.cursor.id = id;
         this.cursor.data = data;
-        this.observers.eventDispatched.notify(this.cursor);
-        if (this.node.graph.events.hasListener(id)) {
-            this.node.graph.events.dispatch(id, this.cursor);
-        }
         return true;
     }
     dispatchDeep(id, data) {

package/Nodes/NodeId.d.ts

@@ -1,15 +1,6 @@
 export declare class NodeId {
-    high: bigint;
-    low: bigint;
-    private _idString;
-    get idString(): string;
-    set idString(id: string);
-    private constructor();
-    static Compare(id: NodeId, id2: NodeId): boolean;
-    static Create(id?: string): NodeId;
-    static FromString(id: string): {
-        high: bigint;
-        low: bigint;
-    };
-    static ToHexString(id: NodeId): string;
+    static Create(): bigint;
+    static CreateString(): string;
+    static FromString(id: string): bigint;
+    static ToHexString(id: BigInt): string;
 }

package/Nodes/NodeId.js

@@ -1,56 +1,24 @@
+const buffer = new ArrayBuffer(16);
+const randomArray = new Uint8Array(buffer);
+const view = new DataView(buffer);
 export class NodeId {
-    high;
-    low;
-    _idString = "";
-    get idString() {
-        if (!this._idString)
-            this._idString = NodeId.ToHexString(this);
-        return this._idString;
+    static Create() {
+        crypto.getRandomValues(randomArray);
+        const high = BigInt(view.getUint32(0)) << 96n;
+        const midHigh = BigInt(view.getUint32(4)) << 64n;
+        const midLow = BigInt(view.getUint32(8)) << 32n;
+        const low = BigInt(view.getUint32(12));
+        const bigIntId = high | midHigh | midLow | low;
+        return bigIntId;
     }
-    set idString(id) {
-        this._idString = id;
-    }
-    constructor(low, high) {
-        this.low = low;
-        this.high = high;
-    }
-    static Compare(id, id2) {
-        return id.low == id2.low && id.high == id2.high;
-    }
-    static Create(id) {
-        if (id) {
-            const { high, low } = NodeId.FromString(id);
-            return new NodeId(low, high);
-        }
-        else {
-            const array = new Uint8Array(16);
-            crypto.getRandomValues(array);
-            const high = (BigInt(array[0]) << 56n) |
-                (BigInt(array[1]) << 48n) |
-                (BigInt(array[2]) << 40n) |
-                (BigInt(array[3]) << 32n) |
-                (BigInt(array[4]) << 24n) |
-                (BigInt(array[5]) << 16n) |
-                (BigInt(array[6]) << 8n) |
-                BigInt(array[7]);
-            const low = (BigInt(array[8]) << 56n) |
-                (BigInt(array[9]) << 48n) |
-                (BigInt(array[10]) << 40n) |
-                (BigInt(array[11]) << 32n) |
-                (BigInt(array[12]) << 24n) |
-                (BigInt(array[13]) << 16n) |
-                (BigInt(array[14]) << 8n) |
-                BigInt(array[15]);
-            return new NodeId(low, high);
-        }
+    static CreateString() {
+        return this.ToHexString(this.Create());
     }
     static FromString(id) {
-        const high = BigInt("0x" + id.slice(0, 16));
-        const low = BigInt("0x" + id.slice(16, 32));
-        return { high, low };
+        const bigIntId = BigInt("0x" + id);
+        return bigIntId;
     }
     static ToHexString(id) {
-        return (id.high.toString(16).padStart(16, "0") +
-            id.low.toString(16).padStart(16, "0"));
+        return id.toString(16).padStart(32, "0");
     }
 }

package/Nodes/NodeObservers.d.ts

@@ -1,24 +1,39 @@
-import { Observable } from "@amodx/core/Observers";
-import { NodeInstance } from "./NodeInstance";
+import { Observable } from "../Util/Observable";
+import { NodeCursor } from "./NodeCursor";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { TagCursor } from "../Tags/TagCursor";
 export interface NodeObservers {
 }
 export declare class NodeObservers {
-    private _disposed?;
-    private _parented?;
-    private _removedFromParent?;
-    private _childAdded?;
-    private _childRemoved?;
-    private _childrenUpdated?;
-    get disposed(): Observable<void>;
-    get parented(): Observable<void>;
-    get removedFromParent(): Observable<void>;
-    get childAdded(): Observable<NodeInstance>;
-    get childRemoved(): Observable<NodeInstance>;
-    get childrenUpdated(): Observable<void>;
-    isDisposedSet(): boolean;
-    isParentedSet(): boolean;
-    isRemovedFromParentSet(): boolean;
-    isChildAddedSet(): boolean;
-    isChildRemovedSet(): boolean;
-    isChildrenUpdatedSet(): boolean;
+    node: NodeCursor;
+    static Get(): NodeObservers;
+    static Retrun(cursor: NodeObservers): boolean;
+    private constructor();
+    get observers(): Observable<any>[][];
+    get disposed(): Observable<any>;
+    get enabled(): Observable<any>;
+    get parented(): Observable<any>;
+    get removedFromParent(): Observable<any>;
+    get childAdded(): Observable<NodeCursor>;
+    get childRemoved(): Observable<NodeCursor>;
+    get childrenUpdated(): Observable<any>;
+    get isDisposedSet(): boolean;
+    get isEnabledSet(): boolean;
+    get isParentedSet(): boolean;
+    get isRemovedFromParentSet(): boolean;
+    get isChildAddedSet(): boolean;
+    get isChildRemovedSet(): boolean;
+    get isChildrenUpdatedSet(): boolean;
+    get componentAdded(): Observable<ComponentCursor>;
+    get componentRemoved(): Observable<ComponentCursor>;
+    get componentsUpdated(): Observable<any>;
+    get isComponentAddedSet(): boolean;
+    get isComponentRemovedSet(): boolean;
+    get isComponentsUpdatedSet(): boolean;
+    get tagsAdded(): Observable<TagCursor>;
+    get tagsRemoved(): Observable<TagCursor>;
+    get tagsUpdated(): Observable<any>;
+    get isTagsAddedSet(): boolean;
+    get isTagsRemovedSet(): boolean;
+    get isTagsUpdatedSet(): boolean;
 }