@amodx/ncs 0.0.2 → 0.0.21

package/Contexts/ContextCursor.d.ts

@@ -2,6 +2,7 @@ import { ContextRegisterData } from "./Context.types";
 import { ContextArray } from "./ContextArray";
 import { NodeCursor } from "../Nodes/NodeCursor";
 import { SchemaCursor } from "../Schema/Schema.types";
+import { Graph } from "../Graphs/Graph";
 export declare class ContextCursor<ContextSchema extends {} = {}, Data extends {} = {}> {
     static Get(): ContextCursor<{}, {}>;
     static Retrun(cursor: ContextCursor): boolean;
@@ -10,9 +11,12 @@ export declare class ContextCursor<ContextSchema extends {} = {}, Data extends {
     _type: number;
     get index(): number;
     get data(): Data;
+    set data(data: Data);
     schema: SchemaCursor<ContextSchema>;
     get nodes(): number[];
     get type(): string;
+    private _graph;
+    get graph(): Graph;
     arrays: ContextArray;
     private constructor();
     setContext(node: NodeCursor, index: number): void;

package/Contexts/ContextCursor.js

@@ -19,6 +19,9 @@ export class ContextCursor {
     get data() {
         return this.arrays._data[this._index];
     }
+    set data(data) {
+        this.arrays._data[this._index] = data;
+    }
     schema;
     get nodes() {
         return this.arrays._node[this._index];
@@ -26,11 +29,16 @@ export class ContextCursor {
     get type() {
         return NCSRegister.contexts.idPalette.getStringId(this.arrays._type[this._index]);
     }
+    _graph;
+    get graph() {
+        return this._graph;
+    }
     arrays;
     constructor() { }
     setContext(node, index) {
         this._index = index;
         this.arrays = node.graph._contexts;
+        this._graph = node.graph;
         this._type = this.arrays._type[index];
     }
     dispose() {

package/NCS.d.ts

@@ -35,12 +35,12 @@ export declare const NCS: {
         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): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequired(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequiredChild(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
-        getParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared> | null;
-        getRequiredParent(node: import(".").NodeCursor, cursor?: import(".").ComponentCursor<ComponentSchema, Data, Shared> | undefined): import(".").ComponentCursor<ComponentSchema, Data, Shared>;
+        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;

package/NCS.js

@@ -12,33 +12,39 @@ 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";
-const traverseCreateSchema = (object, parent) => {
-    for (const key in object) {
-        parent.children ??= [];
-        const value = object[key];
-        if (value instanceof SchemaProperty) {
-            if (value.value instanceof SchemaProperty &&
-                typeof value.value.value == "object") {
-                const newParent = {
-                    id: key,
-                    meta: value.meta,
-                    value: value.value,
-                    children: [],
-                };
-                parent.children.push(newParent);
-                traverseCreateSchema(value.value.value, newParent);
-            }
-            else {
-                parent.children.push({
-                    id: key,
-                    meta: value.meta,
-                    value: value.value,
-                });
-            }
+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,
+            });
         }
     }
     return parent;
-};
+}
 export const NCS = {
     /** Create a graph. */
     createGraph() {
@@ -60,11 +66,12 @@ export const NCS = {
     },
     /** Create a schema for a component or context. */
     schema(schema, views) {
-        const s = new Schema(traverseCreateSchema(schema, {
+        const data = traverseCreateSchema(schema, {
             id: "root",
             value: {},
             children: [],
-        }).children);
+        }).children;
+        const s = new Schema(data);
         if (views) {
             for (const view of views) {
                 s.createView(view);

package/Nodes/NodeComponents.d.ts

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

package/Nodes/NodeComponents.js

@@ -1,4 +1,5 @@
 import { ComponentCursor } from "../Components/ComponentCursor";
+import { NodeCursor } from "./NodeCursor";
 import { NCSRegister } from "../Register/NCSRegister";
 import { ComponentArray } from "../Components/ComponentArray";
 import { NCSPools } from "../Pools/NCSPools";
@@ -110,14 +111,16 @@ export class NodeComponents {
         }
         return false;
     }
-    get(type, cursor = ComponentCursor.Get()) {
+    get(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
         const components = this.components;
         if (!components)
             return null;
         const numberId = NCSRegister.components.idPalette.getNumberId(type);
         for (let i = 0; i < components.length; i += 2) {
             if (components[i] == numberId) {
-                cursor.setInstance(this.node, numberId, components[i + 1]);
+                if (nodeCursor !== this.node)
+                    this.node.cloneCursor(nodeCursor);
+                cursor.setInstance(nodeCursor, numberId, components[i + 1]);
                 return cursor;
             }
         }
@@ -157,21 +160,21 @@ export class NodeComponents {
         }
         return true;
     }
-    getChild(type, cursor = ComponentCursor.Get()) {
+    getChild(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
         for (const child of this.node.traverseChildren()) {
             if (!child.components)
                 continue;
-            const found = child.components.get(type, cursor);
+            const found = child.components.get(type, cursor, nodeCursor);
             if (found)
                 return found;
         }
         return null;
     }
-    getParent(type, cursor = ComponentCursor.Get()) {
+    getParent(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
         for (const parent of this.node.traverseParents()) {
             if (!parent.components)
                 continue;
-            const found = parent.components.get(type, cursor);
+            const found = parent.components.get(type, cursor, nodeCursor);
             if (found)
                 return found;
         }

package/Nodes/NodeEvents.d.ts

@@ -15,7 +15,9 @@ export declare class NodeEvents {
     private constructor();
     hasListener(id: string): boolean;
     clearListeners(id: string): false | undefined;
-    addListener<Data>(id: string, run: (data: Data) => void): void;
+    addListener<Data>(id: string, run: (data: Data) => void, options?: {
+        once?: boolean;
+    }): void;
     removeListener(id: string, run: ObservableFunction<any>): boolean;
     dispatch<Data>(id: string, data: Data): boolean;
     dispatchDeep<Data>(id: string, data: Data): void;

package/Nodes/NodeEvents.js

@@ -41,7 +41,7 @@ export class NodeEvents {
         NCSPools.observers.addItem(observer);
         this.node.arrays._events[numberId][this.index] = undefined;
     }
-    addListener(id, run) {
+    addListener(id, run, options) {
         const numberId = this.node.arrays._eventPalette.isRegistered(id)
             ? this.node.arrays._eventPalette.getNumberId(id)
             : this.node.arrays._eventPalette.register(id);
@@ -55,7 +55,12 @@ export class NodeEvents {
             observer = NCSPools.observers.get() || new Observable();
             observers[this.index] = observer;
         }
-        observer.subscribe(run);
+        if (options?.once) {
+            observer.subscribeOnce(run);
+        }
+        else {
+            observer.subscribe(run);
+        }
     }
     removeListener(id, run) {
         const numberId = this.node.arrays._eventPalette.getNumberId(id);

package/Register/registerComponent.d.ts

@@ -10,12 +10,12 @@ type RegisteredComponent<ComponentSchema extends object = any, Data extends any
     getComponents(grpah: Graph): Generator<ComponentCursor<ComponentSchema, Data, Shared>>;
     set(node: NodeCursor, componentSchema?: Nullable<Partial<ComponentSchema>>, schemaCursor?: Nullable<SchemaCursor<ComponentSchema>>, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared>;
     has(node: NodeCursor): boolean;
-    get(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared> | null;
-    getRequired(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared>;
-    getChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared> | null;
-    getRequiredChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared>;
-    getParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared> | null;
-    getRequiredParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>): ComponentCursor<ComponentSchema, Data, Shared>;
+    get(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+    getRequired(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+    getChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+    getRequiredChild(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
+    getParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared> | null;
+    getRequiredParent(node: NodeCursor, cursor?: ComponentCursor<ComponentSchema, Data, Shared>, nodeCursor?: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>;
     getAll(node: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>[] | null;
     remove(node: NodeCursor): boolean;
     removeAll(node: NodeCursor): boolean;

package/Register/registerComponent.js

@@ -49,29 +49,29 @@ export const registerComponent = (data) => {
         has(node) {
             return node.components.has(data.type);
         },
-        get(node, cursor) {
-            return node.components.get(data.type, cursor);
+        get(node, cursor, nodeCursor) {
+            return node.components.get(data.type, cursor, nodeCursor);
         },
-        getRequired(node, cursor) {
-            const found = node.components.get(data.type, cursor);
+        getRequired(node, cursor, nodeCursor) {
+            const found = node.components.get(data.type, cursor, nodeCursor);
             if (!found)
                 throw new Error(`Node [${node.name}] does not have required component [${data.type}].`);
             return found;
         },
-        getChild(node, cursor) {
-            return node.components.getChild(data.type, cursor);
+        getChild(node, cursor, nodeCursor) {
+            return node.components.getChild(data.type, cursor, nodeCursor);
         },
-        getRequiredChild(node, cursor) {
-            const comp = node.components.getChild(data.type, cursor);
+        getRequiredChild(node, cursor, nodeCursor) {
+            const comp = node.components.getChild(data.type, cursor, nodeCursor);
             if (!comp)
                 throw new Error(`Node [${node.name}] does not have a child with required component [${data.type}].`);
             return comp;
         },
-        getParent(node, cursor) {
-            return node.components.getParent(data.type, cursor);
+        getParent(node, cursor, nodeCursor) {
+            return node.components.getParent(data.type, cursor, nodeCursor);
         },
-        getRequiredParent(node, cursor = ComponentCursor.Get()) {
-            const comp = node.components.getParent(data.type, cursor);
+        getRequiredParent(node, cursor, nodeCursor) {
+            const comp = node.components.getParent(data.type, cursor, nodeCursor);
             if (!comp)
                 throw new Error(`Node [${node.name}] does not have a parent with required component [${data.type}].`);
             return comp;

package/Register/registerContext.js

@@ -1,4 +1,5 @@
 import { NCSRegister } from "./NCSRegister";
+import { ContextCursor } from "../Contexts/ContextCursor";
 import { NCSPools } from "../Pools/NCSPools";
 export function registerContext(data) {
     NCSRegister.contexts.register(data.type, data);
@@ -12,9 +13,13 @@ export function registerContext(data) {
     };
     return Object.assign(createContext, data, {
         data,
-        set: (parent, schema, schemaViewId, data) => {
+        set: (parent, schema, schemaViewId, data, cursor = ContextCursor.Get()) => {
             const newContext = parent.context.add(createContext(schema, schemaViewId, data));
-            return newContext;
+            if (data) {
+                parent.graph._contexts._data[newContext] = data;
+            }
+            cursor.setContext(parent, newContext);
+            return cursor;
         },
         get: (parent) => {
             return parent.context.get(data.type);

package/Schema/Schema.js

@@ -11,7 +11,7 @@ const traverseCreate = (parent, properties, index) => {
     parent.children ??= [];
     for (let i = 0; i < properties.length; i++) {
         const data = properties[i];
-        if (typeof data.value == "object" && !data.children) {
+        if (typeof data.value == "object" && !data.children?.length) {
             data.children ??= [];
             for (const key in data.value) {
                 const value = data.value[key];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amodx/ncs",
-  "version": "0.0.02",
+  "version": "0.0.21",
   "module": "index.js",
   "types": "index.d.ts",
   "type": "module",