@amodx/ncs 0.0.1 → 0.0.2

package/Nodes/Node.types.d.ts

@@ -0,0 +1,39 @@
+import { CreateComponentData } from "../Components/Component.types";
+export type CreateNodeData = [
+    /**
+     * The unique 128 bit identifier of the node.
+     *
+     */
+    id: bigint | string | null,
+    /**
+     * The name of the node.
+     */
+    name: string,
+    /**
+     * The components of the node.
+     */
+    components: CreateComponentData[] | null,
+    /**
+     * The tags of the node.
+     */
+    tags: number[] | null,
+    /**
+     * The children nodes of the node.
+     */
+    children: CreateNodeData[] | null
+];
+export declare enum NodeObserverIds {
+    Disposed = 0,
+    Enabled = 1,
+    Parented = 2,
+    RemovedFromParent = 3,
+    ChildAdded = 4,
+    ChildRemoved = 5,
+    ChildrenUpdated = 6,
+    ComponentAdded = 7,
+    ComponentRemoved = 8,
+    ComponentsUpdated = 9,
+    TagAdded = 10,
+    TagRemoved = 11,
+    TagsUpdated = 12
+}

package/Nodes/Node.types.js

@@ -0,0 +1,16 @@
+export var NodeObserverIds;
+(function (NodeObserverIds) {
+    NodeObserverIds[NodeObserverIds["Disposed"] = 0] = "Disposed";
+    NodeObserverIds[NodeObserverIds["Enabled"] = 1] = "Enabled";
+    NodeObserverIds[NodeObserverIds["Parented"] = 2] = "Parented";
+    NodeObserverIds[NodeObserverIds["RemovedFromParent"] = 3] = "RemovedFromParent";
+    NodeObserverIds[NodeObserverIds["ChildAdded"] = 4] = "ChildAdded";
+    NodeObserverIds[NodeObserverIds["ChildRemoved"] = 5] = "ChildRemoved";
+    NodeObserverIds[NodeObserverIds["ChildrenUpdated"] = 6] = "ChildrenUpdated";
+    NodeObserverIds[NodeObserverIds["ComponentAdded"] = 7] = "ComponentAdded";
+    NodeObserverIds[NodeObserverIds["ComponentRemoved"] = 8] = "ComponentRemoved";
+    NodeObserverIds[NodeObserverIds["ComponentsUpdated"] = 9] = "ComponentsUpdated";
+    NodeObserverIds[NodeObserverIds["TagAdded"] = 10] = "TagAdded";
+    NodeObserverIds[NodeObserverIds["TagRemoved"] = 11] = "TagRemoved";
+    NodeObserverIds[NodeObserverIds["TagsUpdated"] = 12] = "TagsUpdated";
+})(NodeObserverIds || (NodeObserverIds = {}));

package/Nodes/NodeArray.d.ts

@@ -0,0 +1,25 @@
+import { IdPalette } from "../Util/IdPalette";
+import { Observable } from "../Util/Observable";
+export declare class NodeArray {
+    _freeSlots: number[];
+    _eventPalette: IdPalette;
+    /**A map of node ids to their index in the run time array */
+    _idMap: Map<bigint, number>;
+    /**A map of node run time indexes to their unique id */
+    _indexMap: bigint[];
+    _names: string[];
+    _events: Observable<any>[][];
+    _observers: Observable<any>[][];
+    _parents: number[];
+    _children: number[][];
+    _components: number[][];
+    _tags: number[][];
+    _context: number[][];
+    _disposed: boolean[];
+    _enabled: boolean[];
+    _hasObservers: boolean[];
+    addNode(id: bigint | null, parent: number, name: string): number;
+    removeNode(slot: number): boolean;
+    addNodeId(index: number, id: bigint): void;
+    removeNodeId(id: bigint): void;
+}

package/Nodes/NodeArray.js

@@ -0,0 +1,96 @@
+import { IdPalette } from "../Util/IdPalette";
+import { NCSPools } from "../Pools/NCSPools";
+import { NodeObserverIds } from "./Node.types";
+const observerValues = Object.values(NodeObserverIds)
+    .map((_) => Number(_))
+    .filter((v) => !Number.isNaN(v));
+const observersArrays = [];
+for (let i = 0; i < observerValues.length; i++) {
+    observersArrays[observerValues[i]] = [];
+}
+export class NodeArray {
+    _freeSlots = [];
+    _eventPalette = new IdPalette();
+    /**A map of node ids to their index in the run time array */
+    _idMap = new Map();
+    /**A map of node run time indexes to their unique id */
+    _indexMap = [];
+    _names = [];
+    _events = [];
+    _observers = structuredClone(observersArrays);
+    _parents = [];
+    _children = [];
+    _components = [];
+    _tags = [];
+    _context = [];
+    _disposed = [];
+    _enabled = [];
+    _hasObservers = [];
+    addNode(id, parent, name) {
+        let slot = this._freeSlots.length
+            ? this._freeSlots.shift()
+            : this._parents.length;
+        id && this.addNodeId(slot, id);
+        this._parents[slot] = parent;
+        this._names[slot] = name;
+        this._disposed[slot] = false;
+        this._enabled[slot] = true;
+        this._hasObservers[slot] = false;
+        return slot;
+    }
+    removeNode(slot) {
+        if (this._parents[slot] === undefined)
+            return false;
+        this._freeSlots.push(slot);
+        this._indexMap[slot] && this.removeNodeId(this._indexMap[slot]);
+        this._parents[slot] = -1;
+        this._names[slot] = "";
+        this._disposed[slot] = true;
+        this._enabled[slot] = false;
+        this._hasObservers[slot] = false;
+        for (let i = 0; i < observerValues.length; i++) {
+            const observer = this._observers[i][slot];
+            if (observer !== undefined) {
+                NCSPools.observers.addItem(observer);
+                this._events[i][slot] = undefined;
+            }
+        }
+        for (let i = 0; i < this._eventPalette.size; i++) {
+            const observer = this._events[i][slot];
+            if (observer !== undefined) {
+                NCSPools.observers.addItem(observer);
+                this._events[i][slot] = undefined;
+            }
+        }
+        if (this._children[slot] !== undefined) {
+            this._children[slot].length = 0;
+            NCSPools.numberArray.addItem(this._children[slot]);
+            this._children[slot] = undefined;
+        }
+        if (this._components[slot] !== undefined) {
+            this._components[slot].length = 0;
+            NCSPools.numberArray.addItem(this._components[slot]);
+            this._components[slot] = undefined;
+        }
+        if (this._tags[slot] !== undefined) {
+            this._tags[slot].length = 0;
+            NCSPools.numberArray.addItem(this._tags[slot]);
+            this._tags[slot] = undefined;
+        }
+        if (this._context[slot] !== undefined) {
+            this._context[slot].length = 0;
+            NCSPools.numberArray.addItem(this._context[slot]);
+            this._context[slot] = undefined;
+        }
+        return true;
+    }
+    addNodeId(index, id) {
+        this._idMap.set(id, index);
+        this._indexMap[index] = id;
+    }
+    removeNodeId(id) {
+        const index = this._idMap.get(id);
+        this._indexMap[index] = undefined;
+        this._idMap.delete(id);
+    }
+}

package/Nodes/NodeComponents.d.ts

@@ -0,0 +1,19 @@
+import { CreateComponentData } from "../Components/Component.types";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { NodeCursor } from "./NodeCursor";
+export declare class NodeComponents {
+    static Get(): NodeComponents;
+    static Retrun(cursor: NodeComponents): boolean;
+    get components(): number[];
+    node: NodeCursor;
+    private constructor();
+    dispose(): void;
+    add(comp: CreateComponentData): number;
+    remove(type: string): true | undefined;
+    has(type: string): boolean;
+    get(type: string, cursor?: ComponentCursor<{}, any, any>): ComponentCursor<any, any, any> | null;
+    getAll(type: string): ComponentCursor<any, any, any>[];
+    removeAll(type: string): boolean;
+    getChild(type: string, cursor?: ComponentCursor<{}, any, any>): ComponentCursor<any, any, any> | null;
+    getParent(type: string, cursor?: ComponentCursor<{}, any, any>): ComponentCursor<any, any, any> | null;
+}

package/Nodes/NodeComponents.js

@@ -0,0 +1,180 @@
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { NCSRegister } from "../Register/NCSRegister";
+import { ComponentArray } from "../Components/ComponentArray";
+import { NCSPools } from "../Pools/NCSPools";
+const defaultCursor = ComponentCursor.Get();
+export class NodeComponents {
+    static Get() {
+        const cursor = NCSPools.nodeComponents.get();
+        if (!cursor)
+            return new NodeComponents();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.nodeComponents.addItem(cursor);
+    }
+    get components() {
+        return this.node.arrays._components[this.node.index] || null;
+    }
+    node;
+    constructor() { }
+    dispose() {
+        if (!this.components)
+            return;
+        const components = this.components;
+        for (let i = 0; i < components.length; i += 2) {
+            defaultCursor.setInstance(this.node, components[i], components[i + 1]);
+            defaultCursor.dispose();
+        }
+    }
+    add(comp) {
+        if (!this.components) {
+            this.node.arrays._components[this.node.index] =
+                NCSPools.numberArray.get() || [];
+        }
+        const compProto = NCSRegister.components.get(comp[0]);
+        const typeId = NCSRegister.components.idPalette.getNumberId(compProto.type);
+        let compArray = this.node.graph._components[typeId];
+        if (!compArray) {
+            compArray = new ComponentArray(this.node.graph, typeId);
+            if (compArray.proto.update) {
+                this.node.graph._updatingComponents.push(compArray);
+            }
+            this.node.graph._components[typeId] = compArray;
+        }
+        let compData = null;
+        if (comp[3]) {
+            compData = compArray.schemaArray.schema
+                .getView(comp[2] || "default")
+                .fromRemote(comp[1]);
+        }
+        else {
+            compData = compProto.schema
+                ? compProto.schema.getView(comp[2] || "default")?.createData(comp[1]) ||
+                    null
+                : null;
+        }
+        const componentIndex = compArray.addComponent(this.node.index, compData, comp[2] || "default");
+        comp[0] = "";
+        comp[1] = null;
+        comp[2] = null;
+        comp[3] = null;
+        NCSPools.createComponentData.addItem(comp);
+        this.components.push(typeId, componentIndex);
+        compArray.observers.nodeAdded.notify(this.node.index);
+        if (this.node.hasObservers) {
+            defaultCursor.setInstance(this.node, typeId, componentIndex);
+            this.node.observers.isComponentAddedSet &&
+                this.node.observers.componentAdded.notify(defaultCursor);
+            this.node.observers.isComponentsUpdatedSet &&
+                this.node.observers.componentsUpdated.notify(defaultCursor);
+        }
+        return componentIndex;
+    }
+    remove(type) {
+        const components = this.components;
+        if (!components)
+            return;
+        let removeIndex = -1;
+        let removeComponentIndex = -1;
+        const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        for (let i = 0; i < components.length; i += 2) {
+            if (components[i] == numberId) {
+                removeIndex = i;
+                removeComponentIndex = components[i + 1];
+                break;
+            }
+        }
+        if (removeIndex == -1)
+            return;
+        defaultCursor.setInstance(this.node, numberId, removeComponentIndex);
+        this.components.splice(removeIndex, 2);
+        if (this.node.hasObservers) {
+            this.node.observers.isComponentRemovedSet &&
+                this.node.observers.componentRemoved.notify(defaultCursor);
+            this.node.observers.isComponentsUpdatedSet &&
+                this.node.observers.componentsUpdated.notify(defaultCursor);
+        }
+        defaultCursor.dispose();
+        return true;
+    }
+    has(type) {
+        const components = this.components;
+        if (!components)
+            return false;
+        const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        for (let i = 0; i < components.length; i += 2) {
+            if (components[i] == numberId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get(type, cursor = ComponentCursor.Get()) {
+        const components = this.components;
+        if (!components)
+            return null;
+        const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        for (let i = 0; i < components.length; i += 2) {
+            if (components[i] == numberId) {
+                cursor.setInstance(this.node, numberId, components[i + 1]);
+                return cursor;
+            }
+        }
+        return null;
+    }
+    getAll(type) {
+        const components = this.components;
+        if (!components)
+            return [];
+        const cursors = [];
+        const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        for (let i = 0; i < components.length; i += 2) {
+            if (components[i] == numberId) {
+                const cursor = ComponentCursor.Get();
+                cursor.setInstance(this.node, components[i], components[i + 1]);
+                cursors.push(cursor);
+            }
+        }
+        return cursors;
+    }
+    removeAll(type) {
+        const components = this.components;
+        if (!components)
+            return false;
+        const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        for (let i = components.length; i > 0; i -= 2) {
+            if (components[i] == numberId) {
+                defaultCursor.setInstance(this.node, components[i], components[i + 1]);
+                this.components.splice(i, 2);
+                if (this.node.hasObservers) {
+                    this.node.observers.isComponentRemovedSet &&
+                        this.node.observers.componentRemoved.notify(defaultCursor);
+                    this.node.observers.isComponentsUpdatedSet &&
+                        this.node.observers.componentsUpdated.notify(defaultCursor);
+                }
+            }
+        }
+        return true;
+    }
+    getChild(type, cursor = ComponentCursor.Get()) {
+        for (const child of this.node.traverseChildren()) {
+            if (!child.components)
+                continue;
+            const found = child.components.get(type, cursor);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    getParent(type, cursor = ComponentCursor.Get()) {
+        for (const parent of this.node.traverseParents()) {
+            if (!parent.components)
+                continue;
+            const found = parent.components.get(type, cursor);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+}

package/Nodes/NodeContext.d.ts

@@ -0,0 +1,14 @@
+import { ContextCursor } from "../Contexts/ContextCursor";
+import { CreateContextData } from "../Contexts/Context.types";
+import { NodeCursor } from "./NodeCursor";
+export declare class NodeContext {
+    node: NodeCursor;
+    static Get(): NodeContext;
+    static Retrun(cursor: NodeContext): boolean;
+    get context(): number[];
+    private constructor();
+    dispose(): void;
+    add(contextData: CreateContextData): number;
+    remove(type: string): boolean;
+    get(type: string): ContextCursor | null;
+}

package/Nodes/NodeContext.js

@@ -0,0 +1,107 @@
+import { ContextCursor } from "../Contexts/ContextCursor";
+import { NCSRegister } from "../Register/NCSRegister";
+import { NodeCursor } from "./NodeCursor";
+import { NCSPools } from "../Pools/NCSPools";
+export class NodeContext {
+    node;
+    static Get() {
+        const cursor = NCSPools.nodeContext.get();
+        if (!cursor)
+            return new NodeContext();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.nodeContext.addItem(cursor);
+    }
+    get context() {
+        return this.node.arrays._context[this.node.index];
+    }
+    constructor() { }
+    dispose() {
+        if (!this.context)
+            return;
+        const context = this.context;
+        const defaultCursor = ContextCursor.Get();
+        for (let i = 0; i < context.length; i += 2) {
+            defaultCursor.setContext(this.node, context[i]);
+            defaultCursor.dispose();
+        }
+        ContextCursor.Retrun(defaultCursor);
+    }
+    add(contextData) {
+        const cursor = ContextCursor.Get();
+        if (!this.context) {
+            this.node.arrays._context[this.node.index] =
+                NCSPools.numberArray.get() || [];
+        }
+        const context = this.context;
+        for (let i = 0; i < context.length; i++) {
+            cursor.setContext(this.node, context[i]);
+            if (cursor.type == contextData[0])
+                return cursor.index;
+        }
+        const contextType = NCSRegister.contexts.get(contextData[0]);
+        const typeId = NCSRegister.contexts.idPalette.getNumberId(contextData[0]);
+        const newContext = this.node.graph._contexts.addContext(typeId, [this.node.index], contextType, contextType.schema
+            ? contextType.schema
+                .getView(contextData[2] || "default")
+                .createData(contextData[1])
+            : null, contextData[3]);
+        context.push(newContext);
+        cursor.setContext(this.node, newContext);
+        contextData[0] = "";
+        contextData[1] = null;
+        contextData[2] = null;
+        contextData[3] = null;
+        NCSPools.createContextData.addItem(contextData);
+        ContextCursor.Retrun(cursor);
+        return newContext;
+    }
+    remove(type) {
+        const cursor = ContextCursor.Get();
+        const context = this.context;
+        for (let i = 0; i < context.length; i++) {
+            cursor.setContext(this.node, context[i]);
+            if (cursor.type == type) {
+                context.splice(i, 1);
+                for (let n = 0; n < cursor.nodes.length; n++) {
+                    if (cursor.nodes[n] == this.node.index) {
+                        cursor.nodes.splice(n, 1);
+                        break;
+                    }
+                }
+                ContextCursor.Retrun(cursor);
+                return true;
+            }
+        }
+        ContextCursor.Retrun(cursor);
+        return false;
+    }
+    get(type) {
+        const context = this.context;
+        const cursor = ContextCursor.Get();
+        if (context) {
+            for (let i = 0; i < context.length; i++) {
+                cursor.setContext(this.node, context[i]);
+                if (cursor.type == type)
+                    return cursor;
+            }
+        }
+        const parentCursor = NodeCursor.Get();
+        for (const parent of this.node.traverseParents(parentCursor)) {
+            if (this.node.arrays._context[parent.index]) {
+                const context = this.node.arrays._context[parent.index];
+                for (let i = 0; i < context.length; i++) {
+                    cursor.setContext(parent, context[i]);
+                    if (cursor.type == type) {
+                        //@todo add anchor
+                        cursor.setContext(parent, context[i]);
+                        return cursor;
+                    }
+                }
+            }
+        }
+        NodeCursor.Retrun(parentCursor);
+        return null;
+    }
+}

package/Nodes/NodeCursor.d.ts

@@ -0,0 +1,65 @@
+import { Graph } from "../Graphs/Graph";
+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";
+export interface NodeCursor {
+}
+export declare class NodeCursor {
+    static Get(): NodeCursor;
+    static Retrun(cursor: NodeCursor): void;
+    clear(events: boolean, context: boolean, observers: boolean, compoents: boolean, tags: boolean): void;
+    get index(): number;
+    get parentIndex(): number;
+    get id(): bigint | null;
+    get name(): string;
+    private _events;
+    get events(): NodeEvents;
+    get hasEvents(): boolean;
+    private _context;
+    get context(): NodeContext;
+    get hasContexts(): boolean;
+    private _observers;
+    get observers(): NodeObservers;
+    get hasObservers(): boolean;
+    private _components;
+    get components(): NodeComponents;
+    get hasComponents(): boolean;
+    private _tags;
+    get tags(): NodeTags;
+    get hasTags(): boolean;
+    get childrenArray(): number[];
+    get parent(): number;
+    set parent(value: number);
+    graph: Graph;
+    get arrays(): import("./NodeArray").NodeArray;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get isDisposed(): boolean;
+    private _index;
+    private constructor();
+    setNode(graph: Graph, index: number): this;
+    toRef(cursor?: NodeCursor): NodeCursor;
+    /** Traverse the node's direct children */
+    children(cursor?: NodeCursor): Generator<NodeCursor>;
+    /** Traverse all the node's descendants */
+    traverseChildren(cursor?: NodeCursor): Generator<NodeCursor>;
+    /** Traverse all the node's parents */
+    traverseParents(cursor?: NodeCursor): Generator<NodeCursor>;
+    /** Traverse all the node's components */
+    traverseComponents(cursor?: ComponentCursor<{}, any, any>): Generator<ComponentCursor>;
+    /** Traverse all the node's tags */
+    traverseTags(cursor?: TagCursor): Generator<TagCursor>;
+    dispose(): void;
+    hasChild(node: NodeCursor): boolean;
+    parentTo(nodeToParentTo: NodeCursor): void;
+    getChild(index: number, cursor?: NodeCursor): NodeCursor | null;
+    addChild(node: NodeCursor): void;
+    removeChild(index: number): number | null | undefined;
+    addUniqueId(): bigint;
+    returnCursor(): void;
+    cloneCursor(cursor?: NodeCursor): NodeCursor;
+}