@amodx/ncs 0.0.1 → 0.0.2

package/Nodes/NodeObservers.js

@@ -1,63 +1,188 @@
-import { Observable } from "@amodx/core/Observers";
+import { Observable } from "../Util/Observable";
+import { NodeObserverIds } from "./Node.types";
+import { NCSPools } from "../Pools/NCSPools";
 export class NodeObservers {
-    _disposed;
-    _parented;
-    _removedFromParent;
-    _childAdded;
-    _childRemoved;
-    _childrenUpdated;
+    node;
+    static Get() {
+        const cursor = NCSPools.nodeObservers.get();
+        if (!cursor)
+            return new NodeObservers();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.nodeObservers.addItem(cursor);
+    }
+    constructor() { }
+    get observers() {
+        return this.node.arrays._observers;
+    }
     get disposed() {
-        if (!this._disposed) {
-            this._disposed = new Observable();
+        let observer = this.observers[NodeObserverIds.Disposed][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.Disposed][this.node.index] = observer;
         }
-        return this._disposed;
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
+    }
+    get enabled() {
+        let observer = this.observers[NodeObserverIds.Enabled][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.Enabled][this.node.index] = observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
     get parented() {
-        if (!this._parented) {
-            this._parented = new Observable();
+        let observer = this.observers[NodeObserverIds.Parented][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.Parented][this.node.index] = observer;
         }
-        return this._parented;
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
     get removedFromParent() {
-        if (!this._removedFromParent) {
-            this._removedFromParent = new Observable();
+        let observer = this.observers[NodeObserverIds.RemovedFromParent][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.RemovedFromParent][this.node.index] =
+                observer;
         }
-        return this._removedFromParent;
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
     get childAdded() {
-        if (!this._childAdded) {
-            this._childAdded = new Observable();
+        let observer = this.observers[NodeObserverIds.ChildAdded][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.ChildAdded][this.node.index] = observer;
         }
-        return this._childAdded;
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
     get childRemoved() {
-        if (!this._childRemoved) {
-            this._childRemoved = new Observable();
+        let observer = this.observers[NodeObserverIds.ChildRemoved][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.ChildRemoved][this.node.index] = observer;
         }
-        return this._childRemoved;
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
     get childrenUpdated() {
-        if (!this._childrenUpdated) {
-            this._childrenUpdated = new Observable();
+        let observer = this.observers[NodeObserverIds.ChildrenUpdated][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.ChildrenUpdated][this.node.index] =
+                observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
+    }
+    get isDisposedSet() {
+        return (this.observers[NodeObserverIds.Disposed][this.node.index] !== undefined);
+    }
+    get isEnabledSet() {
+        return (this.observers[NodeObserverIds.Enabled][this.node.index] !== undefined);
+    }
+    get isParentedSet() {
+        return (this.observers[NodeObserverIds.Parented][this.node.index] !== undefined);
+    }
+    get isRemovedFromParentSet() {
+        return (this.observers[NodeObserverIds.RemovedFromParent][this.node.index] !==
+            undefined);
+    }
+    get isChildAddedSet() {
+        return (this.observers[NodeObserverIds.ChildAdded][this.node.index] !== undefined);
+    }
+    get isChildRemovedSet() {
+        return (this.observers[NodeObserverIds.ChildRemoved][this.node.index] !==
+            undefined);
+    }
+    get isChildrenUpdatedSet() {
+        return (this.observers[NodeObserverIds.ChildrenUpdated][this.node.index] !==
+            undefined);
+    }
+    get componentAdded() {
+        let observer = this.observers[NodeObserverIds.ComponentAdded][this.node.index];
+        if (!observer) {
+            observer = new Observable();
+            this.observers[NodeObserverIds.ComponentAdded][this.node.index] =
+                observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
+    }
+    get componentRemoved() {
+        // This is the one you already fixed
+        let observer = this.observers[NodeObserverIds.ComponentRemoved][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.ComponentRemoved][this.node.index] =
+                observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
+    }
+    get componentsUpdated() {
+        let observer = this.observers[NodeObserverIds.ComponentsUpdated][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.ComponentsUpdated][this.node.index] =
+                observer;
         }
-        return this._childrenUpdated;
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
-    isDisposedSet() {
-        return !!this._disposed;
+    get isComponentAddedSet() {
+        return (this.observers[NodeObserverIds.ComponentAdded][this.node.index] !==
+            undefined);
     }
-    isParentedSet() {
-        return !!this._parented;
+    get isComponentRemovedSet() {
+        return (this.observers[NodeObserverIds.ComponentRemoved][this.node.index] !==
+            undefined);
     }
-    isRemovedFromParentSet() {
-        return !!this._removedFromParent;
+    get isComponentsUpdatedSet() {
+        return (this.observers[NodeObserverIds.ComponentsUpdated][this.node.index] !==
+            undefined);
+    }
+    get tagsAdded() {
+        let observer = this.observers[NodeObserverIds.TagAdded][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.TagAdded][this.node.index] = observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
+    }
+    get tagsRemoved() {
+        let observer = this.observers[NodeObserverIds.TagRemoved][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.TagRemoved][this.node.index] = observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
+    }
+    get tagsUpdated() {
+        let observer = this.observers[NodeObserverIds.TagsUpdated][this.node.index];
+        if (!observer) {
+            observer = NCSPools.observers.get() || new Observable();
+            this.observers[NodeObserverIds.TagsUpdated][this.node.index] = observer;
+        }
+        this.node.arrays._hasObservers[this.node.index] = true;
+        return observer;
     }
-    isChildAddedSet() {
-        return !!this._childAdded;
+    get isTagsAddedSet() {
+        return (this.observers[NodeObserverIds.TagAdded][this.node.index] !== undefined);
     }
-    isChildRemovedSet() {
-        return !!this._childRemoved;
+    get isTagsRemovedSet() {
+        return (this.observers[NodeObserverIds.TagRemoved][this.node.index] !== undefined);
     }
-    isChildrenUpdatedSet() {
-        return !!this._childrenUpdated;
+    get isTagsUpdatedSet() {
+        return (this.observers[NodeObserverIds.TagsUpdated][this.node.index] !==
+            undefined);
     }
 }

package/Nodes/NodeTags.d.ts

@@ -0,0 +1,17 @@
+import { TagCursor } from "../Tags/TagCursor";
+import { NodeCursor } from "./NodeCursor";
+export declare class NodeTags {
+    node: NodeCursor;
+    static Get(): NodeTags;
+    static Retrun(cursor: NodeTags): boolean;
+    get tags(): number[];
+    private constructor();
+    dispose(): void;
+    add(id: number, cursor?: TagCursor): any;
+    remove(id: string): boolean;
+    get(type: string, cursor?: TagCursor): TagCursor | null;
+    getChild(type: string, cursor?: TagCursor): TagCursor | null;
+    getAllChildlren(type: string): TagCursor[];
+    getParent(type: string, cursor?: TagCursor): TagCursor | null;
+    getAllParents(type: string): TagCursor[];
+}

package/Nodes/NodeTags.js

@@ -0,0 +1,102 @@
+import { NCSPools } from "../Pools/NCSPools";
+import { NCSRegister } from "../Register/NCSRegister";
+import { TagCursor } from "../Tags/TagCursor";
+const tagCursor = TagCursor.Get();
+export class NodeTags {
+    node;
+    static Get() {
+        const cursor = NCSPools.nodeTags.get();
+        if (!cursor)
+            return new NodeTags();
+        return cursor;
+    }
+    static Retrun(cursor) {
+        return NCSPools.nodeTags.addItem(cursor);
+    }
+    get tags() {
+        return this.node.arrays._tags[this.node.index];
+    }
+    constructor() { }
+    dispose() {
+        for (let i = 0; i < this.tags.length; i += 2) {
+            tagCursor.setTag(this.node, this.tags[i], this.tags[i + 1]);
+            tagCursor.dispose();
+        }
+    }
+    add(id, cursor = tagCursor) {
+        const newTag = this.node.graph._tags[id].addTag(this.node.index);
+        this.tags.push(id, newTag);
+        cursor.setTag(this.node, id, newTag);
+        if (this.node.hasObservers) {
+            this.node.observers.isTagsAddedSet &&
+                this.node.observers.tagsAdded.notify(cursor);
+        }
+        return cursor;
+    }
+    remove(id) {
+        const tagId = NCSRegister.tags.idPalette.getNumberId(id);
+        const tags = this.tags;
+        for (let i = 0; i < tags.length; i++) {
+            if (tags[i] == tagId) {
+                tagCursor.setTag(this.node, tagId, tags[i]);
+                tagCursor.dispose();
+                this.tags.splice(i, 2);
+                this.node.hasObservers &&
+                    this.node.observers.isTagsRemovedSet &&
+                    this.node.observers.tagsRemoved.notify(tagCursor);
+                this.node.hasObservers &&
+                    this.node.observers.isTagsUpdatedSet &&
+                    this.node.observers.tagsUpdated.notify(0);
+                return true;
+            }
+        }
+        return false;
+    }
+    get(type, cursor = tagCursor) {
+        const tagId = NCSRegister.tags.idPalette.getNumberId(type);
+        const tags = this.tags;
+        for (let i = 0; i < tags.length; i += 2) {
+            if (tags[i] == tagId) {
+                cursor.setTag(this.node, tags[i], tags[i + 1]);
+                return cursor;
+            }
+        }
+        return null;
+    }
+    getChild(type, cursor = tagCursor) {
+        for (const child of this.node.traverseChildren()) {
+            const found = child.tags.get(type, cursor);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    getAllChildlren(type) {
+        const tags = [];
+        for (const child of this.node.traverseChildren()) {
+            const found = child.tags.get(type);
+            if (found) {
+                tags.push(TagCursor.Get().setTag(this.node, found.typeId, found.index));
+            }
+        }
+        return tags;
+    }
+    getParent(type, cursor = tagCursor) {
+        for (const parent of this.node.traverseParents()) {
+            const found = parent.tags.get(type, cursor);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    getAllParents(type) {
+        const tags = [];
+        for (const child of this.node.traverseParents()) {
+            const found = child.tags.get(type, tagCursor);
+            if (found) {
+                tags.push(TagCursor.Get().setTag(this.node, found.typeId, found.index));
+            }
+        }
+        return tags;
+    }
+}

package/Pools/NCSPools.d.ts

@@ -1,7 +1,30 @@
-import { ItemPool } from "./ItemPool";
-import { Observable } from "@amodx/core/Observers";
-import { Pipeline } from "@amodx/core/Pipelines";
+import { ItemPool } from "../Util/ItemPool";
+import { Observable } from "../Util/Observable";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { NodeObservers } from "../Nodes/NodeObservers";
+import { NodeEvents } from "../Nodes/NodeEvents";
+import { NodeComponents } from "../Nodes/NodeComponents";
+import { NodeTags } from "../Nodes/NodeTags";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { ContextCursor } from "../Contexts/ContextCursor";
+import { TagCursor } from "../Tags/TagCursor";
+import { NodeContext } from "../Nodes/NodeContext";
+import { CreateNodeData } from "../Nodes/Node.types";
+import { CreateComponentData } from "../Components/Component.types";
+import { CreateContextData } from "../Contexts/Context.types";
 export declare class NCSPools {
     static observers: ItemPool<Observable<void>>;
-    static pipelines: ItemPool<Pipeline<{}>>;
+    static numberArray: ItemPool<number[]>;
+    static createNodeData: ItemPool<CreateNodeData>;
+    static createComponentData: ItemPool<CreateComponentData>;
+    static createContextData: ItemPool<CreateContextData>;
+    static nodeCursor: ItemPool<NodeCursor>;
+    static nodeContext: ItemPool<NodeContext>;
+    static nodeObservers: ItemPool<NodeObservers>;
+    static nodeEvents: ItemPool<NodeEvents>;
+    static nodeComponents: ItemPool<NodeComponents>;
+    static nodeTags: ItemPool<NodeTags>;
+    static tagCursor: ItemPool<TagCursor>;
+    static componentCursor: ItemPool<ComponentCursor<{}, any, any>>;
+    static contextCursor: ItemPool<ContextCursor<{}, {}>>;
 }

package/Pools/NCSPools.js

@@ -1,5 +1,17 @@
-import { ItemPool } from "./ItemPool";
+import { ItemPool } from "../Util/ItemPool";
 export class NCSPools {
     static observers = new ItemPool();
-    static pipelines = new ItemPool();
+    static numberArray = new ItemPool();
+    static createNodeData = new ItemPool();
+    static createComponentData = new ItemPool();
+    static createContextData = new ItemPool();
+    static nodeCursor = new ItemPool();
+    static nodeContext = new ItemPool();
+    static nodeObservers = new ItemPool();
+    static nodeEvents = new ItemPool();
+    static nodeComponents = new ItemPool();
+    static nodeTags = new ItemPool();
+    static tagCursor = new ItemPool();
+    static componentCursor = new ItemPool();
+    static contextCursor = new ItemPool();
 }

package/Queries/Query.types.d.ts

@@ -0,0 +1,8 @@
+import { ComponentRegisterData } from "../Components/Component.types";
+import { TagRegisterData } from "../Tags/Tag.types";
+export type QueryData = {
+    inclueComponents?: ComponentRegisterData<any, any, any>[];
+    includeTags?: TagRegisterData[];
+    excludeComponents?: ComponentRegisterData<any, any, any>[];
+    excludeTags?: TagRegisterData[];
+};

package/Queries/QueryInstance.d.ts

@@ -1,12 +1,14 @@
 import { Graph } from "../Graphs/Graph";
-import { QueryData } from "./QueryData";
-import { NodeInstance } from "../Nodes/NodeInstance";
+import { QueryData } from "./Query.types";
+import { NodeCursor } from "../Nodes/NodeCursor";
 export declare class QueryInstance {
     graph: Graph;
     data: QueryData;
-    nodes: Set<NodeInstance>;
+    nodes: number[];
+    private _updateFunction;
+    private nodeCursor;
     constructor(graph: Graph, data: QueryData);
-    evulate(node: NodeInstance): boolean;
+    evulate(node: NodeCursor): boolean;
     init(): void;
     dispose(): void;
 }

package/Queries/QueryInstance.js

@@ -1,77 +1,122 @@
-import { ComponentInstanceMap } from "../Components/ComponentInstanceMap";
-import { TagInstanceMap } from "../Tags/TagInstanceMap";
+import { NodeCursor } from "../Nodes/NodeCursor";
 import { NCSRegister } from "../Register/NCSRegister";
+import { ComponentArray } from "../Components/ComponentArray";
+import { TagArray } from "../Tags/TagArray";
 export class QueryInstance {
     graph;
     data;
-    nodes = new Set();
+    nodes = [];
+    _updateFunction;
+    nodeCursor = NodeCursor.Get();
     constructor(graph, data) {
         this.graph = graph;
         this.data = data;
     }
     evulate(node) {
-        for (const comp of this.data.inclueComponents) {
-            if (!(node.hasComponents && node.components.get(comp.type))) {
-                return false;
+        if (this.data.inclueComponents) {
+            for (const comp of this.data.inclueComponents) {
+                if (!node.components.has(comp.type)) {
+                    return false;
+                }
             }
         }
-        for (const tag of this.data.includeTags) {
-            if (!(node.hasTags && node.tags.get(tag.id))) {
-                return false;
+        if (this.data.includeTags) {
+            for (const tag of this.data.includeTags) {
+                if (!(node.hasTags && node.tags.get(tag.id))) {
+                    return false;
+                }
             }
         }
-        for (const comp of this.data.excludeComponents) {
-            if (node.hasComponents && node.components.get(comp.type)) {
-                return false;
+        if (this.data.excludeComponents) {
+            for (const comp of this.data.excludeComponents) {
+                if (node.components.has(comp.type)) {
+                    return false;
+                }
             }
         }
-        for (const tag of this.data.excludeTags) {
-            if (node.hasTags && node.tags.get(tag.id)) {
-                return false;
+        if (this.data.excludeTags) {
+            for (const tag of this.data.excludeTags) {
+                if (node.hasTags && node.tags.get(tag.id)) {
+                    return false;
+                }
             }
         }
         return true;
     }
     init() {
-        const onupdate = (node) => {
+        this._updateFunction = (nodeIndex) => {
+            const node = this.nodeCursor.setNode(this.graph, nodeIndex);
             if (!this.evulate(node)) {
-                this.nodes.delete(node);
+                for (let i = 0; i < this.nodes.length; i++) {
+                    if (this.nodes[i] == node.index) {
+                        this.nodes.splice(i, 1);
+                    }
+                }
                 return;
             }
-            this.nodes.add(node);
+            this.nodes.push(nodeIndex);
         };
-        for (const comp of this.data.inclueComponents) {
-            const map = ComponentInstanceMap.getMap(comp.type).getMap(this.graph);
-            map.observers.nodeAdded.subscribe(this, onupdate);
-            map.observers.nodeRemoved.subscribe(this, onupdate);
+        if (this.data.inclueComponents) {
+            for (const comp of this.data.inclueComponents) {
+                const compId = NCSRegister.components.idPalette.getNumberId(comp.type);
+                let map = this.graph._components[compId];
+                if (!map) {
+                    map = new ComponentArray(this.graph, compId);
+                    this.graph._components[compId] = map;
+                }
+                map.observers.nodeAdded.subscribe(this._updateFunction);
+                map.observers.nodeRemoved.subscribe(this._updateFunction);
+            }
         }
-        for (const tagId of this.data.includeTags) {
-            const tagPrototype = NCSRegister.tags.get(tagId.id, tagId.namespace || "main");
-            const tagMap = TagInstanceMap.getMap(tagId.id).getMap(this.graph);
-            tagMap.observers.nodeAdded.subscribe(this, onupdate);
-            tagMap.observers.nodeRemoved.subscribe(this, onupdate);
-            for (const child of tagPrototype.tag.traverseChildren()) {
-                const chidMap = TagInstanceMap.getMap(child.id).getMap(this.graph);
-                chidMap.observers.nodeAdded.subscribe(this, onupdate);
-                chidMap.observers.nodeRemoved.subscribe(this, onupdate);
+        if (this.data.includeTags) {
+            for (const includeTag of this.data.includeTags) {
+                const tag = NCSRegister.tags.get(includeTag.id);
+                const tagId = NCSRegister.tags.idPalette.getNumberId(includeTag.id);
+                let tagMap = this.graph._tags[tagId];
+                if (!tagMap) {
+                    tagMap = new TagArray(includeTag.id);
+                    this.graph._tags[tagId] = tagMap;
+                }
+                tagMap.observers.nodeAdded.subscribe(this._updateFunction);
+                tagMap.observers.nodeRemoved.subscribe(this._updateFunction);
+                for (const child of tag.traverseChildren()) {
+                    const tagId = NCSRegister.tags.idPalette.getNumberId(child.id);
+                    let chidMap = this.graph._tags[tagId];
+                    if (!chidMap) {
+                        chidMap = new TagArray(child.id);
+                        this.graph._tags[tagId] = chidMap;
+                    }
+                    chidMap.observers.nodeAdded.subscribe(this._updateFunction);
+                    chidMap.observers.nodeRemoved.subscribe(this._updateFunction);
+                }
             }
         }
     }
     dispose() {
-        for (const comp of this.data.inclueComponents) {
-            const map = ComponentInstanceMap.getMap(comp.type).getMap(this.graph);
-            map.observers.nodeAdded.unsubscribe(this);
-            map.observers.nodeRemoved.unsubscribe(this);
+        if (this.data.inclueComponents) {
+            for (const comp of this.data.inclueComponents) {
+                const map = this.graph._components[NCSRegister.components.idPalette.getNumberId(comp.type)];
+                if (!map)
+                    continue;
+                map.observers.nodeAdded.unsubscribe(this._updateFunction);
+                map.observers.nodeRemoved.unsubscribe(this._updateFunction);
+            }
         }
-        for (const tagId of this.data.includeTags) {
-            const tagPrototype = NCSRegister.tags.get(tagId.id, tagId.namespace || "main");
-            const tagMap = TagInstanceMap.getMap(tagId.id).getMap(this.graph);
-            tagMap.observers.nodeAdded.unsubscribe(this);
-            tagMap.observers.nodeRemoved.unsubscribe(this);
-            for (const child of tagPrototype.tag.traverseChildren()) {
-                const chidMap = TagInstanceMap.getMap(child.id).getMap(this.graph);
-                chidMap.observers.nodeAdded.unsubscribe(this);
-                chidMap.observers.nodeRemoved.unsubscribe(this);
+        if (this.data.includeTags) {
+            for (const includeTag of this.data.includeTags) {
+                const tag = NCSRegister.tags.get(includeTag.id);
+                const tagMap = this.graph._tags[NCSRegister.tags.idPalette.getNumberId(includeTag.id)];
+                if (!tagMap)
+                    continue;
+                tagMap.observers.nodeAdded.unsubscribe(this._updateFunction);
+                tagMap.observers.nodeRemoved.unsubscribe(this._updateFunction);
+                for (const child of tag.traverseChildren()) {
+                    const childMap = this.graph._tags[NCSRegister.tags.idPalette.getNumberId(child.id)];
+                    if (!childMap)
+                        continue;
+                    childMap.observers.nodeAdded.unsubscribe(this._updateFunction);
+                    childMap.observers.nodeRemoved.unsubscribe(this._updateFunction);
+                }
             }
         }
     }

package/Queries/QueryPrototype.d.ts

@@ -1,5 +1,5 @@
 import { Graph } from "../Graphs/Graph";
-import { QueryData } from "./QueryData";
+import { QueryData } from "./Query.types";
 import { QueryInstance } from "./QueryInstance";
 export declare class QueryPrototype {
     data: QueryData;

package/Register/NCSRegister.d.ts

@@ -1,13 +1,21 @@
-import { ContextPrototype } from "../Contexts/ContextPrototype";
-import { ComponentPrototype } from "../Components/ComponentPrototype";
-import { TraitPrototype } from "../Traits/TraitPrototype";
-import { ItemRegister } from "./ItemRegister";
 import { SystemPrototype } from "../Systems/SystemPrototype";
-import { TagPrototype } from "../Tags/TagPrototype";
+import { ComponentRegisterData } from "../Components/Component.types";
+import { Tag } from "../Tags/Tag";
+import { ContextRegisterData } from "../Contexts/Context.types";
+import { IdPalette } from "../Util/IdPalette";
+declare class ItemRegister<Item extends any> {
+    itemtype: string;
+    items: Item[];
+    idPalette: IdPalette;
+    constructor(itemtype: string);
+    get(id: string | number): Item;
+    has(id: string): boolean;
+    register(id: string, item: Item): number;
+}
 export declare class NCSRegister {
-    static components: ItemRegister<ComponentPrototype<any, any, any, any>>;
-    static traits: ItemRegister<TraitPrototype<any, any, any, any>>;
-    static contexts: ItemRegister<ContextPrototype<any, any>>;
-    static tags: ItemRegister<TagPrototype>;
+    static components: ItemRegister<ComponentRegisterData<any, any, any>>;
+    static contexts: ItemRegister<ContextRegisterData<any, any>>;
+    static tags: ItemRegister<Tag>;
     static systems: ItemRegister<SystemPrototype>;
 }
+export {};