@amodx/ncs 0.0.1 → 0.0.21

package/Schema/SchemaArray.js

@@ -0,0 +1,87 @@
+import { NCSPools } from "../Pools/NCSPools";
+export class SchemaArray {
+    schema;
+    _data = [];
+    _dataViews = [];
+    _observers = [];
+    _proxyObjects = [];
+    _proxyKeys = [];
+    constructor(schema) {
+        this.schema = schema;
+        for (let i = 0; i < schema._data.length; i++) {
+            this._observers[i] = [];
+            this._proxyObjects[i] = [];
+            this._proxyKeys[i] = [];
+        }
+    }
+    createViewCursor(index) {
+        const data = this._data[index];
+        if (data === undefined)
+            return null;
+        const viewId = this._dataViews[index];
+        const view = this.schema.views[viewId];
+        if (!view)
+            return null;
+        return view.createCursor();
+    }
+    setData(index, data, view) {
+        this._data[index] = data;
+        this._dataViews[index] = this.schema.viewIdPalettew.getNumberId(view || "default");
+    }
+    getViewAt(index) {
+        if (this._data[index] === undefined)
+            return null;
+        return this.schema.getView(this.schema.viewIdPalettew.getStringId(this._dataViews[index]));
+    }
+    removeData(index) {
+        if (this._data[index] === undefined)
+            return false;
+        const view = this.getViewAt(index);
+        view.returnData(this._data[index]);
+        this._data[index] = undefined;
+        this._dataViews[index] = -1;
+        for (let i = 0; i < this.schema._data.length; i++) {
+            if (this._observers[i][index]) {
+                this._observers[i][index].clear();
+                NCSPools.observers.addItem(this._observers[i][index]);
+                this._observers[i][index] = undefined;
+            }
+            this._proxyObjects[i][index] = undefined;
+            this._proxyKeys[i][index] = undefined;
+        }
+        return true;
+    }
+    getObserver(propertyIndex, arrayIndex) {
+        if (!this._observers[propertyIndex][arrayIndex])
+            return null;
+        let observer = this._observers[propertyIndex][arrayIndex];
+        if (!observer)
+            return null;
+        return observer;
+    }
+    setObserver(propertyIndex, arrayIndex, value) {
+        if (!value) {
+            //@ts-ignore
+            this._observers[propertyIndex][arrayIndex] = undefined;
+            return;
+        }
+        this._observers[propertyIndex][arrayIndex] = value;
+    }
+    hasProxy(propertyIndex, arrayIndex) {
+        return this._proxyObjects[propertyIndex][arrayIndex] !== undefined;
+    }
+    fetchProxyData(propertyIndex, arrayIndex) {
+        return this._proxyObjects[propertyIndex][arrayIndex][this._proxyKeys[propertyIndex][arrayIndex]];
+    }
+    setProxyData(propertyIndex, arrayIndex, value) {
+        this._proxyObjects[propertyIndex][arrayIndex][this._proxyKeys[propertyIndex][arrayIndex]] = value;
+    }
+    removeProxy(propertyIndex, arrayIndex) {
+        this._proxyObjects[propertyIndex][arrayIndex] = undefined;
+        this._proxyKeys[propertyIndex][arrayIndex] = undefined;
+    }
+    setProxy(propertyIndex, arrayIndex, object, key) {
+        this._proxyObjects[propertyIndex][arrayIndex] = object;
+        this._proxyKeys[propertyIndex][arrayIndex] = key;
+    }
+}

package/Schema/SchemaArrayCursor.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from "../Util/Observable";
+import { SchemaArray } from "./SchemaArray";
+export declare class SchemaArrayCursor {
+    schemaArray: SchemaArray;
+    constructor(schemaArray: SchemaArray);
+    get data(): any;
+    set data(value: any);
+    _index: number;
+    setIndex(index: number): void;
+    getObserver(propertyIndex: number): Observable<any> | null;
+    getOrCreateObserver(propertyIndex: number): Observable<any>;
+    removeObserver(propertyIndex: number): boolean;
+    setObserver(propertyIndex: number, value: Observable | null): void;
+    hasProxy(propertyIndex: number): boolean;
+    fetchProxyData(propertyIndex: number): any;
+    setProxyData(propertyIndex: number, value: any): void;
+    removeProxy(propertyIndex: number): void;
+    setProxy<T extends Record<string | number, any> = {}>(propertyIndex: number, object: T, key: keyof T): void;
+}

package/Schema/SchemaArrayCursor.js

@@ -0,0 +1,56 @@
+import { NCSPools } from "../Pools/NCSPools";
+import { Observable } from "../Util/Observable";
+export class SchemaArrayCursor {
+    schemaArray;
+    constructor(schemaArray) {
+        this.schemaArray = schemaArray;
+    }
+    get data() {
+        return this.schemaArray._data[this._index];
+    }
+    set data(value) {
+        this.schemaArray._data[this._index] = value;
+    }
+    _index = 0;
+    setIndex(index) {
+        this._index = index;
+    }
+    getObserver(propertyIndex) {
+        return this.schemaArray.getObserver(propertyIndex, this._index);
+    }
+    getOrCreateObserver(propertyIndex) {
+        let observer = this.schemaArray.getObserver(propertyIndex, this._index);
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.schemaArray.setObserver(propertyIndex, this._index, observer);
+        }
+        return observer;
+    }
+    removeObserver(propertyIndex) {
+        let observer = this.schemaArray.getObserver(propertyIndex, this._index);
+        if (!observer)
+            return false;
+        observer.clear();
+        NCSPools.observers.addItem(observer);
+        this.schemaArray.setObserver(propertyIndex, this._index, null);
+        return true;
+    }
+    setObserver(propertyIndex, value) {
+        return this.schemaArray.setObserver(propertyIndex, this._index, value);
+    }
+    hasProxy(propertyIndex) {
+        return this.schemaArray.hasProxy(propertyIndex, this._index);
+    }
+    fetchProxyData(propertyIndex) {
+        return this.schemaArray.fetchProxyData(propertyIndex, this._index);
+    }
+    setProxyData(propertyIndex, value) {
+        return this.schemaArray.setProxyData(propertyIndex, this._index, value);
+    }
+    removeProxy(propertyIndex) {
+        return this.schemaArray.removeProxy(propertyIndex, this._index);
+    }
+    setProxy(propertyIndex, object, key) {
+        return this.schemaArray.setProxy(propertyIndex, this._index, object, key);
+    }
+}

package/Schema/SchemaView.d.ts

@@ -0,0 +1,24 @@
+import { ItemPool } from "../Util/ItemPool";
+import { RecursivePartial } from "../Util/Util.types";
+import { PropertyMetaData } from "./Property/Property.types";
+import { Schema } from "./Schema";
+import { SchemaCreateData, SchemaCursor } from "./Schema.types";
+export declare class SchemaView<Shape extends {} = any> {
+    schema: Schema<Shape>;
+    id: string;
+    meta: PropertyMetaData[];
+    byteOffset: number[];
+    byteSize: number;
+    _createData: SchemaCreateData;
+    private _cursorClass;
+    _dataPool: ItemPool<unknown>;
+    constructor(schema: Schema<Shape>, id: string, meta: PropertyMetaData[], byteOffset: number[], byteSize: number, _createData: SchemaCreateData, _cursorClass: any);
+    returnData(returnData: any): void;
+    createData(overrides?: RecursivePartial<Shape> | null): any;
+    createCursor(): SchemaCursor<Shape>;
+    /** Converts data for use of remote components */
+    toRemote(cursor: SchemaCursor<Shape>): any;
+    /** Converts data for remote data to local data*/
+    fromRemote(remoteData: any): any;
+    toJSON(cursor: SchemaCursor<Shape>): any;
+}

package/Schema/SchemaView.js

@@ -0,0 +1,141 @@
+import { ItemPool } from "../Util/ItemPool";
+import { setBinaryObjectData } from "./Functions/createSchemaBinaryObjectCursorClass";
+import { TypedArrayMap } from "./Property/Property.types";
+function traverseCreateJSON(parent, target, source) {
+    for (const child of parent.children) {
+        if (child.children) {
+            target[child.id] ??= {};
+            traverseCreateJSON(child, target[child.id], source[child.id]);
+        }
+        else {
+            target[child.id] = source[child.id];
+        }
+    }
+    return target;
+}
+const tempData = [];
+export class SchemaView {
+    schema;
+    id;
+    meta;
+    byteOffset;
+    byteSize;
+    _createData;
+    _cursorClass;
+    _dataPool = new ItemPool();
+    constructor(schema, id, meta, byteOffset, byteSize, _createData, _cursorClass) {
+        this.schema = schema;
+        this.id = id;
+        this.meta = meta;
+        this.byteOffset = byteOffset;
+        this.byteSize = byteSize;
+        this._createData = _createData;
+        this._cursorClass = _cursorClass;
+    }
+    returnData(returnData) {
+        this._dataPool.addItem(returnData);
+    }
+    createData(overrides) {
+        const data = this._createData;
+        overrides && (tempData.length = 0);
+        let baseData = !overrides
+            ? this.schema._data
+            : this.schema.createData(tempData, overrides);
+        if (this._dataPool.items.length) {
+            const newData = this._dataPool.get();
+            if (data.type == "object") {
+                for (let i = 0; i < baseData.length; i++) {
+                    newData[i] =
+                        typeof baseData[i] == "object"
+                            ? structuredClone(baseData[i])
+                            : baseData[i];
+                }
+                return newData;
+            }
+            if (data.type == "typed-array") {
+                newData.set(baseData);
+                return newData;
+            }
+            if (data.type == "binary-object") {
+                for (let i = 0; i < baseData.length; i++) {
+                    const meta = this.meta[i];
+                    if (!meta.binary)
+                        continue;
+                    setBinaryObjectData(newData, meta, this.byteOffset[i], baseData[i]);
+                }
+                return newData;
+            }
+        }
+        if (data.type == "object") {
+            const newData = new Array(baseData.length);
+            for (let i = 0; i < baseData.length; i++) {
+                newData[i] =
+                    typeof baseData[i] == "object"
+                        ? structuredClone(baseData[i])
+                        : baseData[i];
+            }
+            return newData;
+        }
+        if (data.type == "typed-array") {
+            const size = baseData.length;
+            const typedArrayClass = TypedArrayMap[data.arrayType];
+            let byteSize = size * typedArrayClass.BYTES_PER_ELEMENT;
+            const typedArray = new typedArrayClass(data.sharedMemory
+                ? new SharedArrayBuffer(byteSize)
+                : new ArrayBuffer(byteSize));
+            typedArray.set(baseData);
+            return typedArray;
+        }
+        if (data.type == "binary-object") {
+            let byteSize = this.byteSize;
+            const buffer = data.sharedMemory
+                ? new SharedArrayBuffer(byteSize)
+                : new ArrayBuffer(byteSize);
+            const current = {
+                view: new DataView(buffer),
+                buffer: new Uint8Array(buffer),
+            };
+            for (let i = 0; i < baseData.length; i++) {
+                const meta = this.meta[i];
+                if (!meta.binary)
+                    continue;
+                setBinaryObjectData(current, meta, this.byteOffset[i], baseData[i]);
+            }
+            return current;
+        }
+        throw new Error(`Invalid create data`);
+    }
+    createCursor() {
+        return new this._cursorClass(this, this.meta, this._createData, this.byteOffset);
+    }
+    /** Converts data for use of remote components */
+    toRemote(cursor) {
+        if (this._createData.type == "object") {
+            return cursor.__cursor.data;
+        }
+        if (this._createData.type == "typed-array") {
+            return cursor.__cursor.data;
+        }
+        if (this._createData.type == "binary-object") {
+            return cursor.__cursor.data.buffer;
+        }
+    }
+    /** Converts data for remote data to local data*/
+    fromRemote(remoteData) {
+        if (this._createData.type == "object") {
+            return remoteData;
+        }
+        if (this._createData.type == "typed-array") {
+            return remoteData;
+        }
+        if (this._createData.type == "binary-object") {
+            return {
+                view: new DataView(remoteData.buffer),
+                buffer: new Uint8Array(remoteData.buffer),
+            };
+        }
+    }
+    toJSON(cursor) {
+        return traverseCreateJSON(this.schema.root, {}, cursor);
+    }
+}

package/Systems/{SystemData.d.ts → System.types.d.ts}

@@ -5,10 +5,6 @@ export type SystemRegisterData = {
      * The name of the system.
      */
     type: string;
-    /**
-     * The namespace of the system.
-     */
-    namespace?: string;
     /**
      * The queries of the system.
      */

package/Systems/SystemInstance.d.ts

@@ -1,11 +1,13 @@
 import { Graph } from "../Graphs/Graph";
-import { SystemRegisterData } from "./SystemData";
+import { SystemRegisterData } from "./System.types";
 import { QueryInstance } from "../Queries/QueryInstance";
+import { NodeCursor } from "../Nodes/NodeCursor";
 export declare class SystemInstance {
     graph: Graph;
-    systemPrototype: SystemRegisterData;
+    proto: SystemRegisterData;
     queries: QueryInstance[];
-    constructor(graph: Graph, systemPrototype: SystemRegisterData);
-    init(): void;
+    node: NodeCursor;
+    constructor(graph: Graph, proto: SystemRegisterData);
+    update(): void;
     dispose(): void;
 }

package/Systems/SystemInstance.js

@@ -1,19 +1,25 @@
-import { GraphUpdate } from "../Graphs/GraphUpdate";
+import { NodeCursor } from "../Nodes/NodeCursor";
 export class SystemInstance {
     graph;
-    systemPrototype;
+    proto;
     queries = [];
-    constructor(graph, systemPrototype) {
+    node = NodeCursor.Get();
+    constructor(graph, proto) {
         this.graph = graph;
-        this.systemPrototype = systemPrototype;
-        for (const query of systemPrototype.queries) {
+        this.proto = proto;
+        for (const query of proto.queries) {
             this.queries.push(query.add(graph));
         }
+        this.graph._systems.push(this);
     }
-    init() {
-        GraphUpdate.addSystemToUpdate(this);
+    update() {
+        this.proto.update(this);
     }
     dispose() {
-        GraphUpdate.removeSystemFromUpdate(this);
+        for (let i = 0; i < this.graph._systems.length; i++) {
+            if (this.graph._systems[i] == this) {
+                this.graph._systems.splice(i, 1);
+            }
+        }
     }
 }

package/Systems/SystemPrototype.d.ts

@@ -1,6 +1,6 @@
 import { SystemInstance } from "./SystemInstance";
 import { Graph } from "../Graphs/Graph";
-import { SystemRegisterData } from "./SystemData";
+import { SystemRegisterData } from "./System.types";
 export declare class SystemPrototype {
     data: SystemRegisterData;
     systems: Map<Graph, SystemInstance>;

package/Systems/SystemPrototype.js

@@ -10,7 +10,6 @@ export class SystemPrototype {
             return this.systems.get(graph);
         const newSystem = new SystemInstance(graph, this.data);
         this.systems.set(graph, newSystem);
-        newSystem.init();
         return newSystem;
     }
     remove(graph) {

package/Tags/Tag.d.ts

@@ -1,4 +1,4 @@
-import { TagRegisterData } from "./TagData";
+import { TagRegisterData } from "./Tag.types";
 export declare class Tag {
     parent: Tag | null;
     private tagData;

package/Tags/Tag.js

@@ -4,7 +4,7 @@ export class Tag {
     get id() {
         return this.tagData.id;
     }
-    children;
+    children = [];
     constructor(parent, tagData) {
         this.parent = parent;
         this.tagData = tagData;

package/Tags/{TagData.d.ts → Tag.types.d.ts}

@@ -6,19 +6,6 @@ export interface TagMetaData {
     description?: string;
     [key: string]: any;
 }
-/**
- * Type representing the data of a tag.
- */
-export type TagData = {
-    /**
-     * The type of the tag.
-     */
-    id: string;
-    /**
-     * The namespace of the tag.
-     */
-    namespace?: string;
-};
 /**
  * Type representing the data required to register a tag.
  */
@@ -27,10 +14,6 @@ export type TagRegisterData = {
      * The type of the tag.
      */
     id: string;
-    /**
-     * The namespace of the tag.
-     */
-    namespace?: string;
     /**
      * The shared meta data of all tags.
      */

package/Tags/TagArray.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from "../Util/Observable";
+declare class TagArrayObservers {
+    tagAdded: Observable<number>;
+    componentRemoved: Observable<number>;
+    nodeAdded: Observable<number>;
+    nodeRemoved: Observable<number>;
+}
+export declare class TagArray {
+    typeId: string;
+    _freeSlots: number[];
+    _node: number[];
+    observers: TagArrayObservers;
+    typeNumberId: number;
+    constructor(typeId: string);
+    addTag(node: number): number;
+    removeTag(index: number): true | null;
+}
+export {};

package/Tags/TagArray.js

@@ -0,0 +1,37 @@
+import { Observable } from "../Util/Observable";
+import { NCSRegister } from "../Register/NCSRegister";
+class TagArrayObservers {
+    tagAdded = new Observable();
+    componentRemoved = new Observable();
+    nodeAdded = new Observable();
+    nodeRemoved = new Observable();
+}
+export class TagArray {
+    typeId;
+    _freeSlots = [];
+    _node = [];
+    observers = new TagArrayObservers();
+    typeNumberId;
+    constructor(typeId) {
+        this.typeId = typeId;
+        this.typeNumberId = NCSRegister.tags.idPalette.getNumberId(typeId);
+    }
+    addTag(node) {
+        let slot = this._freeSlots.length
+            ? this._freeSlots.shift()
+            : this._node.length;
+        this._node[slot] = node;
+        this.observers.tagAdded.notify(slot);
+        this.observers.nodeAdded.notify(node);
+        return slot;
+    }
+    removeTag(index) {
+        if (this._node[index] === undefined)
+            return null;
+        this.observers.tagAdded.notify(index);
+        this.observers.nodeRemoved.notify(this._node[index]);
+        this._freeSlots.push(index);
+        this._node[index] = -1;
+        return true;
+    }
+}

package/Tags/TagCursor.d.ts

@@ -0,0 +1,20 @@
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { Tag } from "./Tag";
+import { TagArray } from "./TagArray";
+export declare class TagCursor {
+    static Get(): TagCursor;
+    static Retrun(cursor: TagCursor): boolean;
+    get id(): string;
+    private _index;
+    get index(): number;
+    _type: number;
+    get typeId(): number;
+    get type(): string;
+    tag: Tag;
+    node: NodeCursor;
+    private constructor();
+    tagArray: TagArray;
+    setTag(node: NodeCursor, type: number, index: number): this;
+    dispose(): true | null;
+    toJSON(): string;
+}

package/Tags/TagCursor.js

@@ -0,0 +1,45 @@
+import { NCSRegister } from "../Register/NCSRegister";
+import { NCSPools } from "../Pools/NCSPools";
+export class TagCursor {
+    static Get() {
+        const cursor = NCSPools.tagCursor.get();
+        if (!cursor)
+            return new TagCursor();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.tagCursor.addItem(cursor);
+    }
+    get id() {
+        return this.tag.id;
+    }
+    _index = 0;
+    get index() {
+        return this._index;
+    }
+    _type = 0;
+    get typeId() {
+        return this._type;
+    }
+    get type() {
+        return NCSRegister.tags.idPalette.getStringId(this.typeId);
+    }
+    tag;
+    node;
+    constructor() { }
+    tagArray;
+    setTag(node, type, index) {
+        this.node = node;
+        this._type = type;
+        this._index = index;
+        this.tagArray = node.graph._tags[type];
+        this.tag = NCSRegister.tags.get(this.typeId);
+        return this;
+    }
+    dispose() {
+        return this.tagArray.removeTag(this._index);
+    }
+    toJSON() {
+        return this.id;
+    }
+}

package/Util/IdPalette.d.ts

@@ -0,0 +1,13 @@
+export declare class IdPalette {
+    private _count;
+    _palette: string[];
+    _map: Record<string, number>;
+    constructor(inital?: ArrayLike<string>);
+    get size(): number;
+    register(string: string): number;
+    get(): string[];
+    getMap(): Record<string, number>;
+    isRegistered(id: string): boolean;
+    getNumberId(id: string): number;
+    getStringId(id: number): string;
+}

package/Util/IdPalette.js

@@ -0,0 +1,38 @@
+export class IdPalette {
+    _count = 0;
+    _palette = [];
+    _map = {};
+    constructor(inital) {
+        if (inital) {
+            const length = inital.length;
+            for (let i = 0; i < length; i++) {
+                this.register(inital[i]);
+            }
+        }
+    }
+    get size() {
+        return this._count;
+    }
+    register(string) {
+        const id = this._count;
+        this._count++;
+        this._palette[id] = string;
+        this._map[string] = id;
+        return id;
+    }
+    get() {
+        return this._palette;
+    }
+    getMap() {
+        return this._map;
+    }
+    isRegistered(id) {
+        return this._map[id] !== undefined;
+    }
+    getNumberId(id) {
+        return this._map[id];
+    }
+    getStringId(id) {
+        return this._palette[id];
+    }
+}

package/{Pools → Util}/ItemPool.d.ts

@@ -1,7 +1,6 @@
 export declare class ItemPool<Item> {
-    maxSize: number;
     items: Item[];
-    constructor(maxSize?: number);
-    addItem(item: Item): false | undefined;
+    maxSize: number;
+    addItem(item: Item): boolean;
     get(): NonNullable<Item> | null;
 }

package/{Pools → Util}/ItemPool.js

@@ -1,13 +1,11 @@
 export class ItemPool {
-    maxSize;
     items = [];
-    constructor(maxSize = 100) {
-        this.maxSize = maxSize;
-    }
+    maxSize = Infinity;
     addItem(item) {
         if (this.items.length > this.maxSize)
             return false;
         this.items.push(item);
+        return true;
     }
     get() {
         const item = this.items.shift();