@amodx/ncs 0.0.22 → 0.0.24

package/Components/Component.types.d.ts

@@ -41,6 +41,10 @@ export type ComponentRegisterData<ComponentSchema extends object = any, Data ext
      * The type of the component.
      */
     type: string;
+    performance?: {
+        /**If set to true component init will use a re-usable cursor that will be used for other components.  */
+        useReusableCursor: boolean;
+    };
     /**
      * The schema used to create an editable version of the component.
      * For the actual ComponentInstance the schema is created into an object.
@@ -67,8 +71,9 @@ export type ComponentRegisterData<ComponentSchema extends object = any, Data ext
      * It is up to the graph though when it gets called.
      *
      * @param component - The instance of the component being updated.
+     * @param delta - The time since the last update
      */
-    update?(component: ComponentCursor<ComponentSchema, Data, Shared>): void;
+    update?(component: ComponentCursor<ComponentSchema, Data, Shared>, delta: number): void;
     /**
      * Optional disposal function for the component.
      *

package/Components/ComponentArray.d.ts

@@ -24,7 +24,7 @@ export declare class ComponentArray {
     constructor(graph: Graph, numberTypeId: number);
     addComponent(node: number, schema: any | null, schemaView: string | null): number;
     removeComponent(index: number): number | null;
-    update(): void;
+    update(delta: number): void;
     init(index: number): boolean;
 }
 export {};

package/Components/ComponentArray.js

@@ -60,7 +60,7 @@ export class ComponentArray {
             this.schemaArray.removeData(index);
         return nodeIndex;
     }
-    update() {
+    update(delta) {
         const update = this.proto.update;
         if (!update)
             return;
@@ -68,15 +68,22 @@ export class ComponentArray {
             if (this._disposed[i])
                 continue;
             this._componentCursor.setInstance(this._nodeCursor.setNode(this.graph, this._node[i]), this.numberTypeId, i);
-            update(this._componentCursor);
+            update(this._componentCursor, delta);
         }
     }
     init(index) {
         const init = this.proto.init;
         if (!init)
             return false;
-        this._componentCursor.setInstance(this._nodeCursor.setNode(this.graph, this._node[index]), this.numberTypeId, index);
-        init(this._componentCursor);
+        const cursor = !this.proto.performance?.useReusableCursor
+            ? ComponentCursor.Get()
+            : this._componentCursor;
+        const nodeCursor = !this.proto.performance?.useReusableCursor
+            ? NodeCursor.Get()
+            : this._nodeCursor;
+        cursor.setInstance(nodeCursor
+            .setNode(this.graph, this._node[index]), this.numberTypeId, index);
+        init(cursor);
         return false;
     }
 }

package/Components/ComponentCursor.d.ts

@@ -5,6 +5,9 @@ import { ComponentArray } from "./ComponentArray";
 export declare class ComponentCursor<ComponentSchema extends object = {}, Data extends any = any, Shared extends any = any> {
     static Get(): ComponentCursor<{}, any, any>;
     static Retrun(cursor: ComponentCursor): boolean;
+    /**The index of the parent node in the node array */
+    get nodeIndex(): number;
+    /**The index in the component array */
     get index(): number;
     get type(): string;
     get shared(): Shared;
@@ -23,5 +26,5 @@ export declare class ComponentCursor<ComponentSchema extends object = {}, Data e
     dispose(): void;
     returnCursor(): boolean;
     cloneCursor(cursor?: ComponentCursor, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
-    update(): void;
+    update(delta: number): void;
 }

package/Components/ComponentCursor.js

@@ -11,6 +11,11 @@ export class ComponentCursor {
     static Retrun(cursor) {
         return NCSPools.componentCursor.addItem(cursor);
     }
+    /**The index of the parent node in the node array */
+    get nodeIndex() {
+        return this.node.index;
+    }
+    /**The index in the component array */
     get index() {
         return this._index;
     }
@@ -66,7 +71,7 @@ export class ComponentCursor {
         newCursor.setInstance(newNodeCursor, this.typeId, this._index);
         return newCursor;
     }
-    update() {
-        this.__proto.update && this.__proto.update(this);
+    update(delta) {
+        this.__proto.update && this.__proto.update(this, delta);
     }
 }

package/Data/serializeComponent.js

@@ -10,7 +10,7 @@ export function serializeComponentData(data) {
 export function serializeComponent(component) {
     return {
         type: component.type,
-        ...(component.schema ? { schema: component.schema.toJSON() } : {}),
+        ...(component.schema?.__cursor?.data ? { schema: component.schema.toJSON() } : {}),
         ...(component.schema?.__view && component.schema?.__view.id !== "default"
             ? { schemaViewId: component.schema.__view.id }
             : {}),

package/Data/serializeNode.js

@@ -1,9 +1,35 @@
 import { NodeId } from "../Nodes/NodeId";
-import { createRemoteComponent, serializeComponent, } from "./serializeComponent";
+import { createRemoteComponent, serializeComponent, serializeComponentData, } from "./serializeComponent";
+import { NCSRegister } from "../Register/NCSRegister";
 export function serializeNodeData(data) {
-    return {
+    const nodeData = {
         name: data[1],
     };
+    if (typeof data[0] == "string") {
+        nodeData.id = data[0];
+    }
+    if (typeof data[0] == "bigint") {
+        nodeData.id = NodeId.ToHexString(data[0]);
+    }
+    if (data[2]) {
+        nodeData.components = [];
+        for (const comp of data[2]) {
+            nodeData.components.push(serializeComponentData(comp));
+        }
+    }
+    if (data[3]) {
+        nodeData.tags = [];
+        for (const tag of data[3]) {
+            nodeData.tags.push(NCSRegister.tags.get(tag).id);
+        }
+    }
+    if (data[4]) {
+        nodeData.children = [];
+        for (const child of data[4]) {
+            nodeData.children.push(serializeNodeData(child));
+        }
+    }
+    return nodeData;
 }
 /** Serialize the node data as is for storage*/
 export function serializeNode(node) {

package/Functional.js

@@ -1,5 +1,7 @@
 import { NCS } from "./NCS";
 export function Node(dataOrComponents, maybeComponentsOrChildren, ...restChildren) {
+    if (typeof dataOrComponents == "string" && dataOrComponents == "")
+        dataOrComponents = "New Node";
     if (!dataOrComponents) {
         return NCS.createNode(null, "New Node", null, undefined, restChildren);
     }

package/Graphs/Graph.d.ts

@@ -18,5 +18,6 @@ export declare class Graph {
     getNodeFromId(id: bigint | string, cursor?: NodeCursor): NodeCursor;
     addNode(data: CreateNodeData, parent?: number, cursor?: NodeCursor): NodeCursor;
     removeNode(index: number): boolean;
+    private _lastTime;
     update(): void;
 }

package/Graphs/Graph.js

@@ -3,11 +3,9 @@ import { NodeArray } from "../Nodes/NodeArray";
 import { NodeCursor } from "../Nodes/NodeCursor";
 import { ContextArray } from "../Contexts/ContextArray";
 import { NCSPools } from "../Pools/NCSPools";
-const parentCursor = NodeCursor.Get();
-const nodeCursor = NodeCursor.Get();
 function createNode(graph, data, parent) {
     const newNode = graph._nodes.addNode(typeof data[0] == "string" ? NodeId.FromString(data[0]) : data[0], parent, data[1]);
-    nodeCursor.graph = graph;
+    const nodeCursor = NodeCursor.Get();
     nodeCursor.setNode(graph, newNode);
     if (data[2]?.length) {
         for (let i = 0; i < data[2].length; i++) {
@@ -19,10 +17,6 @@ function createNode(graph, data, parent) {
             nodeCursor.tags.add(data[3][i]);
         }
     }
-    if (parent >= 0) {
-        parentCursor.setNode(graph, parent);
-        parentCursor.addChild(nodeCursor);
-    }
     if (data[4]?.length) {
         for (let i = 0; i < data[4].length; i++) {
             createNode(graph, data[4][i], newNode);
@@ -35,6 +29,12 @@ function createNode(graph, data, parent) {
     data[3] = null;
     data[4] = null;
     NCSPools.createNodeData.addItem(data);
+    if (parent >= 0) {
+        const parentCursor = NodeCursor.Get();
+        parentCursor.setNode(graph, parent);
+        parentCursor.addChild(nodeCursor);
+        parentCursor.returnCursor();
+    }
     return nodeCursor;
 }
 export class Graph {
@@ -49,23 +49,25 @@ export class Graph {
         const rootIndex = this._nodes.addNode(null, -1, "root");
         this.root.setNode(this, rootIndex);
     }
-    getNode(index, cursor = nodeCursor) {
+    getNode(index, cursor = NodeCursor.Get()) {
         const parentIndex = this._nodes._parents[index];
         if (typeof parentIndex === "undefined")
-            throw new Error(`Node with index ${index} does not exist`);
+            throw new Error(`NCS: Node with index ${index} does not exist`);
         cursor.setNode(this, index);
         return cursor;
     }
-    getNodeFromId(id, cursor = nodeCursor) {
+    getNodeFromId(id, cursor = NodeCursor.Get()) {
         if (typeof id == "string")
             id = NodeId.FromString(id);
         const nodeIndex = this._nodes._idMap.get(id);
         if (typeof nodeIndex === "undefined")
-            throw new Error(`Node with id ${id} does not exist`);
+            throw new Error(`NCS: Node with id ${id} does not exist`);
         cursor.setNode(this, nodeIndex);
         return cursor;
     }
-    addNode(data, parent = this.root.index, cursor = nodeCursor) {
+    addNode(data, parent = this.root.index, cursor = NodeCursor.Get()) {
+        if (typeof parent !== "number")
+            throw new Error(`NCS: Passed in invalid parent ${parent} in graph.addNode`);
         const newNode = createNode(this, data, parent);
         if (newNode.hasComponents) {
             const components = newNode.components.components;
@@ -82,6 +84,7 @@ export class Graph {
             }
         }
         newNode.toRef(cursor);
+        newNode.returnCursor();
         return cursor;
     }
     removeNode(index) {
@@ -90,12 +93,20 @@ export class Graph {
             return false;
         return true;
     }
+    _lastTime = 0;
     update() {
+        if (this._lastTime == 0) {
+            this._lastTime = performance.now();
+            return;
+        }
+        const current = performance.now();
+        const delta = current - this._lastTime;
+        this._lastTime = current;
         for (let i = 0; i < this._updatingComponents.length; i++) {
-            this._updatingComponents[i].update();
+            this._updatingComponents[i].update(delta);
         }
         for (let i = 0; i < this._systems.length; i++) {
-            this._systems[i].update();
+            this._systems[i].update(delta);
         }
     }
 }

package/NCS.d.ts

@@ -12,7 +12,14 @@ import { deserializeComponentData } from "./Data/deserializeComponent";
 import { cloneNode, copyNode, createRemoteNode, serializeNode, serializeNodeData } from "./Data/serializeNode";
 import { deserializeNodeData } from "./Data/deserializeNode";
 import { ExtractSchemaClass, SchemaCreateData, SchemaProperty } from "./Schema/Schema.types";
+import { NodeCursor } from "./Nodes/NodeCursor";
+import { ComponentCursor } from "./Components/ComponentCursor";
+import { SerializedNodeData } from "./Data/SerializedData.types";
 export declare const NCS: {
+    Debug: {
+        logNode(node: NodeCursor): void;
+        output(node: NodeCursor): [index: number, data: SerializedNodeData];
+    };
     /** Create a graph. */
     createGraph(): Graph;
     /** Create node data to add a node to a graph. */
@@ -31,30 +38,30 @@ export declare const NCS: {
     registerSystem: typeof registerSystem;
     /** Register a component for use with NCS. */
     registerComponent: <Data extends unknown = any, Shared extends unknown = any, ComponentSchema extends object = any>(data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>) => import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared> & {
-        getNodes(grpah: Graph): Generator<import(".").NodeCursor>;
-        getComponents(grpah: Graph): Generator<import(".").ComponentCursor<ComponentSchema, Data, Shared>, any, any>;
-        set(node: import(".").NodeCursor, componentSchema?: import("./Util/Util.types").Nullable<Partial<ComponentSchema>> | undefined, schemaCursor?: import("./Util/Util.types").Nullable<import("./Schema/Schema.types").SchemaCursor<ComponentSchema>> | undefined, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        has(node: import(".").NodeCursor): boolean;
-        get(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequired(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequiredChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequiredParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getAll(node: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>[] | null;
-        remove(node: import(".").NodeCursor): boolean;
-        removeAll(node: import(".").NodeCursor): boolean;
+        getNodes(grpah: Graph): Generator<NodeCursor>;
+        getComponents(grpah: Graph): Generator<ComponentCursor<ComponentSchema, Data, Shared>, any, any>;
+        set(node: NodeCursor, componentSchema?: import("./Util/Util.types").Nullable<Partial<ComponentSchema>> | undefined, schemaCursor?: import("./Util/Util.types").Nullable<import("./Schema/Schema.types").SchemaCursor<ComponentSchema>> | undefined, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined): ComponentCursor<ComponentSchema, Data, Shared>;
+        has(node: NodeCursor): boolean;
+        get(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequired(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+        getChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequiredChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+        getParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequiredParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+        getAll(node: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>[] | null;
+        remove(node: NodeCursor): boolean;
+        removeAll(node: NodeCursor): boolean;
         nodeData: {
-            get(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema> | null;
-            set(node: import(".").SerializedNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
-            getAll(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema>[] | null;
-            remove(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema> | null;
-            removeAll(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema>[] | null;
+            get(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema> | null;
+            set(node: SerializedNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
+            getAll(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema>[] | null;
+            remove(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema> | null;
+            removeAll(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema>[] | null;
         };
         type: string;
         typeId: number;
         data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>;
-        default: import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        default: ComponentCursor<ComponentSchema, Data, Shared>;
     } & ((schema?: Partial<ComponentSchema> | null | undefined, schemaView?: string | null) => CreateComponentData<ComponentSchema>);
     /** Register a context for use with NCS. */
     registerContext: typeof registerContext;

package/NCS.js

@@ -12,6 +12,7 @@ import { deserializeComponentData } from "./Data/deserializeComponent";
 import { cloneNode, copyNode, createRemoteNode, serializeNode, serializeNodeData, } from "./Data/serializeNode";
 import { deserializeNodeData } from "./Data/deserializeNode";
 import { SchemaProperty, } from "./Schema/Schema.types";
+import { ComponentCursor } from "./Components/ComponentCursor";
 function traverseCreateSchema(obj, parent) {
     parent.children ??= [];
     for (const key in obj) {
@@ -45,7 +46,21 @@ function traverseCreateSchema(obj, parent) {
     }
     return parent;
 }
+const Debug = {
+    logNode(node) {
+        console.log("log node", node.index);
+        const temp = ComponentCursor.Get();
+        for (const comp of node.traverseComponents(temp)) {
+            console.log(comp.type, comp.schema && comp.schema.toJSON());
+        }
+        temp.returnCursor();
+    },
+    output(node) {
+        return [node.index, serializeNode(node)];
+    },
+};
 export const NCS = {
+    Debug,
     /** Create a graph. */
     createGraph() {
         return new Graph();

package/Nodes/NodeArray.d.ts

@@ -18,6 +18,7 @@ export declare class NodeArray {
     _disposed: boolean[];
     _enabled: boolean[];
     _hasObservers: boolean[];
+    private _count;
     addNode(id: bigint | null, parent: number, name: string): number;
     removeNode(slot: number): boolean;
     addNodeId(index: number, id: bigint): void;

package/Nodes/NodeArray.js

@@ -26,10 +26,13 @@ export class NodeArray {
     _disposed = [];
     _enabled = [];
     _hasObservers = [];
+    _count = 0;
     addNode(id, parent, name) {
-        let slot = this._freeSlots.length
-            ? this._freeSlots.shift()
-            : this._parents.length;
+        let slot = this._freeSlots.shift();
+        if (slot === undefined) {
+            slot = this._count;
+            this._count++;
+        }
         id && this.addNodeId(slot, id);
         this._parents[slot] = parent;
         this._names[slot] = name;
@@ -39,25 +42,28 @@ export class NodeArray {
         return slot;
     }
     removeNode(slot) {
-        if (this._parents[slot] === undefined)
+        if (this._parents[slot] === -1)
             return false;
         this._freeSlots.push(slot);
         this._indexMap[slot] && this.removeNodeId(this._indexMap[slot]);
-        this._parents[slot] = -1;
+        this._parents[slot] = 0;
         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];
+        for (let j = 0; j < observerValues.length; j++) {
+            const key = observerValues[j];
+            const observer = this._observers[key]?.[slot];
             if (observer !== undefined) {
+                observer.clear();
                 NCSPools.observers.addItem(observer);
-                this._events[i][slot] = undefined;
+                this._observers[key][slot] = undefined;
             }
         }
         for (let i = 0; i < this._eventPalette.size; i++) {
             const observer = this._events[i][slot];
             if (observer !== undefined) {
+                observer.clear();
                 NCSPools.observers.addItem(observer);
                 this._events[i][slot] = undefined;
             }

package/Nodes/NodeComponents.js

@@ -3,7 +3,6 @@ import { NodeCursor } from "./NodeCursor";
 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();
@@ -23,10 +22,12 @@ export class NodeComponents {
         if (!this.components)
             return;
         const components = this.components;
+        const tempCursor = ComponentCursor.Get();
         for (let i = 0; i < components.length; i += 2) {
-            defaultCursor.setInstance(this.node, components[i], components[i + 1]);
-            defaultCursor.dispose();
+            tempCursor.setInstance(this.node, components[i], components[i + 1]);
+            tempCursor.dispose();
         }
+        tempCursor.returnCursor();
     }
     add(comp) {
         if (!this.components) {
@@ -63,13 +64,15 @@ export class NodeComponents {
         NCSPools.createComponentData.addItem(comp);
         this.components.push(typeId, componentIndex);
         compArray.observers.nodeAdded.notify(this.node.index);
+        const temp = ComponentCursor.Get();
         if (this.node.hasObservers) {
-            defaultCursor.setInstance(this.node, typeId, componentIndex);
+            temp.setInstance(this.node, typeId, componentIndex);
             this.node.observers.isComponentAddedSet &&
-                this.node.observers.componentAdded.notify(defaultCursor);
+                this.node.observers.componentAdded.notify(temp);
             this.node.observers.isComponentsUpdatedSet &&
-                this.node.observers.componentsUpdated.notify(defaultCursor);
+                this.node.observers.componentsUpdated.notify(temp);
         }
+        temp.returnCursor();
         return componentIndex;
     }
     remove(type) {
@@ -88,15 +91,17 @@ export class NodeComponents {
         }
         if (removeIndex == -1)
             return;
-        defaultCursor.setInstance(this.node, numberId, removeComponentIndex);
+        const temp = ComponentCursor.Get();
+        temp.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.componentRemoved.notify(temp);
             this.node.observers.isComponentsUpdatedSet &&
-                this.node.observers.componentsUpdated.notify(defaultCursor);
+                this.node.observers.componentsUpdated.notify(temp);
         }
-        defaultCursor.dispose();
+        temp.dispose();
+        temp.returnCursor();
         return true;
     }
     has(type) {
@@ -118,8 +123,7 @@ export class NodeComponents {
         const numberId = NCSRegister.components.idPalette.getNumberId(type);
         for (let i = 0; i < components.length; i += 2) {
             if (components[i] == numberId) {
-                if (nodeCursor !== this.node)
-                    this.node.cloneCursor(nodeCursor);
+                nodeCursor.setNode(this.node.graph, this.node.index);
                 cursor.setInstance(nodeCursor, numberId, components[i + 1]);
                 return cursor;
             }
@@ -146,38 +150,49 @@ export class NodeComponents {
         if (!components)
             return false;
         const numberId = NCSRegister.components.idPalette.getNumberId(type);
+        const tempCursor = ComponentCursor.Get();
         for (let i = components.length; i > 0; i -= 2) {
             if (components[i] == numberId) {
-                defaultCursor.setInstance(this.node, components[i], components[i + 1]);
+                tempCursor.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.componentRemoved.notify(tempCursor);
                     this.node.observers.isComponentsUpdatedSet &&
-                        this.node.observers.componentsUpdated.notify(defaultCursor);
+                        this.node.observers.componentsUpdated.notify(tempCursor);
                 }
             }
         }
+        tempCursor.returnCursor();
         return true;
     }
     getChild(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
-        for (const child of this.node.traverseChildren()) {
+        const tempCursor = NodeCursor.Get();
+        for (const child of this.node.traverseChildren(tempCursor)) {
             if (!child.components)
                 continue;
+            nodeCursor.setNode(this.node.graph, child.index);
             const found = child.components.get(type, cursor, nodeCursor);
-            if (found)
+            if (found) {
+                tempCursor.returnCursor();
                 return found;
+            }
         }
+        tempCursor.returnCursor();
         return null;
     }
     getParent(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
-        for (const parent of this.node.traverseParents()) {
+        const tempCursor = NodeCursor.Get();
+        for (const parent of this.node.traverseParents(tempCursor)) {
             if (!parent.components)
                 continue;
             const found = parent.components.get(type, cursor, nodeCursor);
-            if (found)
+            if (found) {
+                tempCursor.returnCursor();
                 return found;
+            }
         }
+        tempCursor.returnCursor();
         return null;
     }
 }

package/Nodes/NodeCursor.d.ts

@@ -13,7 +13,6 @@ export declare class 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;
@@ -50,16 +49,17 @@ export declare class 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>;
+    traverseComponents(cursor?: ComponentCursor): 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;
+    getChildIndex(node: NodeCursor | number): number;
+    addChild(node: NodeCursor): number;
+    removeChild(index: number): number | undefined;
+    uniqueId(): bigint;
     returnCursor(): void;
     cloneCursor(cursor?: NodeCursor): NodeCursor;
 }