@amodx/ncs 0.0.1 → 0.0.21

package/Data/serializeNode.js

@@ -0,0 +1,83 @@
+import { NodeId } from "../Nodes/NodeId";
+import { createRemoteComponent, serializeComponent, } from "./serializeComponent";
+export function serializeNodeData(data) {
+    return {
+        name: data[1],
+    };
+}
+/** Serialize the node data as is for storage*/
+export function serializeNode(node) {
+    const id = node.id;
+    let components = null;
+    if (node.hasComponents) {
+        components = [];
+        for (const comp of node.traverseComponents()) {
+            components.push(serializeComponent(comp));
+        }
+    }
+    let tags = null;
+    if (node.hasTags) {
+        tags = [];
+        for (const tag of node.traverseTags()) {
+            tags.push(tag.type);
+        }
+    }
+    let children = null;
+    if (node.childrenArray?.length) {
+        children = [];
+        for (const child of node.children()) {
+            children.push(serializeNode(child));
+        }
+    }
+    return {
+        ...(id ? { id: NodeId.ToHexString(id) } : {}),
+        name: node.name,
+        ...(components ? { components } : {}),
+        ...(tags ? { tags } : {}),
+        ...(children ? { children } : {}),
+    };
+}
+/** Copy the node data as is */
+export function copyNode(node) {
+    return [null, node.name, null, null, null];
+}
+/** Clone the node data and create new ids if needed. */
+export function cloneNode(node) {
+    return {
+        name: node.name,
+    };
+}
+export function createRemoteNode(node, includeChildren = false, includedComponents = []) {
+    let children = null;
+    if (includeChildren) {
+        children = [];
+        for (const child of node.children()) {
+            children.push(createRemoteNode(child, includeChildren, includedComponents));
+        }
+    }
+    let components = null;
+    if (node.hasComponents) {
+        components = [];
+        for (const component of node.traverseComponents()) {
+            if (includedComponents.length) {
+                for (let i = 0; i < includedComponents.length; i++) {
+                    if (includedComponents[i].type == component.type) {
+                        components.push(createRemoteComponent(component));
+                        break;
+                    }
+                }
+            }
+            else {
+                components.push(createRemoteComponent(component));
+            }
+        }
+    }
+    let tags = null;
+    if (node.hasTags) {
+        tags = [];
+        for (const tag of node.traverseTags()) {
+            tags.push(tag.typeId);
+        }
+    }
+    return [node.id ? node.id : null, node.name, components, tags, children];
+}

package/Functional.d.ts

@@ -0,0 +1,12 @@
+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(data: {
+    id?: true;
+    name?: string;
+    tags?: number[];
+}, components?: CreateComponentData[], ...children: CreateNodeData[]): CreateNodeData;
+export declare function Tag(id: string, ...children: RegisteredTag[]): RegisteredTag;

package/Functional.js

@@ -0,0 +1,31 @@
+import { NCS } from "./NCS";
+export function Node(dataOrComponents, maybeComponentsOrChildren, ...restChildren) {
+    if (!dataOrComponents) {
+        return NCS.createNode(null, "New Node", null, undefined, restChildren);
+    }
+    // Case A: dataOrComponents is an array => treat it as the components array
+    if (Array.isArray(dataOrComponents)) {
+        const components = dataOrComponents;
+        const children = restChildren ?? [];
+        return NCS.createNode(undefined, undefined, Array.isArray(maybeComponentsOrChildren)
+            ? maybeComponentsOrChildren
+            : undefined, components, children);
+    }
+    // Case B: dataOrComponents is a string => treat it as the name
+    if (typeof dataOrComponents === "string") {
+        const name = dataOrComponents;
+        const components = (maybeComponentsOrChildren ??
+            []);
+        return NCS.createNode(undefined, name, undefined, components, restChildren);
+    }
+    // Case C: dataOrComponents is the object form => { id?, name?, state?, tags? }
+    const components = (maybeComponentsOrChildren ?? []);
+    return NCS.createNode(dataOrComponents.id, dataOrComponents.name, dataOrComponents.tags, components, restChildren);
+}
+export function Tag(id, ...children) {
+    const tag = NCS.registerTag({ id });
+    children.forEach((_) => {
+        tag.tag.addChild(_.tag);
+    });
+    return tag;
+}

package/Graphs/Graph.d.ts

@@ -1,24 +1,22 @@
-import { NodeData } from "../Nodes/NodeData";
-import { NodeInstance } from "../Nodes/NodeInstance";
-import { NodeId } from "../Nodes/NodeId";
-import { GraphEvents } from "./GraphEvents";
-import { GraphObservers } from "./GraphObservers";
-export interface GraphDependencies {
-    [key: string]: any;
-}
-export interface Graph {
-}
+import { CreateNodeData } from "../Nodes/Node.types";
+import { NodeArray } from "../Nodes/NodeArray";
+import { ComponentArray } from "../Components/ComponentArray";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { ContextArray } from "../Contexts/ContextArray";
+import { TagArray } from "../Tags/TagArray";
+import { SystemInstance } from "../Systems/SystemInstance";
 export declare class Graph {
-    dependencies: GraphDependencies;
-    _nodeMap: Map<BigInt, Map<BigInt, NodeInstance>>;
-    events: GraphEvents;
-    observers: GraphObservers;
-    root: NodeInstance;
-    constructor(dependencies: GraphDependencies);
-    getNode(id: NodeId | string): NodeInstance;
-    loadInRoot(data: NodeData): Promise<void>;
-    addNode(data: NodeData, parent?: NodeInstance): Promise<NodeInstance>;
-    removeNode(id: NodeId): void;
+    _systems: SystemInstance[];
+    _nodes: NodeArray;
+    _components: ComponentArray[];
+    _contexts: ContextArray;
+    _tags: TagArray[];
+    _updatingComponents: ComponentArray[];
+    root: NodeCursor;
+    constructor();
+    getNode(index: number, cursor?: NodeCursor): NodeCursor;
+    getNodeFromId(id: bigint | string, cursor?: NodeCursor): NodeCursor;
+    addNode(data: CreateNodeData, parent?: number, cursor?: NodeCursor): NodeCursor;
+    removeNode(index: number): boolean;
     update(): void;
-    toJSON(): NodeData;
 }

package/Graphs/Graph.js

@@ -1,90 +1,101 @@
-import { NodeInstance } from "../Nodes/NodeInstance";
 import { NodeId } from "../Nodes/NodeId";
-import { GraphEvents } from "./GraphEvents";
-import { Node } from "../NCS";
-import { GraphUpdate } from "./GraphUpdate";
-import { GraphObservers } from "./GraphObservers";
-export class Graph {
-    dependencies;
-    _nodeMap = new Map();
-    events = new GraphEvents();
-    observers = new GraphObservers();
-    root = new NodeInstance(null, Node({ name: "__root__" }), this);
-    constructor(dependencies) {
-        this.dependencies = dependencies;
+import { NodeArray } from "../Nodes/NodeArray";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { ContextArray } from "../Contexts/ContextArray";
+import { NCSPools } from "../Pools/NCSPools";
+const parentCursor = NodeCursor.Get();
+const nodeCursor = NodeCursor.Get();
+function createNode(graph, data, parent) {
+    const newNode = graph._nodes.addNode(typeof data[0] == "string" ? NodeId.FromString(data[0]) : data[0], parent, data[1]);
+    nodeCursor.graph = graph;
+    nodeCursor.setNode(graph, newNode);
+    if (data[2]?.length) {
+        for (let i = 0; i < data[2].length; i++) {
+            nodeCursor.components.add(data[2][i]);
+        }
     }
-    getNode(id) {
-        if (typeof id == "string")
-            id = NodeId.Create(id);
-        const high = this._nodeMap.get(id.low);
-        if (!high)
-            throw new Error(`Node with id ${id.idString} does not exist`);
-        const node = high.get(id.high);
-        if (!node)
-            throw new Error(`Node with id ${id.idString} does not exist`);
-        return node;
+    if (data[3]?.length) {
+        for (let i = 0; i < data[3].length; i++) {
+            nodeCursor.tags.add(data[3][i]);
+        }
     }
-    async loadInRoot(data) {
-        if (this.root)
-            this.root.dispose();
-        const root = new NodeInstance({}, data, this);
-        await root.addChildren(...data.children);
-        this.root = root;
+    if (parent >= 0) {
+        parentCursor.setNode(graph, parent);
+        parentCursor.addChild(nodeCursor);
     }
-    async addNode(data, parent = this.root) {
-        const newNode = new NodeInstance(parent, data, this);
-        newNode.parent = parent;
-        parent.children.push(newNode);
-        let high = this._nodeMap.get(newNode.id.low);
-        if (!high) {
-            high = new Map();
-            this._nodeMap.set(newNode.id.low, high);
+    if (data[4]?.length) {
+        for (let i = 0; i < data[4].length; i++) {
+            createNode(graph, data[4][i], newNode);
         }
-        high.set(newNode.id.high, newNode);
-        if (data.components?.length) {
-            await newNode.components.addComponents(...data.components);
+    }
+    nodeCursor.setNode(graph, newNode);
+    data[0] = null;
+    data[1] = "";
+    data[2] = null;
+    data[3] = null;
+    data[4] = null;
+    NCSPools.createNodeData.addItem(data);
+    return nodeCursor;
+}
+export class Graph {
+    _systems = [];
+    _nodes = new NodeArray();
+    _components = [];
+    _contexts = new ContextArray();
+    _tags = [];
+    _updatingComponents = [];
+    root = NodeCursor.Get();
+    constructor() {
+        const rootIndex = this._nodes.addNode(null, -1, "root");
+        this.root.setNode(this, rootIndex);
+    }
+    getNode(index, cursor = nodeCursor) {
+        const parentIndex = this._nodes._parents[index];
+        if (typeof parentIndex === "undefined")
+            throw new Error(`Node with index ${index} does not exist`);
+        cursor.setNode(this, index);
+        return cursor;
+    }
+    getNodeFromId(id, cursor = nodeCursor) {
+        if (typeof id == "string")
+            id = NodeId.FromString(id);
+        const nodeIndex = this._nodes._idMap.get(id);
+        if (typeof nodeIndex === "undefined")
+            throw new Error(`Node with id ${id} does not exist`);
+        cursor.setNode(this, nodeIndex);
+        return cursor;
+    }
+    addNode(data, parent = this.root.index, cursor = nodeCursor) {
+        const newNode = createNode(this, data, parent);
+        if (newNode.hasComponents) {
+            const components = newNode.components.components;
+            for (let i = 0; i < components.length; i += 2) {
+                this._components[components[i]].init(components[i + 1]);
+            }
         }
-        parent.hasObservers &&
-            parent.observers.isChildAddedSet() &&
-            parent.observers.childAdded.notify(newNode);
-        this.observers.nodeAdded.notify(newNode);
-        this.observers.nodesUpdated.notify();
-        if (data.children?.length) {
-            for (const child of data.children) {
-                await this.addNode(child, newNode);
+        for (const child of newNode.traverseChildren()) {
+            if (child.hasComponents) {
+                const components = child.components.components;
+                for (let i = 0; i < components.length; i += 2) {
+                    this._components[components[i]].init(components[i + 1]);
+                }
             }
         }
-        return newNode;
+        newNode.toRef(cursor);
+        return cursor;
     }
-    removeNode(id) {
-        const low = this._nodeMap.get(id.low);
-        if (!low)
-            return;
-        const node = low.get(id.high);
+    removeNode(index) {
+        const node = this._nodes.removeNode(index);
         if (!node)
-            return;
-        if (!node.isDisposed())
-            node.dispose();
-        this._nodeMap.delete(id.low);
-        low.delete(id.high);
-        this.observers.nodeRemoved.notify(node);
-        this.observers.nodesUpdated.notify();
+            return false;
+        return true;
     }
     update() {
-        {
-            const updating = GraphUpdate.getUpdatingComponents(this);
-            for (const component of updating) {
-                component.componentPrototype.data.update(component);
-            }
+        for (let i = 0; i < this._updatingComponents.length; i++) {
+            this._updatingComponents[i].update();
         }
-        {
-            const updating = GraphUpdate.getUpdatingSystems(this);
-            for (const system of updating) {
-                system.systemPrototype.update(system);
-            }
+        for (let i = 0; i < this._systems.length; i++) {
+            this._systems[i].update();
         }
     }
-    toJSON() {
-        return this.root.toJSON();
-    }
 }

package/NCS.d.ts

@@ -1,54 +1,85 @@
-import { Pipeline } from "@amodx/core/Pipelines";
-import { Graph, GraphDependencies } from "./Graphs/Graph";
-import { NodeData, NodeStateData } from "./Nodes/NodeData";
-import { NodeInstance } from "./Nodes/NodeInstance";
-import { QueryData } from "./Queries/QueryData";
+import { Graph } from "./Graphs/Graph";
+import { CreateNodeData } from "./Nodes/Node.types";
+import { QueryData } from "./Queries/Query.types";
 import { QueryPrototype } from "./Queries/QueryPrototype";
-import { ComponentData } from "./Components/ComponentData";
-import { TraitData } from "./Traits/TraitData";
-import { ContextData } from "./Contexts/ContextData";
-import { TagData } from "./Tags/TagData";
+import { CreateComponentData } from "./Components/Component.types";
 import { registerContext } from "./Register/registerContext";
-import { registerTrait } from "./Register/registerTrait";
 import { registerTag } from "./Register/registerTag";
 import { registerSystem } from "./Register/registerSystem";
-export declare class NCS {
-    static Pipelines: {
-        OnComponentDataCreate: Pipeline<ComponentData>;
-        OnTraitDataCreate: Pipeline<TraitData>;
-        OnNodeDataCreate: Pipeline<NodeData>;
-        OnContextDataCreate: Pipeline<ContextData>;
-        OnTagDataCreate: Pipeline<TagData>;
-    };
-    static createGraph(dependencies: GraphDependencies): Graph;
-    static createNode(name?: string | null, state?: NodeStateData | null, components?: ComponentData[], children?: NodeData[]): NodeData;
-    static createQuery(data: QueryData): QueryPrototype;
-    static registerSystem: typeof registerSystem;
-    static registerComponent: <ComponentSchema extends object = {}, Data extends object = {}, Logic extends object = {}, Shared extends object = {}>(data: import("./Components/ComponentData").ComponentRegisterData<ComponentSchema, Data, Logic, Shared>) => import("./Components/ComponentData").ComponentRegisterData<ComponentSchema, Data, Logic, Shared> & {
-        getNodes: (grpah: Graph) => Set<NodeInstance>;
-        getComponents: (grpah: Graph) => Set<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
-        set: (node: NodeInstance, componentSchema?: Partial<ComponentSchema> | undefined, traits?: TraitData[], state?: import("./Components/ComponentData").ComponentStateData) => Promise<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>>;
-        get: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
-        getChild: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
-        getParent: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null;
-        getAll: (node: NodeInstance) => import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>[] | null;
-        remove: (node: NodeInstance) => Promise<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared> | null>;
-        removeAll: (node: NodeInstance) => Promise<import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>[] | null>;
+import { Schema } from "./Schema/Schema";
+import { copyComponent, createRemoteComponent, serializeComponent, serializeComponentData } from "./Data/serializeComponent";
+import { deserializeComponentData } from "./Data/deserializeComponent";
+import { cloneNode, copyNode, createRemoteNode, serializeNode, serializeNodeData } from "./Data/serializeNode";
+import { deserializeNodeData } from "./Data/deserializeNode";
+import { ExtractSchemaClass, SchemaCreateData, SchemaProperty } from "./Schema/Schema.types";
+export declare const NCS: {
+    /** Create a graph. */
+    createGraph(): Graph;
+    /** Create node data to add a node to a graph. */
+    createNode(id?: true | null, name?: string | null, tags?: number[] | null, components?: CreateComponentData[], children?: CreateNodeData[]): CreateNodeData;
+    /** Create a schema from an object. */
+    schemaFromObject<T extends Record<string, any>>(data: T): Schema<T>;
+    /** Create a schema for a component or context. */
+    schema<T extends Record<string, SchemaProperty<any>>>(schema: T, views?: SchemaCreateData[]): Schema<ExtractSchemaClass<T>>;
+    /** Create a property for a schema. */
+    property<T>(value: T, meta?: SchemaProperty<T>["meta"]): SchemaProperty<T>;
+    /** Cast and set the type for the Data and Shared properties of a component. */
+    data<T>(data?: any): T;
+    /** Create a query to work with nodes based on specific components and tags. */
+    createQuery(data: QueryData): QueryPrototype;
+    /** Register a system for use with NCS. */
+    registerSystem: typeof registerSystem;
+    /** Register a component for use with NCS. */
+    registerComponent: <Data extends unknown = any, Shared extends unknown = any, ComponentSchema extends object = any>(data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>) => import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared> & {
+        getNodes(grpah: Graph): Generator<import(".").NodeCursor>;
+        getComponents(grpah: Graph): Generator<import(".").ComponentCursor<ComponentSchema, Data, Shared>, any, any>;
+        set(node: import(".").NodeCursor, componentSchema?: import("./Util/Util.types").Nullable<Partial<ComponentSchema>> | undefined, schemaCursor?: import("./Util/Util.types").Nullable<import("./Schema/Schema.types").SchemaCursor<ComponentSchema>> | undefined, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        has(node: import(".").NodeCursor): boolean;
+        get(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequired(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        getChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequiredChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        getParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
+        getRequiredParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined, nodeCursor?: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        getAll(node: import(".").NodeCursor): import(".").ComponentCursor<ComponentSchema, Data, Shared>[] | null;
+        remove(node: import(".").NodeCursor): boolean;
+        removeAll(node: import(".").NodeCursor): boolean;
         nodeData: {
-            get: (node: NodeData) => ComponentData<ComponentSchema> | null;
-            set: (node: NodeData, componentSchema?: Partial<ComponentSchema> | undefined, traits?: TraitData[], state?: import("./Components/ComponentData").ComponentStateData) => void;
-            getAll: (node: NodeData) => ComponentData<ComponentSchema>[] | null;
-            remove: (node: NodeData) => ComponentData<ComponentSchema> | null;
-            removeAll: (node: NodeData) => ComponentData<ComponentSchema>[] | null;
+            get(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema> | null;
+            set(node: import(".").SerializedNodeData, componentSchema?: Partial<ComponentSchema> | undefined): void;
+            getAll(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema>[] | null;
+            remove(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema> | null;
+            removeAll(node: import(".").SerializedNodeData): import(".").SerializedComponentData<ComponentSchema>[] | null;
         };
-        prototype: import("./Components/ComponentPrototype").ComponentPrototype<ComponentSchema, Data, Logic, Shared>;
-        default: import(".").ComponentInstance<ComponentSchema, Data, Logic, Shared>;
-    } & ((schema?: Partial<ComponentSchema> | null | undefined, state?: Partial<import("./Components/ComponentData").ComponentStateData> | null | undefined, ...traits: TraitData[]) => ComponentData<ComponentSchema>);
-    static registerTrait: typeof registerTrait;
-    static registerContext: typeof registerContext;
-    static registerTag: typeof registerTag;
-}
-export declare function Node(data: {
-    name?: string;
-    state?: NodeStateData;
-}, components?: ComponentData[], ...children: NodeData[]): NodeData;
+        type: string;
+        typeId: number;
+        data: import("./Components/Component.types").ComponentRegisterData<ComponentSchema, Data, Shared>;
+        default: import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+    } & ((schema?: Partial<ComponentSchema> | null | undefined, schemaView?: string | null) => CreateComponentData<ComponentSchema>);
+    /** Register a context for use with NCS. */
+    registerContext: typeof registerContext;
+    /** Register a tag for use with NCS. */
+    registerTag: typeof registerTag;
+    /** Serialize a component for storage. */
+    serializeComponent: typeof serializeComponent;
+    /** Serialize component data for storage. */
+    serializeComponentData: typeof serializeComponentData;
+    /** Serialize a component to use in another context. */
+    createRemoteComponent: typeof createRemoteComponent;
+    /** Copy a component. */
+    copyComponent: typeof copyComponent;
+    /** Deserialize a component from storage into component data. */
+    deserializeComponentData: typeof deserializeComponentData;
+    /** Serialize a node for storage. */
+    serializeNode: typeof serializeNode;
+    /** Serialize node data for storage. */
+    serializeNodeData: typeof serializeNodeData;
+    /** Copy a node as is. */
+    copyNode: typeof copyNode;
+    /** Copy a node and change IDs. */
+    cloneNode: typeof cloneNode;
+    /** Serialize a node for use in another context. */
+    createRemoteNode: typeof createRemoteNode;
+    /** Deserialize a node from storage into node data. */
+    deserializeNodeData: typeof deserializeNodeData;
+};

package/NCS.js

@@ -1,41 +1,124 @@
-import { Pipeline } from "@amodx/core/Pipelines";
 import { Graph } from "./Graphs/Graph";
 import { NodeId } from "./Nodes/NodeId";
 import { QueryPrototype } from "./Queries/QueryPrototype";
 import { registerContext } from "./Register/registerContext";
 import { registerComponent } from "./Register/registerComponent";
-import { registerTrait } from "./Register/registerTrait";
 import { registerTag } from "./Register/registerTag";
 import { registerSystem } from "./Register/registerSystem";
-export class NCS {
-    static Pipelines = {
-        OnComponentDataCreate: new Pipeline(),
-        OnTraitDataCreate: new Pipeline(),
-        OnNodeDataCreate: new Pipeline(),
-        OnContextDataCreate: new Pipeline(),
-        OnTagDataCreate: new Pipeline(),
-    };
-    static createGraph(dependencies) {
-        return new Graph(dependencies);
+import { NCSPools } from "./Pools/NCSPools";
+import { Schema } from "./Schema/Schema";
+import { copyComponent, createRemoteComponent, serializeComponent, serializeComponentData, } from "./Data/serializeComponent";
+import { deserializeComponentData } from "./Data/deserializeComponent";
+import { cloneNode, copyNode, createRemoteNode, serializeNode, serializeNodeData, } from "./Data/serializeNode";
+import { deserializeNodeData } from "./Data/deserializeNode";
+import { SchemaProperty, } from "./Schema/Schema.types";
+function traverseCreateSchema(obj, parent) {
+    parent.children ??= [];
+    for (const key in obj) {
+        const schemaProp = obj[key];
+        // If this isn't a SchemaProperty, either skip or handle differently
+        if (!(schemaProp instanceof SchemaProperty)) {
+            continue;
+        }
+        // If the SchemaProperty's value is itself an object, we treat it as a parent
+        if (schemaProp.value !== null &&
+            typeof schemaProp.value === "object" &&
+            !Array.isArray(schemaProp.value)) {
+            // Make a new "parent" property data
+            const newParent = {
+                id: key,
+                meta: schemaProp.meta,
+                value: schemaProp.value,
+            };
+            parent.children.push(newParent);
+            // Recurse into the object’s own keys (which themselves may be SchemaProperties)
+            traverseCreateSchema(schemaProp.value, newParent);
+        }
+        else {
+            // Otherwise it's a leaf (number, boolean, string, etc.)
+            parent.children.push({
+                id: key,
+                meta: schemaProp.meta,
+                value: schemaProp.value,
+            });
+        }
     }
-    static createNode(name, state, components = [], children = []) {
-        return NCS.Pipelines.OnNodeDataCreate.pipe({
-            id: NodeId.Create().idString,
-            components,
-            children,
-            name: name ? name : "",
-            state: state ? state : {},
-        });
-    }
-    static createQuery(data) {
-        return new QueryPrototype(data);
-    }
-    static registerSystem = registerSystem;
-    static registerComponent = registerComponent;
-    static registerTrait = registerTrait;
-    static registerContext = registerContext;
-    static registerTag = registerTag;
-}
-export function Node(data, components, ...children) {
-    return NCS.createNode(data.name, data.state, components, children);
+    return parent;
 }
+export const NCS = {
+    /** Create a graph. */
+    createGraph() {
+        return new Graph();
+    },
+    /** Create node data to add a node to a graph. */
+    createNode(id, name, tags, components, children = []) {
+        const data = NCSPools.createNodeData.get() || [];
+        data[0] = id ? NodeId.Create() : null;
+        data[1] = name || "New Node";
+        data[2] = components || null;
+        data[3] = tags || null;
+        data[4] = children || null;
+        return data;
+    },
+    /** Create a schema from an object. */
+    schemaFromObject(data) {
+        return Schema.FromObject(data);
+    },
+    /** Create a schema for a component or context. */
+    schema(schema, views) {
+        const data = traverseCreateSchema(schema, {
+            id: "root",
+            value: {},
+            children: [],
+        }).children;
+        const s = new Schema(data);
+        if (views) {
+            for (const view of views) {
+                s.createView(view);
+            }
+        }
+        return s;
+    },
+    /** Create a property for a schema. */
+    property(value, meta = {}) {
+        return new SchemaProperty(value, meta);
+    },
+    /** Cast and set the type for the Data and Shared properties of a component. */
+    data(data = {}) {
+        return data;
+    },
+    /** Create a query to work with nodes based on specific components and tags. */
+    createQuery(data) {
+        return new QueryPrototype(data);
+    },
+    /** Register a system for use with NCS. */
+    registerSystem,
+    /** Register a component for use with NCS. */
+    registerComponent,
+    /** Register a context for use with NCS. */
+    registerContext,
+    /** Register a tag for use with NCS. */
+    registerTag,
+    /** Serialize a component for storage. */
+    serializeComponent,
+    /** Serialize component data for storage. */
+    serializeComponentData,
+    /** Serialize a component to use in another context. */
+    createRemoteComponent,
+    /** Copy a component. */
+    copyComponent,
+    /** Deserialize a component from storage into component data. */
+    deserializeComponentData,
+    /** Serialize a node for storage. */
+    serializeNode,
+    /** Serialize node data for storage. */
+    serializeNodeData,
+    /** Copy a node as is. */
+    copyNode,
+    /** Copy a node and change IDs. */
+    cloneNode,
+    /** Serialize a node for use in another context. */
+    createRemoteNode,
+    /** Deserialize a node from storage into node data. */
+    deserializeNodeData,
+};