@amodx/ncs 0.0.24 → 0.0.27

package/Components/Component.types.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "../Schema/Schema";
 import { ComponentCursor } from "./ComponentCursor";
 import { RecursivePartial } from "../Util/Util.types";
+import { GraphClock } from "../Graphs/GraphClock";
 export type CreateComponentData<ComponentSchema extends object = any> = [
     /**
      * The type of the component.
@@ -73,7 +74,7 @@ export type ComponentRegisterData<ComponentSchema extends object = any, Data ext
      * @param component - The instance of the component being updated.
      * @param delta - The time since the last update
      */
-    update?(component: ComponentCursor<ComponentSchema, Data, Shared>, delta: number): void;
+    update?(component: ComponentCursor<ComponentSchema, Data, Shared>, clock: GraphClock): void;
     /**
      * Optional disposal function for the component.
      *

package/Components/ComponentArray.d.ts

@@ -2,6 +2,8 @@ import { Observable } from "../Util/Observable";
 import { SchemaArray } from "../Schema/SchemaArray";
 import { ComponentRegisterData } from "./Component.types";
 import { Graph } from "../Graphs/Graph";
+import { ItemPool } from "../Util/ItemPool";
+import { GraphClock } from "../Graphs/GraphClock";
 type ComponentObserverData = [type: number, index: number];
 declare class ComponentArrayObservers {
     componentAdded: Observable<ComponentObserverData>;
@@ -17,14 +19,14 @@ export declare class ComponentArray {
     _disposed: boolean[];
     _data: any[];
     schemaArray: SchemaArray;
+    dataPool: ItemPool<any>;
     proto: ComponentRegisterData;
     observers: ComponentArrayObservers;
-    private _nodeCursor;
     private _componentCursor;
     constructor(graph: Graph, numberTypeId: number);
     addComponent(node: number, schema: any | null, schemaView: string | null): number;
     removeComponent(index: number): number | null;
-    update(delta: number): void;
+    update(clock: GraphClock): void;
     init(index: number): boolean;
 }
 export {};

package/Components/ComponentArray.js

@@ -1,7 +1,7 @@
 import { Observable } from "../Util/Observable";
 import { NCSRegister } from "../Register/NCSRegister";
-import { NodeCursor } from "../Nodes/NodeCursor";
 import { ComponentCursor } from "./ComponentCursor";
+import { ItemPool } from "../Util/ItemPool";
 const componentObserverData = [0, 0];
 class ComponentArrayObservers {
     componentAdded = new Observable();
@@ -17,9 +17,9 @@ export class ComponentArray {
     _disposed = [];
     _data = [];
     schemaArray;
+    dataPool = new ItemPool();
     proto;
     observers = new ComponentArrayObservers();
-    _nodeCursor;
     _componentCursor;
     constructor(graph, numberTypeId) {
         this.graph = graph;
@@ -28,12 +28,12 @@ export class ComponentArray {
         if (proto.schema)
             this.schemaArray = proto.schema.array;
         this.proto = proto;
-        this._nodeCursor = NodeCursor.Get();
         this._componentCursor = ComponentCursor.Get();
+        this._componentCursor._returnable = false;
     }
     addComponent(node, schema, schemaView) {
         let slot = this._freeSlots.length
-            ? this._freeSlots.shift()
+            ? this._freeSlots.pop()
             : this._node.length;
         this._node[slot] = node;
         this._disposed[slot] = false;
@@ -45,7 +45,7 @@ export class ComponentArray {
         return slot;
     }
     removeComponent(index) {
-        if (this._node[index] === undefined)
+        if (this._disposed[index])
             return null;
         componentObserverData[0] = this.numberTypeId;
         componentObserverData[1] = index;
@@ -60,15 +60,19 @@ export class ComponentArray {
             this.schemaArray.removeData(index);
         return nodeIndex;
     }
-    update(delta) {
+    update(clock) {
         const update = this.proto.update;
         if (!update)
             return;
         for (let i = 0; i < this._disposed.length; i++) {
-            if (this._disposed[i])
+            const node = this._node[i];
+            if (this._disposed[i] ||
+                this.graph._nodes._disposed[node] ||
+                this.graph._nodes._beingDisposed[node] ||
+                node < 0)
                 continue;
-            this._componentCursor.setInstance(this._nodeCursor.setNode(this.graph, this._node[i]), this.numberTypeId, i);
-            update(this._componentCursor, delta);
+            this._componentCursor.setInstance(node, this.graph, this.numberTypeId, i);
+            update(this._componentCursor, clock);
         }
     }
     init(index) {
@@ -78,12 +82,8 @@ export class ComponentArray {
         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);
+        cursor.setInstance(this._node[index], this.graph, this.numberTypeId, index);
         init(cursor);
-        return false;
+        return true;
     }
 }

package/Components/ComponentCursor.d.ts

@@ -2,9 +2,12 @@ import { ComponentRegisterData } from "./Component.types";
 import { SchemaCursor } from "../Schema/Schema.types";
 import { NodeCursor } from "../Nodes/NodeCursor";
 import { ComponentArray } from "./ComponentArray";
+import { Graph } from "../Graphs/Graph";
+import { ItemPool } from "../Util/ItemPool";
+import { GraphClock } from "../Graphs/GraphClock";
 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;
+    static Return(cursor: ComponentCursor): boolean;
     /**The index of the parent node in the node array */
     get nodeIndex(): number;
     /**The index in the component array */
@@ -14,6 +17,7 @@ export declare class ComponentCursor<ComponentSchema extends object = {}, Data e
     schema: SchemaCursor<ComponentSchema>;
     get data(): Data;
     set data(data: Data);
+    get dataPool(): ItemPool<Data>;
     node: NodeCursor;
     arrays: ComponentArray;
     __proto: ComponentRegisterData<ComponentSchema, Data, Shared>;
@@ -21,10 +25,11 @@ export declare class ComponentCursor<ComponentSchema extends object = {}, Data e
     private _index;
     private _type;
     private constructor();
-    setInstance(node: NodeCursor, type: number, index: number): this;
+    _returnable: boolean;
+    setInstance(nodeIndex: number, graph: Graph, type: number, index: number): this;
     get isDisposed(): boolean;
     dispose(): void;
     returnCursor(): boolean;
     cloneCursor(cursor?: ComponentCursor, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
-    update(delta: number): void;
+    update(graphClock: GraphClock): void;
 }

package/Components/ComponentCursor.js

@@ -8,7 +8,12 @@ export class ComponentCursor {
             return new ComponentCursor();
         return cursor;
     }
-    static Retrun(cursor) {
+    static Return(cursor) {
+        if (cursor.schema) {
+            cursor.schema.__view.returnCursor(cursor.schema);
+            cursor.schema = null;
+        }
+        cursor._index = -1;
         return NCSPools.componentCursor.addItem(cursor);
     }
     /**The index of the parent node in the node array */
@@ -32,7 +37,10 @@ export class ComponentCursor {
     set data(data) {
         this.arrays._data[this._index] = data;
     }
-    node;
+    get dataPool() {
+        return this.arrays.dataPool;
+    }
+    node = NodeCursor.Get();
     arrays;
     __proto;
     get typeId() {
@@ -41,37 +49,47 @@ export class ComponentCursor {
     _index = 0;
     _type = 0;
     constructor() { }
-    setInstance(node, type, index) {
+    _returnable = true;
+    setInstance(nodeIndex, graph, type, index) {
         this._index = index;
         this._type = type;
-        this.node = node;
+        this.node.setNode(graph, nodeIndex);
         this.__proto = NCSRegister.components.items[this._type];
-        this.arrays = node.graph._components[type];
+        this.arrays = graph._components[type];
         if (this.arrays?.schemaArray?._data[index] !== undefined) {
             this.schema = this.arrays.schemaArray.createViewCursor(index);
             this.schema.setInstance(index);
         }
+        else {
+            this.schema = null;
+        }
         return this;
     }
     get isDisposed() {
+        if (this._index == -1 || this.nodeIndex == -1)
+            return true;
         return this.arrays._disposed[this._index];
     }
     dispose() {
         if (this.__proto.dispose)
             this.__proto.dispose(this);
         this.arrays.removeComponent(this._index);
+        this._index = -1;
+        this.node.clear(true, true, true, true, true);
     }
     returnCursor() {
-        return ComponentCursor.Retrun(this);
+        if (!this._returnable)
+            throw new Error(`Tried to return component cursor that cannot be returned`);
+        return ComponentCursor.Return(this);
     }
     cloneCursor(cursor, nodeCursor) {
         const newCursor = cursor || ComponentCursor.Get();
         const newNodeCursor = nodeCursor || NodeCursor.Get();
         newNodeCursor.setNode(this.node.graph, this.node.index);
-        newCursor.setInstance(newNodeCursor, this.typeId, this._index);
+        newCursor.setInstance(newNodeCursor.index, newNodeCursor.graph, this.typeId, this._index);
         return newCursor;
     }
-    update(delta) {
-        this.__proto.update && this.__proto.update(this, delta);
+    update(graphClock) {
+        this.__proto.update && this.__proto.update(this, graphClock);
     }
 }

package/Contexts/ContextArray.d.ts

@@ -7,7 +7,7 @@ export declare class ContextArray {
     _state: ContextStateData[];
     _disposed: boolean[];
     _data: any[];
-    schemaArray: SchemaArray[];
+    schemaArray: (SchemaArray | null)[];
     numberTypeId: number;
     addContext(type: number, node: number[], state: ContextStateData, schema: any | null, data?: any | null): number;
     removeContext(index: number): number[] | null;

package/Contexts/ContextArray.js

@@ -6,11 +6,11 @@ export class ContextArray {
     _state = [];
     _disposed = [];
     _data = [];
-    schemaArray;
+    schemaArray = [];
     numberTypeId;
     addContext(type, node, state, schema, data = null) {
         let slot = this._freeSlots.length
-            ? this._freeSlots.shift()
+            ? this._freeSlots.pop()
             : this._node.length;
         const contextSchema = NCSRegister.contexts.get(type).schema;
         if (contextSchema) {
@@ -21,6 +21,9 @@ export class ContextArray {
             }
             schemaArray.setData(slot, schema);
         }
+        else {
+            this.schemaArray[type] = null;
+        }
         this._type[slot] = type;
         this._node[slot] = node;
         this._state[slot] = state;
@@ -41,6 +44,7 @@ export class ContextArray {
         if (schemaArray) {
             schemaArray.removeData(index);
         }
+        this.schemaArray[this._type[index]] = null;
         this._data[index] = undefined;
         return data;
     }

package/Contexts/ContextCursor.d.ts

@@ -5,7 +5,7 @@ import { SchemaCursor } from "../Schema/Schema.types";
 import { Graph } from "../Graphs/Graph";
 export declare class ContextCursor<ContextSchema extends {} = {}, Data extends {} = {}> {
     static Get(): ContextCursor<{}, {}>;
-    static Retrun(cursor: ContextCursor): boolean;
+    static Return(cursor: ContextCursor): boolean;
     proto: ContextRegisterData<ContextSchema, Data>;
     _index: number;
     _type: number;
@@ -21,4 +21,5 @@ export declare class ContextCursor<ContextSchema extends {} = {}, Data extends {
     private constructor();
     setContext(node: NodeCursor, index: number): void;
     dispose(): void;
+    returnCursor(): boolean;
 }

package/Contexts/ContextCursor.js

@@ -7,7 +7,12 @@ export class ContextCursor {
             return new ContextCursor();
         return cursor;
     }
-    static Retrun(cursor) {
+    static Return(cursor) {
+        if (cursor.schema) {
+            cursor.schema.__view.returnCursor(cursor.schema);
+            cursor.schema = null;
+        }
+        cursor._index = -1;
         return NCSPools.contextCursor.addItem(cursor);
     }
     proto;
@@ -44,4 +49,7 @@ export class ContextCursor {
     dispose() {
         this.arrays.removeContext(this._index);
     }
+    returnCursor() {
+        return ContextCursor.Return(this);
+    }
 }

package/Data/serializeComponent.js

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

package/Data/serializeNode.js

@@ -14,6 +14,8 @@ export function serializeNodeData(data) {
     if (data[2]) {
         nodeData.components = [];
         for (const comp of data[2]) {
+            if (!comp)
+                continue;
             nodeData.components.push(serializeComponentData(comp));
         }
     }
@@ -26,6 +28,8 @@ export function serializeNodeData(data) {
     if (data[4]) {
         nodeData.children = [];
         for (const child of data[4]) {
+            if (!child)
+                continue;
             nodeData.children.push(serializeNodeData(child));
         }
     }

package/Functional.d.ts

@@ -2,11 +2,11 @@ import { CreateNodeData } from "./Nodes/Node.types";
 import { CreateComponentData } from "./Components/Component.types";
 import { RegisteredTag } from "./Register/registerTag";
 export declare function Node(): CreateNodeData;
-export declare function Node(components?: CreateComponentData[], tags?: number[] | null, ...children: CreateNodeData[]): CreateNodeData;
-export declare function Node(data: string, components?: CreateComponentData[], ...children: CreateNodeData[]): CreateNodeData;
+export declare function Node(components?: (CreateComponentData | null)[], tags?: number[] | null, ...children: CreateNodeData[]): CreateNodeData;
+export declare function Node(data: string, components?: (CreateComponentData | null)[], ...children: CreateNodeData[]): CreateNodeData;
 export declare function Node(data: {
     id?: true;
     name?: string;
     tags?: number[];
-}, components?: CreateComponentData[], ...children: CreateNodeData[]): CreateNodeData;
+}, components?: (CreateComponentData | null)[], ...children: CreateNodeData[]): CreateNodeData;
 export declare function Tag(id: string, ...children: RegisteredTag[]): RegisteredTag;

package/Functional.js

@@ -26,8 +26,8 @@ export function Node(dataOrComponents, maybeComponentsOrChildren, ...restChildre
 }
 export function Tag(id, ...children) {
     const tag = NCS.registerTag({ id });
-    children.forEach((_) => {
-        tag.tag.addChild(_.tag);
-    });
+    for (const child of children) {
+        tag.tag.addChild(child.tag);
+    }
     return tag;
 }

package/Graphs/Graph.d.ts

@@ -5,6 +5,7 @@ import { NodeCursor } from "../Nodes/NodeCursor";
 import { ContextArray } from "../Contexts/ContextArray";
 import { TagArray } from "../Tags/TagArray";
 import { SystemInstance } from "../Systems/SystemInstance";
+import { GraphClock } from "./GraphClock";
 export declare class Graph {
     _systems: SystemInstance[];
     _nodes: NodeArray;
@@ -18,6 +19,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;
+    clock: GraphClock;
     update(): void;
 }

package/Graphs/Graph.js

@@ -3,13 +3,17 @@ import { NodeArray } from "../Nodes/NodeArray";
 import { NodeCursor } from "../Nodes/NodeCursor";
 import { ContextArray } from "../Contexts/ContextArray";
 import { NCSPools } from "../Pools/NCSPools";
+import { GraphClock } from "./GraphClock";
 function createNode(graph, data, parent) {
     const newNode = graph._nodes.addNode(typeof data[0] == "string" ? NodeId.FromString(data[0]) : data[0], parent, data[1]);
     const nodeCursor = NodeCursor.Get();
     nodeCursor.setNode(graph, newNode);
     if (data[2]?.length) {
         for (let i = 0; i < data[2].length; i++) {
-            nodeCursor.components.add(data[2][i]);
+            const comp = data[2][i];
+            if (!comp)
+                continue;
+            nodeCursor.components.add(comp);
         }
     }
     if (data[3]?.length) {
@@ -19,7 +23,10 @@ function createNode(graph, data, parent) {
     }
     if (data[4]?.length) {
         for (let i = 0; i < data[4].length; i++) {
-            createNode(graph, data[4][i], newNode);
+            const node = data[4][i];
+            if (!node)
+                continue;
+            createNode(graph, node, newNode);
         }
     }
     nodeCursor.setNode(graph, newNode);
@@ -93,20 +100,16 @@ export class Graph {
             return false;
         return true;
     }
-    _lastTime = 0;
+    clock = new GraphClock();
     update() {
-        if (this._lastTime == 0) {
-            this._lastTime = performance.now();
+        this.clock.update();
+        if (!this.clock.delta)
             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(delta);
+            this._updatingComponents[i].update(this.clock);
         }
         for (let i = 0; i < this._systems.length; i++) {
-            this._systems[i].update(delta);
+            this._systems[i].update(this.clock);
         }
     }
 }

package/Graphs/GraphClock.d.ts

@@ -0,0 +1,8 @@
+export declare class GraphClock {
+    private _lastTime;
+    expectedDelta: number;
+    deltaRatio: number;
+    delta: number;
+    totalTime: number;
+    update(): void;
+}

package/Graphs/GraphClock.js

@@ -0,0 +1,18 @@
+export class GraphClock {
+    _lastTime = 0;
+    expectedDelta = 1000 / 60;
+    deltaRatio = 0;
+    delta = 0;
+    totalTime = 0;
+    update() {
+        if (this._lastTime === 0) {
+            this._lastTime = performance.now();
+            return;
+        }
+        const current = performance.now();
+        this.delta = current - this._lastTime;
+        this.totalTime += this.delta;
+        this.deltaRatio = this.delta / this.expectedDelta;
+        this._lastTime = current;
+    }
+}

package/NCS.d.ts

@@ -51,13 +51,22 @@ export declare const NCS: {
         getAll(node: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>[] | null;
         remove(node: NodeCursor): boolean;
         removeAll(node: NodeCursor): boolean;
-        nodeData: {
+        serializedNodeData: {
             get(node: SerializedNodeData): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema> | null;
             set(node: SerializedNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
+            set(node: CreateNodeData, schema: string, schemaViewId?: string | null): import("./Data/SerializedData.types").SerializedComponentData<ComponentSchema>[] | null;
             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;
         };
+        nodeData: {
+            get(node: CreateNodeData): CreateComponentData<ComponentSchema> | null;
+            set(node: CreateNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
+            set(node: CreateNodeData, schema: string, schemaViewId?: string, remote?: true | null): CreateComponentData<ComponentSchema>[] | null;
+            getAll(node: CreateNodeData): CreateComponentData<ComponentSchema>[] | null;
+            remove(node: CreateNodeData): CreateComponentData<ComponentSchema> | null;
+            removeAll(node: CreateNodeData): CreateComponentData<ComponentSchema>[] | null;
+        };
         type: string;
         typeId: number;
         data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>;

package/Nodes/Node.types.d.ts

@@ -12,7 +12,7 @@ export type CreateNodeData = [
     /**
      * The components of the node.
      */
-    components: CreateComponentData[] | null,
+    components: (CreateComponentData | null)[] | null,
     /**
      * The tags of the node.
      */
@@ -20,7 +20,7 @@ export type CreateNodeData = [
     /**
      * The children nodes of the node.
      */
-    children: CreateNodeData[] | null
+    children: (CreateNodeData | null)[] | null
 ];
 export declare enum NodeObserverIds {
     Disposed = 0,

package/Nodes/NodeArray.d.ts

@@ -15,6 +15,7 @@ export declare class NodeArray {
     _components: number[][];
     _tags: number[][];
     _context: number[][];
+    _beingDisposed: boolean[];
     _disposed: boolean[];
     _enabled: boolean[];
     _hasObservers: boolean[];

package/Nodes/NodeArray.js

@@ -23,12 +23,13 @@ export class NodeArray {
     _components = [];
     _tags = [];
     _context = [];
+    _beingDisposed = [];
     _disposed = [];
     _enabled = [];
     _hasObservers = [];
     _count = 0;
     addNode(id, parent, name) {
-        let slot = this._freeSlots.shift();
+        let slot = this._freeSlots.pop();
         if (slot === undefined) {
             slot = this._count;
             this._count++;
@@ -39,18 +40,20 @@ export class NodeArray {
         this._disposed[slot] = false;
         this._enabled[slot] = true;
         this._hasObservers[slot] = false;
+        this._beingDisposed[slot] = false;
         return slot;
     }
     removeNode(slot) {
-        if (this._parents[slot] === -1)
+        if (this._disposed[slot] === true)
             return false;
         this._freeSlots.push(slot);
         this._indexMap[slot] && this.removeNodeId(this._indexMap[slot]);
-        this._parents[slot] = 0;
+        this._parents[slot] = -1;
         this._names[slot] = "";
         this._disposed[slot] = true;
         this._enabled[slot] = false;
         this._hasObservers[slot] = false;
+        this._beingDisposed[slot] = false;
         for (let j = 0; j < observerValues.length; j++) {
             const key = observerValues[j];
             const observer = this._observers[key]?.[slot];

package/Nodes/NodeComponents.d.ts

@@ -11,9 +11,9 @@ export declare class NodeComponents {
     add(comp: CreateComponentData): number;
     remove(type: string): true | undefined;
     has(type: string): boolean;
-    get(type: string, cursor?: ComponentCursor<{}, any, any>, nodeCursor?: NodeCursor): ComponentCursor<any, any, any> | null;
+    get(type: string, cursor?: ComponentCursor | null): ComponentCursor<any, any, any> | null;
     getAll(type: string): ComponentCursor<any, any, any>[];
     removeAll(type: string): boolean;
-    getChild(type: string, cursor?: ComponentCursor<{}, any, any>, nodeCursor?: NodeCursor): ComponentCursor<any, any, any> | null;
-    getParent(type: string, cursor?: ComponentCursor<{}, any, any>, nodeCursor?: NodeCursor): ComponentCursor<any, any, any> | null;
+    getChild(type: string, cursor?: ComponentCursor | null): ComponentCursor<any, any, any> | null;
+    getParent(type: string, cursor?: ComponentCursor | null): ComponentCursor<any, any, any> | null;
 }