@amodx/ncs 0.0.1

package/Nodes/Tags/NodeTags.js

@@ -0,0 +1,95 @@
+import { NodeTagObservers } from "./NodeTagObservers";
+import { NCSRegister } from "../../Register/NCSRegister";
+export class NodeTags {
+    node;
+    _observers;
+    get observers() {
+        if (!this._observers) {
+            this._observers = new NodeTagObservers();
+        }
+        return this._observers;
+    }
+    get hasObservers() {
+        return Boolean(this._observers);
+    }
+    tags = [];
+    constructor(node) {
+        this.node = node;
+    }
+    dispose() {
+        for (const tag of this.tags) {
+            tag.dispose();
+        }
+    }
+    add(tag) {
+        const tagType = NCSRegister.tags.get(tag.id, tag.namespace || "main");
+        const newTag = tagType.create(this.node, tag);
+        this.tags.push(newTag);
+        this.hasObservers &&
+            this.observers.isTagsAddedSet() &&
+            this.hasObservers &&
+            this.observers.tagsAdded.notify(newTag);
+        return newTag;
+    }
+    addTags(...components) {
+        for (const comp of components) {
+            this.add(comp);
+        }
+        this.hasObservers &&
+            this.observers.isTagsUpdatedSet() &&
+            this.observers.tagsUpdated.notify();
+    }
+    remove(type) {
+        const index = this.tags.findIndex((_) => _.id == type);
+        const tag = this.tags[index];
+        if (tag) {
+            const child = this.tags.splice(index, 1)[0];
+            this.hasObservers &&
+                this.observers.isTagsRemovedSet() &&
+                this.observers.tagsRemoved.notify(child);
+            this.hasObservers &&
+                this.observers.isTagsUpdatedSet() &&
+                this.observers.tagsUpdated.notify();
+            tag.dispose();
+            return true;
+        }
+        return false;
+    }
+    get(type) {
+        return this.tags.find((_) => _.id == type) || null;
+    }
+    getChild(type) {
+        for (const child of this.node.traverseChildren()) {
+            const found = child.tags.get(type);
+            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(found);
+        }
+        return tags;
+    }
+    getParent(type) {
+        for (const parent of this.node.traverseParents()) {
+            const found = parent.tags.get(type);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    getAllParents(type) {
+        const tags = [];
+        for (const child of this.node.traverseParents()) {
+            const found = child.tags.get(type);
+            if (found)
+                tags.push(found);
+        }
+        return tags;
+    }
+}

package/Pools/ItemPool.d.ts

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

package/Pools/ItemPool.js

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

package/Pools/NCSPools.d.ts

@@ -0,0 +1,7 @@
+import { ItemPool } from "./ItemPool";
+import { Observable } from "@amodx/core/Observers";
+import { Pipeline } from "@amodx/core/Pipelines";
+export declare class NCSPools {
+    static observers: ItemPool<Observable<void>>;
+    static pipelines: ItemPool<Pipeline<{}>>;
+}

package/Pools/NCSPools.js

@@ -0,0 +1,5 @@
+import { ItemPool } from "./ItemPool";
+export class NCSPools {
+    static observers = new ItemPool();
+    static pipelines = new ItemPool();
+}

package/Queries/QueryData.d.ts

@@ -0,0 +1,8 @@
+import { ComponentRegisterData } from "../Components/ComponentData";
+import { TagRegisterData } from "../Tags/TagData";
+export type QueryData = {
+    inclueComponents: ComponentRegisterData[];
+    includeTags: TagRegisterData[];
+    excludeComponents: ComponentRegisterData[];
+    excludeTags: TagRegisterData[];
+};

package/Queries/QueryData.js

@@ -0,0 +1 @@
+export {};

package/Queries/QueryInstance.d.ts

@@ -0,0 +1,12 @@
+import { Graph } from "../Graphs/Graph";
+import { QueryData } from "./QueryData";
+import { NodeInstance } from "../Nodes/NodeInstance";
+export declare class QueryInstance {
+    graph: Graph;
+    data: QueryData;
+    nodes: Set<NodeInstance>;
+    constructor(graph: Graph, data: QueryData);
+    evulate(node: NodeInstance): boolean;
+    init(): void;
+    dispose(): void;
+}

package/Queries/QueryInstance.js

@@ -0,0 +1,78 @@
+import { ComponentInstanceMap } from "../Components/ComponentInstanceMap";
+import { TagInstanceMap } from "../Tags/TagInstanceMap";
+import { NCSRegister } from "../Register/NCSRegister";
+export class QueryInstance {
+    graph;
+    data;
+    nodes = new Set();
+    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;
+            }
+        }
+        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;
+            }
+        }
+        for (const tag of this.data.excludeTags) {
+            if (node.hasTags && node.tags.get(tag.id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    init() {
+        const onupdate = (node) => {
+            if (!this.evulate(node)) {
+                this.nodes.delete(node);
+                return;
+            }
+            this.nodes.add(node);
+        };
+        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);
+        }
+        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);
+            }
+        }
+    }
+    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);
+        }
+        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);
+            }
+        }
+    }
+}

package/Queries/QueryPrototype.d.ts

@@ -0,0 +1,10 @@
+import { Graph } from "../Graphs/Graph";
+import { QueryData } from "./QueryData";
+import { QueryInstance } from "./QueryInstance";
+export declare class QueryPrototype {
+    data: QueryData;
+    queries: Map<Graph, QueryInstance>;
+    constructor(data: QueryData);
+    add(graph: Graph): QueryInstance;
+    remove(graph: Graph): boolean;
+}

package/Queries/QueryPrototype.js

@@ -0,0 +1,23 @@
+import { QueryInstance } from "./QueryInstance";
+export class QueryPrototype {
+    data;
+    queries = new Map();
+    constructor(data) {
+        this.data = data;
+    }
+    add(graph) {
+        if (this.queries.has(graph))
+            return this.queries.get(graph);
+        const newQuery = new QueryInstance(graph, this.data);
+        this.queries.set(graph, newQuery);
+        newQuery.init();
+        return newQuery;
+    }
+    remove(graph) {
+        const query = this.queries.get(graph);
+        if (!query)
+            return false;
+        query.dispose();
+        return true;
+    }
+}

package/Register/ItemRegister.d.ts

@@ -0,0 +1,7 @@
+export declare class ItemRegister<Item extends any> {
+    itemtype: string;
+    namespaces: Map<string, Map<string, Item>>;
+    constructor(itemtype: string);
+    get(id: string, namespace: string): Item;
+    register(id: string, namespace: string, item: Item): void;
+}

package/Register/ItemRegister.js

@@ -0,0 +1,24 @@
+export class ItemRegister {
+    itemtype;
+    namespaces = new Map([["main", new Map()]]);
+    constructor(itemtype) {
+        this.itemtype = itemtype;
+    }
+    get(id, namespace) {
+        const namespaceMap = this.namespaces.get(namespace);
+        if (!namespaceMap)
+            throw new Error(`[${this.itemtype}]: Namespace with id ${id} does not exist`);
+        const item = namespaceMap.get(id);
+        if (!item)
+            throw new Error(`[${this.itemtype}]: Entry with id ${id} does not exist`);
+        return item;
+    }
+    register(id, namespace, item) {
+        let itemMap = this.namespaces.get(namespace);
+        if (!itemMap) {
+            itemMap = new Map();
+            this.namespaces.set(namespace, itemMap);
+        }
+        itemMap.set(id, item);
+    }
+}

package/Register/NCSRegister.d.ts

@@ -0,0 +1,13 @@
+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";
+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 systems: ItemRegister<SystemPrototype>;
+}

package/Register/NCSRegister.js

@@ -0,0 +1,8 @@
+import { ItemRegister } from "./ItemRegister";
+export class NCSRegister {
+    static components = new ItemRegister("Components");
+    static traits = new ItemRegister("Traits");
+    static contexts = new ItemRegister("Context");
+    static tags = new ItemRegister("Tags");
+    static systems = new ItemRegister("Systems");
+}

package/Register/registerComponent.d.ts

@@ -0,0 +1,29 @@
+import { ComponentData, ComponentRegisterData, ComponentStateData } from "../Components/ComponentData";
+import { ComponentInstance } from "../Components/ComponentInstance";
+import { Graph } from "../Graphs/Graph";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { TraitData } from "../Traits/TraitData";
+import { NodeData } from "../Nodes/NodeData";
+import { ComponentPrototype } from "../Components/ComponentPrototype";
+type RegisteredComponent<ComponentSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}> = (ComponentRegisterData<ComponentSchema, Data, Logic, Shared> & {
+    getNodes: (grpah: Graph) => Set<NodeInstance>;
+    getComponents: (grpah: Graph) => Set<ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
+    set: (node: NodeInstance, componentSchema?: Partial<ComponentSchema>, traits?: TraitData[], state?: ComponentStateData) => Promise<ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
+    get: (node: NodeInstance) => ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
+    getChild: (node: NodeInstance) => ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
+    getParent: (node: NodeInstance) => ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
+    getAll: (node: NodeInstance) => ComponentInstance<ComponentSchema, Data, Logic, Shared>[] | null;
+    remove: (node: NodeInstance) => Promise<ComponentInstance<ComponentSchema, Data, Logic, Shared> | null>;
+    removeAll: (node: NodeInstance) => Promise<ComponentInstance<ComponentSchema, Data, Logic, Shared>[] | null>;
+    nodeData: {
+        get: (node: NodeData) => ComponentData<ComponentSchema> | null;
+        set: (node: NodeData, componentSchema?: Partial<ComponentSchema>, traits?: TraitData[], state?: ComponentStateData) => void;
+        getAll: (node: NodeData) => ComponentData<ComponentSchema>[] | null;
+        remove: (node: NodeData) => ComponentData<ComponentSchema> | null;
+        removeAll: (node: NodeData) => ComponentData<ComponentSchema>[] | null;
+    };
+    prototype: ComponentPrototype<ComponentSchema, Data, Logic, Shared>;
+    default: ComponentInstance<ComponentSchema, Data, Logic, Shared>;
+}) & ((schema?: Partial<ComponentSchema> | null | undefined, state?: Partial<ComponentStateData> | null | undefined, ...traits: TraitData[]) => ComponentData<ComponentSchema>);
+export declare const registerComponent: <ComponentSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}>(data: ComponentRegisterData<ComponentSchema, Data, Logic, Shared>) => RegisteredComponent<ComponentSchema, Data, Logic, Shared>;
+export {};

package/Register/registerComponent.js

@@ -0,0 +1,54 @@
+import { ComponentInstanceMap } from "../Components/ComponentInstanceMap";
+import { NCS } from "../NCS";
+import { NCSRegister } from "./NCSRegister";
+import { ComponentPrototype } from "../Components/ComponentPrototype";
+export const registerComponent = (data) => {
+    const prototype = new ComponentPrototype(data);
+    NCSRegister.components.register(data.type, data.namespace || "main", prototype);
+    const componentMap = ComponentInstanceMap.registerComponent(data.type);
+    const createComponent = (schema, state, ...traits) => {
+        return NCS.Pipelines.OnComponentDataCreate.pipe({
+            type: data.type,
+            state: state || {},
+            traits: traits || [],
+            schema: {
+                ...structuredClone(prototype.baseContextSchema),
+                ...(schema || {}),
+            },
+        });
+    };
+    return Object.assign(createComponent, data, {
+        prototype,
+        set: (node, schema, state, ...traits) => node.components.add(createComponent(schema
+            ? schema
+            : data.schema
+                ? structuredClone(prototype.baseContextSchema)
+                : {}, state, ...traits)),
+        getNodes: (graph) => componentMap.getNodes(graph),
+        getComponents: (graph) => componentMap.getItems(graph),
+        get: (node) => node.components.get(data.type),
+        getChild: (node) => node.components.getChild(data.type),
+        getParent: (node) => node.components.getParent(data.type),
+        getAll: (node) => node.components.getAll(data.type),
+        removeAll: (node) => node.components.removeAll(data.type),
+        remove: (node) => node.components.remove(data.type),
+        nodeData: {
+            get: (node) => node.components?.find((_) => _.type == data.type) || null,
+            getAll: (node) => node.components?.filter((_) => _.type == data.type),
+            remove: (node) => node.components?.splice(node.components?.findIndex((_) => _.type == data.type))[0] || null,
+            removeAll(node) {
+                const all = this.getAll(node);
+                node.components = node.components?.filter((_) => _.type != data.type);
+                return all?.length ? all : null;
+            },
+            set: (node, schema, state, ...traits) => {
+                node.components ??= [];
+                node.components.push(createComponent(schema
+                    ? schema
+                    : data.schema
+                        ? structuredClone(prototype.baseContextSchema)
+                        : {}, state, ...traits));
+            },
+        },
+    });
+};

package/Register/registerContext.d.ts

@@ -0,0 +1,16 @@
+import { ContextData, ContextRegisterData } from "../Contexts/ContextData";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { ContextInstance } from "../Contexts/ContextInstance";
+import { ObjectSchemaInstance } from "@amodx/schemas";
+import { ContextPrototype } from "../Contexts/ContextPrototype";
+type RegisteredContext<ContextSchema extends {} = {}, Data extends object = {}> = (ContextRegisterData<ContextSchema, Data> & {
+    set: (parent: NodeInstance, schema?: ContextSchema, data?: Data) => Promise<void>;
+    get: (parent: NodeInstance) => ContextInstance<ContextSchema, Data> | null;
+    getRequired: (parent: NodeInstance) => ContextInstance<ContextSchema, Data>;
+    remove: (parent: NodeInstance) => Promise<ContextInstance<ContextSchema, Data> | null>;
+    prototype: ContextPrototype<ContextSchema, Data>;
+    default: ContextInstance<Data>;
+    schemaController: ObjectSchemaInstance<ContextSchema>;
+}) & (() => ContextData);
+export declare function registerContext<ContextSchema extends {} = {}, Data extends object = {}>(data: ContextRegisterData<ContextSchema, Data>): RegisteredContext<ContextSchema, Data>;
+export {};

package/Register/registerContext.js

@@ -0,0 +1,37 @@
+import { NCS } from "../NCS";
+import { NCSRegister } from "./NCSRegister";
+import { ContextPrototype } from "../Contexts/ContextPrototype";
+export function registerContext(data) {
+    const prototype = new ContextPrototype(data);
+    NCSRegister.contexts.register(data.type, data.namespace || "main", prototype);
+    const createContext = (schema) => {
+        return NCS.Pipelines.OnContextDataCreate.pipe({
+            type: data.type,
+            schema: {
+                ...structuredClone(prototype.baseContextSchema),
+                ...(schema || {}),
+            },
+        });
+    };
+    return Object.assign(createContext, data, {
+        prototype,
+        set: (parent, schema, data) => {
+            const newContext = parent.context.add(createContext(schema));
+            if (data) {
+                newContext.data = data;
+            }
+        },
+        get: (parent) => {
+            return parent.context.get(data.type);
+        },
+        getRequired: (parent) => {
+            const found = parent.context.get(data.type);
+            if (!found)
+                throw new Error(`Could not find required context type: ${data.type}`);
+            return found;
+        },
+        remove: (parent) => {
+            return parent.context.remove(data.type);
+        },
+    });
+}

package/Register/registerSystem.d.ts

@@ -0,0 +1,12 @@
+import { SystemPrototype } from "../Systems/SystemPrototype";
+import { SystemRegisterData } from "../Systems/SystemData";
+import { Graph } from "../Graphs/Graph";
+import { SystemInstance } from "../Systems/SystemInstance";
+type RegisteredSystem = SystemRegisterData & {
+    set: (graph: Graph) => void;
+    get: (graph: Graph) => SystemInstance | null;
+    remove: (graph: Graph) => SystemInstance | null;
+    prototype: SystemPrototype;
+};
+export declare function registerSystem(data: SystemRegisterData): RegisteredSystem;
+export {};

package/Register/registerSystem.js

@@ -0,0 +1,12 @@
+import { NCSRegister } from "./NCSRegister";
+import { SystemPrototype } from "../Systems/SystemPrototype";
+export function registerSystem(data) {
+    const prototype = new SystemPrototype(data);
+    NCSRegister.systems.register(data.type, data.namespace || "main", prototype);
+    return Object.assign(data, {
+        prototype,
+        set: (graph) => prototype.add(graph),
+        get: (graph) => prototype.systems.get(graph) || null,
+        remove: (graph) => prototype.remove(graph),
+    });
+}

package/Register/registerTag.d.ts

@@ -0,0 +1,21 @@
+import { TagData, TagRegisterData } from "../Tags/TagData";
+import { NodeInstance } from "../Nodes/NodeInstance";
+import { TagInstance } from "../Tags/TagInstance";
+import { Tag } from "../Tags/Tag";
+import { TagPrototype } from "../Tags/TagPrototype";
+import { Graph } from "../Graphs/Graph";
+type RegisteredTag = (TagRegisterData & {
+    tag: Tag;
+    prototype: TagPrototype;
+    set: (parent: NodeInstance) => TagInstance;
+    get: (parent: NodeInstance) => TagInstance | null;
+    getChild: (parent: NodeInstance) => TagInstance | null;
+    getAllChildlren: (parent: NodeInstance) => TagInstance[] | null;
+    getParent: (parent: NodeInstance) => TagInstance | null;
+    getAllParents: (parent: NodeInstance) => TagInstance[] | null;
+    remove: (parent: NodeInstance) => TagInstance | null;
+    getNodes: (grpah: Graph) => Set<NodeInstance>;
+    getTags: (grpah: Graph) => Set<TagInstance>;
+}) & (() => TagData);
+export declare function registerTag(data: TagRegisterData): RegisteredTag;
+export {};

package/Register/registerTag.js

@@ -0,0 +1,43 @@
+import { NCS } from "../NCS";
+import { NCSRegister } from "./NCSRegister";
+import { Tag } from "../Tags/Tag";
+import { TagPrototype } from "../Tags/TagPrototype";
+import { TagInstanceMap } from "../Tags/TagInstanceMap";
+export function registerTag(data) {
+    const tag = new Tag(null, data);
+    const prototype = new TagPrototype(data, tag);
+    NCSRegister.tags.register(data.id, data.namespace || "main", prototype);
+    const map = TagInstanceMap.getMap(tag.id);
+    const createTag = () => {
+        return NCS.Pipelines.OnTagDataCreate.pipe({
+            id: data.id,
+        });
+    };
+    return Object.assign(createTag, data, {
+        tag,
+        prototype,
+        getNodes: (graph) => map.getNodes(graph),
+        getTags: (graph) => map.getItems(graph),
+        getChild: (parent) => {
+            return parent.tags.getChild(data.id);
+        },
+        getAllChildlren: (parent) => {
+            return parent.tags.getAllChildlren(data.id);
+        },
+        getParent: (parent) => {
+            return parent.tags.getParent(data.id);
+        },
+        getAllParents: (parent) => {
+            return parent.tags.getAllParents(data.id);
+        },
+        set: (parent) => {
+            return parent.tags.add(createTag());
+        },
+        get: (parent) => {
+            return parent.tags.get(data.id);
+        },
+        remove: (parent) => {
+            return parent.tags.remove(data.id);
+        },
+    });
+}

package/Register/registerTrait.d.ts

@@ -0,0 +1,15 @@
+import { ComponentInstance } from "../Components/ComponentInstance";
+import { TraitData, TraitRegisterData, TraitStateData } from "../Traits/TraitData";
+import { TraitInstance } from "../Traits/TraitInstance";
+import { TraitPrototype } from "../Traits/TraitPrototype";
+type RegisteredTrait<TraitSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}> = (TraitRegisterData<TraitSchema, Data, Logic, Shared> & {
+    set: (parent: ComponentInstance | TraitInstance, ComponentSchema?: Partial<TraitSchema>, traits?: TraitData[], state?: TraitStateData) => Promise<void>;
+    get: (parent: ComponentInstance | TraitInstance) => TraitInstance<TraitSchema, Data, Logic, Shared> | null;
+    getAll: (parent: ComponentInstance | TraitInstance) => TraitInstance<TraitSchema, Data, Logic, Shared>[] | null;
+    remove: (parent: ComponentInstance | TraitInstance) => Promise<TraitInstance<TraitSchema, Data, Logic, Shared> | null>;
+    removeAll: (parent: ComponentInstance | TraitInstance) => Promise<TraitInstance<TraitSchema, Data, Logic, Shared>[] | null>;
+    prototype: TraitPrototype<TraitSchema, Data, Logic, Shared>;
+    default: TraitInstance<TraitSchema, Data, Logic, Shared>;
+}) & ((schema?: Partial<TraitSchema> | null | undefined, state?: TraitStateData | null | undefined, ...traits: TraitData[]) => TraitData<TraitSchema>);
+export declare function registerTrait<TraitSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}>(data: TraitRegisterData<TraitSchema, Data, Logic, Shared>): RegisteredTrait;
+export {};

package/Register/registerTrait.js

@@ -0,0 +1,39 @@
+import { NCS } from "../NCS";
+import { NCSRegister } from "./NCSRegister";
+import { TraitPrototype } from "../Traits/TraitPrototype";
+export function registerTrait(data) {
+    const prototype = new TraitPrototype(data);
+    NCSRegister.traits.register(data.type, data.namespace || "main", prototype);
+    const createTrait = (schema, state, ...traits) => {
+        return NCS.Pipelines.OnTraitDataCreate.pipe({
+            type: data.type,
+            state: state || {},
+            traits: traits || [],
+            schema: {
+                ...structuredClone(prototype.baseContextSchema),
+                ...(schema || {}),
+            },
+        });
+    };
+    return Object.assign(createTrait, data, {
+        set: (parent, schema, state, ...traits) => {
+            return parent.traits.addTraits(createTrait(schema
+                ? schema
+                : data.schema
+                    ? structuredClone(prototype.baseContextSchema)
+                    : {}, state, ...traits));
+        },
+        get: (parent) => {
+            return parent.traits.get(data.type);
+        },
+        getAll: (parent) => {
+            return parent.traits.getAll(data.type);
+        },
+        removeAll: (parent) => {
+            return parent.traits.removeAll(data.type);
+        },
+        remove: (parent) => {
+            return parent.traits.remove(data.type);
+        },
+    });
+}

package/Systems/SystemData.d.ts

@@ -0,0 +1,20 @@
+import { QueryPrototype } from "../Queries/QueryPrototype";
+import { SystemInstance } from "./SystemInstance";
+export type SystemRegisterData = {
+    /**
+     * The name of the system.
+     */
+    type: string;
+    /**
+     * The namespace of the system.
+     */
+    namespace?: string;
+    /**
+     * The queries of the system.
+     */
+    queries: QueryPrototype[];
+    /**
+     * The update function  of the system.
+     */
+    update(system: SystemInstance): void;
+};

package/Systems/SystemData.js

@@ -0,0 +1 @@
+export {};