@amodx/ncs 0.0.1 → 0.0.2

package/Register/NCSRegister.js

@@ -1,7 +1,30 @@
-import { ItemRegister } from "./ItemRegister";
+import { IdPalette } from "../Util/IdPalette";
+class ItemRegister {
+    itemtype;
+    items = [];
+    idPalette = new IdPalette();
+    constructor(itemtype) {
+        this.itemtype = itemtype;
+    }
+    get(id) {
+        const item = typeof id == "string"
+            ? this.items[this.idPalette.getNumberId(id)]
+            : this.items[id];
+        if (!item)
+            throw new Error(`[${this.itemtype}]: Entry with id ${id} does not exist`);
+        return item;
+    }
+    has(id) {
+        return this.idPalette.isRegistered(id);
+    }
+    register(id, item) {
+        const itemId = this.idPalette.register(id);
+        this.items[itemId] = item;
+        return itemId;
+    }
+}
 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

@@ -1,29 +1,35 @@
-import { ComponentData, ComponentRegisterData, ComponentStateData } from "../Components/ComponentData";
-import { ComponentInstance } from "../Components/ComponentInstance";
+import { ComponentRegisterData, CreateComponentData } from "../Components/Component.types";
 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>;
+import { SerializedNodeData, SerializedComponentData } from "../Data/SerializedData.types";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { SchemaCursor } from "../Schema/Schema.types";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { Nullable } from "Util/Util.types";
+type RegisteredComponent<ComponentSchema extends object = any, Data extends any = any, Shared extends any = any> = (ComponentRegisterData<ComponentSchema, Data, Shared> & {
+    getNodes(grpah: Graph): Generator<NodeCursor>;
+    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>;
+    getAll(node: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>[] | null;
+    remove(node: NodeCursor): boolean;
+    removeAll(node: NodeCursor): boolean;
     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;
+        get(node: SerializedNodeData): SerializedComponentData<ComponentSchema> | null;
+        set(node: SerializedNodeData, componentSchema?: Partial<ComponentSchema>): void;
+        getAll(node: SerializedNodeData): SerializedComponentData<ComponentSchema>[] | null;
+        remove(node: SerializedNodeData): SerializedComponentData<ComponentSchema> | null;
+        removeAll(node: SerializedNodeData): SerializedComponentData<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>;
+    type: string;
+    typeId: number;
+    data: ComponentRegisterData<ComponentSchema, Data, Shared>;
+    default: ComponentCursor<ComponentSchema, Data, Shared>;
+}) & ((schema?: Partial<ComponentSchema> | null | undefined, schemaView?: string | null) => CreateComponentData<ComponentSchema>);
+export declare const registerComponent: <Data extends unknown = any, Shared extends unknown = any, ComponentSchema extends object = any>(data: ComponentRegisterData<ComponentSchema, Data, Shared>) => RegisteredComponent<ComponentSchema, Data, Shared>;
 export {};

package/Register/registerComponent.js

@@ -1,37 +1,90 @@
-import { ComponentInstanceMap } from "../Components/ComponentInstanceMap";
-import { NCS } from "../NCS";
 import { NCSRegister } from "./NCSRegister";
-import { ComponentPrototype } from "../Components/ComponentPrototype";
+import { ComponentCursor } from "../Components/ComponentCursor";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { NCSPools } from "../Pools/NCSPools";
 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 || {}),
-            },
-        });
+    const typeId = NCSRegister.components.register(data.type, data);
+    data.shared = data.shared || {};
+    const createComponent = (schema, schemaView) => {
+        const createData = NCSPools.createComponentData.get() || [];
+        createData[0] = data.type;
+        createData[1] = schema || {};
+        createData[2] = schemaView || "default";
+        return createData;
     };
     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),
+        data,
+        type: data.type,
+        typeId,
+        *getNodes(graph, nodeCursor = NodeCursor.Get()) {
+            const array = graph._components[typeId];
+            if (!array)
+                return false;
+            for (let i = 0; i < array._disposed.length; i++) {
+                nodeCursor.setNode(graph, array._node[i]);
+                yield nodeCursor;
+            }
+            NodeCursor.Retrun(nodeCursor);
+            return true;
+        },
+        *getComponents(graph, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
+            const array = graph._components[typeId];
+            if (!array)
+                return false;
+            for (let i = 0; i < array._disposed.length; i++) {
+                nodeCursor.setNode(graph, array._node[i]);
+                cursor.setInstance(nodeCursor, typeId, i);
+                yield cursor;
+            }
+            ComponentCursor.Retrun(cursor);
+            NodeCursor.Retrun(nodeCursor);
+            return true;
+        },
+        set(node, schema, schemaView, cursor = ComponentCursor.Get()) {
+            const newComponent = node.components.add(createComponent(schema, schemaView));
+            cursor.setInstance(node, typeId, newComponent);
+            node.graph._components[typeId].init(newComponent);
+            return cursor;
+        },
+        has(node) {
+            return node.components.has(data.type);
+        },
+        get(node, cursor) {
+            return node.components.get(data.type, cursor);
+        },
+        getRequired(node, cursor) {
+            const found = node.components.get(data.type, cursor);
+            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);
+        },
+        getRequiredChild(node, cursor) {
+            const comp = node.components.getChild(data.type, cursor);
+            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);
+        },
+        getRequiredParent(node, cursor = ComponentCursor.Get()) {
+            const comp = node.components.getParent(data.type, cursor);
+            if (!comp)
+                throw new Error(`Node [${node.name}] does not have a parent with required component [${data.type}].`);
+            return comp;
+        },
+        getAll(node) {
+            return node.components.getAll(data.type);
+        },
+        removeAll(node) {
+            return node.components.removeAll(data.type);
+        },
+        remove(node) {
+            return node.components.remove(data.type);
+        },
         nodeData: {
             get: (node) => node.components?.find((_) => _.type == data.type) || null,
             getAll: (node) => node.components?.filter((_) => _.type == data.type),
@@ -41,13 +94,12 @@ export const registerComponent = (data) => {
                 node.components = node.components?.filter((_) => _.type != data.type);
                 return all?.length ? all : null;
             },
-            set: (node, schema, state, ...traits) => {
+            set: (node, schema) => {
                 node.components ??= [];
-                node.components.push(createComponent(schema
-                    ? schema
-                    : data.schema
-                        ? structuredClone(prototype.baseContextSchema)
-                        : {}, state, ...traits));
+                node.components.push({
+                    type: data.type,
+                    schema: {},
+                });
             },
         },
     });

package/Register/registerContext.d.ts

@@ -1,16 +1,13 @@
-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";
+import { ContextRegisterData, CreateContextData } from "../Contexts/Context.types";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { ContextCursor } from "../Contexts/ContextCursor";
 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);
+    set: (parent: NodeCursor, schema?: ContextSchema | null, schemaView?: string | null, data?: Data | null) => ContextCursor<ContextSchema, Data>;
+    get: (parent: NodeCursor) => ContextCursor<ContextSchema, Data> | null;
+    getRequired: (parent: NodeCursor) => ContextCursor<ContextSchema, Data>;
+    remove: (parent: NodeCursor) => ContextCursor<ContextSchema, Data> | null;
+    data: ContextRegisterData<ContextSchema, Data>;
+    default: ContextCursor<ContextSchema, Data>;
+}) & ((schema?: ContextSchema, schemaViewId?: string, data?: Data) => CreateContextData);
 export declare function registerContext<ContextSchema extends {} = {}, Data extends object = {}>(data: ContextRegisterData<ContextSchema, Data>): RegisteredContext<ContextSchema, Data>;
 export {};

package/Register/registerContext.js

@@ -1,25 +1,20 @@
-import { NCS } from "../NCS";
 import { NCSRegister } from "./NCSRegister";
-import { ContextPrototype } from "../Contexts/ContextPrototype";
+import { NCSPools } from "../Pools/NCSPools";
 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 || {}),
-            },
-        });
+    NCSRegister.contexts.register(data.type, data);
+    const createContext = (schema, schemaViewId, contextData) => {
+        const createData = NCSPools.createContextData.get() || [];
+        createData[0] = data.type;
+        createData[1] = schema || {};
+        createData[2] = schemaViewId || "default";
+        createData[3] = contextData || null;
+        return createData;
     };
     return Object.assign(createContext, data, {
-        prototype,
-        set: (parent, schema, data) => {
-            const newContext = parent.context.add(createContext(schema));
-            if (data) {
-                newContext.data = data;
-            }
+        data,
+        set: (parent, schema, schemaViewId, data) => {
+            const newContext = parent.context.add(createContext(schema, schemaViewId, data));
+            return newContext;
         },
         get: (parent) => {
             return parent.context.get(data.type);

package/Register/registerSystem.d.ts

@@ -1,5 +1,5 @@
 import { SystemPrototype } from "../Systems/SystemPrototype";
-import { SystemRegisterData } from "../Systems/SystemData";
+import { SystemRegisterData } from "../Systems/System.types";
 import { Graph } from "../Graphs/Graph";
 import { SystemInstance } from "../Systems/SystemInstance";
 type RegisteredSystem = SystemRegisterData & {

package/Register/registerSystem.js

@@ -2,7 +2,7 @@ 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);
+    NCSRegister.systems.register(data.type, prototype);
     return Object.assign(data, {
         prototype,
         set: (graph) => prototype.add(graph),

package/Register/registerTag.d.ts

@@ -1,21 +1,19 @@
-import { TagData, TagRegisterData } from "../Tags/TagData";
-import { NodeInstance } from "../Nodes/NodeInstance";
-import { TagInstance } from "../Tags/TagInstance";
+import { TagRegisterData } from "../Tags/Tag.types";
+import { NodeCursor } from "../Nodes/NodeCursor";
+import { TagCursor } from "../Tags/TagCursor";
 import { Tag } from "../Tags/Tag";
-import { TagPrototype } from "../Tags/TagPrototype";
 import { Graph } from "../Graphs/Graph";
-type RegisteredTag = (TagRegisterData & {
+export 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);
+    data: TagRegisterData;
+    set(parent: NodeCursor, cursor?: TagCursor): TagCursor;
+    get(parent: NodeCursor, cursor?: TagCursor): TagCursor | null;
+    getChild(parent: NodeCursor, cursor?: TagCursor): TagCursor | null;
+    getAllChildlren(parent: NodeCursor): TagCursor[] | null;
+    getParent(parent: NodeCursor, cursor?: TagCursor): TagCursor | null;
+    getAllParents(parent: NodeCursor): TagCursor[] | null;
+    remove(parent: NodeCursor): boolean;
+    getNodes(grpah: Graph): Generator<NodeCursor>;
+    getTags(grpah: Graph): Generator<TagCursor>;
+}) & (() => number);
 export declare function registerTag(data: TagRegisterData): RegisteredTag;
-export {};

package/Register/registerTag.js

@@ -1,42 +1,39 @@
-import { NCS } from "../NCS";
 import { NCSRegister } from "./NCSRegister";
+import { TagCursor } from "../Tags/TagCursor";
 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 typeId = NCSRegister.tags.register(data.id, tag);
+    // const map = TagInstanceMap.registerTag(tag.id);
     const createTag = () => {
-        return NCS.Pipelines.OnTagDataCreate.pipe({
-            id: data.id,
-        });
+        return typeId;
     };
     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);
+        data,
+        // getNodes: (graph: Graph) => map.getNodes(graph),
+        // getTags: (graph: Graph) => map.getItems(graph),
+        getChild(parent, cursor) {
+            return parent.tags.getChild(data.id, cursor);
         },
-        getAllChildlren: (parent) => {
+        getAllChildlren(parent) {
             return parent.tags.getAllChildlren(data.id);
         },
-        getParent: (parent) => {
-            return parent.tags.getParent(data.id);
+        getParent(parent, cursor) {
+            return parent.tags.getParent(data.id, cursor);
         },
-        getAllParents: (parent) => {
+        getAllParents(parent) {
             return parent.tags.getAllParents(data.id);
         },
-        set: (parent) => {
-            return parent.tags.add(createTag());
+        set(parent, cursor = TagCursor.Get()) {
+            const newTag = parent.tags.add(createTag());
+            cursor.setTag(parent, typeId, newTag);
+            return cursor;
         },
-        get: (parent) => {
-            return parent.tags.get(data.id);
+        get(parent, cursor) {
+            return parent.tags.get(data.id, cursor);
         },
-        remove: (parent) => {
+        remove(parent) {
             return parent.tags.remove(data.id);
         },
     });

package/Schema/Functions/createBaseSchemaCursor.d.ts

@@ -0,0 +1,18 @@
+import { SchemaArrayCursor } from "../SchemaArrayCursor";
+import { SchemaView } from "../SchemaView";
+import { SchemaArray } from "../SchemaArray";
+export declare function createBaseSchemaCursor(): {
+    new (__view: SchemaView<any>): {
+        __cursor: SchemaArrayCursor;
+        __cursors: never[];
+        __view: SchemaView<any>;
+        __array: SchemaArray;
+        __index: number;
+        setInstance(index: number): void;
+        getInstance(): number;
+        getCursor(): SchemaArrayCursor;
+        getSchemaIndex(): import("../Schema.types").SchemaCursorIndex<any>;
+        clone(): any;
+        toJSON(): any;
+    };
+};

package/Schema/Functions/createBaseSchemaCursor.js

@@ -0,0 +1,34 @@
+import { SchemaArrayCursor } from "../SchemaArrayCursor";
+export function createBaseSchemaCursor() {
+    class SchemaCursor {
+        __view;
+        __cursor;
+        __cursors = [];
+        constructor(__view) {
+            this.__view = __view;
+            this.__cursor = new SchemaArrayCursor(this.__view.schema.array);
+        }
+        __array;
+        __index;
+        setInstance(index) {
+            this.__cursor.setIndex(index);
+        }
+        getInstance() {
+            return this.__cursor._index;
+        }
+        getCursor() {
+            return this.__cursor;
+        }
+        getSchemaIndex() {
+            return this.__view.schema.index;
+        }
+        clone() {
+            const newCursor = new SchemaCursor(this.__view);
+            return newCursor;
+        }
+        toJSON() {
+            return this.__view.toJSON(this);
+        }
+    }
+    return SchemaCursor;
+}

package/Schema/Functions/createSchemaBinaryObjectCursorClass.d.ts

@@ -0,0 +1,22 @@
+import { BinaryObjectSchemaView } from "../Schema.types";
+import { Schema } from "../Schema";
+import { PropertyMetaData } from "../Property/Property.types";
+import { SchemaView } from "../SchemaView";
+import { SchemaArrayCursor } from "../SchemaArrayCursor";
+export declare function setBinaryObjectData(current: BinaryObjectSchemaView, meta: PropertyMetaData, index: number, value: number): void;
+export declare function getBinaryObjectData(current: BinaryObjectSchemaView, meta: PropertyMetaData, index: number): any;
+export declare function createSchemaBinaryObjectCursorClass(schema: Schema): {
+    new (__view: SchemaView<any>): {
+        __cursor: SchemaArrayCursor;
+        __cursors: never[];
+        __view: SchemaView<any>;
+        __array: import("../SchemaArray").SchemaArray;
+        __index: number;
+        setInstance(index: number): void;
+        getInstance(): number;
+        getCursor(): SchemaArrayCursor;
+        getSchemaIndex(): import("../Schema.types").SchemaCursorIndex<any>;
+        clone(): any;
+        toJSON(): any;
+    };
+};

package/Schema/Functions/createSchemaBinaryObjectCursorClass.js

@@ -0,0 +1,134 @@
+import { createBaseSchemaCursor } from "./createBaseSchemaCursor";
+const valueSetMap = {
+    i8(dataView, index, value) {
+        dataView.setInt8(index, value);
+    },
+    ui8(dataView, index, value) {
+        dataView.setUint8(index, value);
+    },
+    i16(dataView, index, value) {
+        dataView.setInt16(index, value);
+    },
+    ui16(dataView, index, value) {
+        dataView.setUint16(index, value);
+    },
+    i32(dataView, index, value) {
+        dataView.setInt32(index, value);
+    },
+    ui32(dataView, index, value) {
+        dataView.setUint32(index, value);
+    },
+    f32(dataView, index, value) {
+        dataView.setFloat32(index, value);
+    },
+    f64(dataView, index, value) {
+        dataView.setFloat64(index, value);
+    },
+};
+const valueGetMap = {
+    i8(dataView, index) {
+        return dataView.getInt8(index);
+    },
+    ui8(dataView, index) {
+        return dataView.getUint8(index);
+    },
+    i16(dataView, index) {
+        return dataView.getInt16(index);
+    },
+    ui16(dataView, index) {
+        return dataView.getUint16(index);
+    },
+    i32(dataView, index) {
+        return dataView.getInt32(index);
+    },
+    ui32(dataView, index) {
+        return dataView.getUint32(index);
+    },
+    f32(dataView, index) {
+        return dataView.getFloat32(index);
+    },
+    f64(dataView, index) {
+        return dataView.getFloat64(index);
+    },
+};
+export function setBinaryObjectData(current, meta, index, value) {
+    if (!meta.binary)
+        return undefined;
+    if (typeof meta.binary == "object")
+        return meta.binary.set(current.view, meta, index, value);
+    return valueSetMap[meta.binary](current.view, index, value);
+}
+export function getBinaryObjectData(current, meta, index) {
+    if (!meta.binary)
+        return undefined;
+    if (typeof meta.binary == "object")
+        return meta.binary.get(current.view, meta, index);
+    return valueGetMap[meta.binary](current.view, index);
+}
+function traverse(parent, properties) {
+    for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        const index = property.index;
+        if (!property.children) {
+            Object.defineProperty(parent.prototype, property.id, {
+                get() {
+                    if (this.__cursor.hasProxy(index)) {
+                        return this.__cursor.fetchProxyData(index);
+                    }
+                    return getBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index]);
+                },
+                set(value) {
+                    let obs = this.__cursor.getObserver(index);
+                    let proxy = this.__cursor.hasProxy(index);
+                    if (obs) {
+                        const oldVale = proxy
+                            ? this.__cursor.fetchProxyData(index)
+                            : getBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index]);
+                        if (oldVale != value) {
+                            setBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index], value);
+                            if (proxy) {
+                                this.__cursor.setProxyData(index, value);
+                            }
+                            obs.notify(value);
+                            return;
+                        }
+                    }
+                    setBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index], value);
+                    if (proxy) {
+                        this.__cursor.setProxyData(index, value);
+                    }
+                },
+            });
+            continue;
+        }
+        class SchemaCursorProperty {
+            __cursor;
+            __cursors;
+            __view;
+            constructor(__cursor, __cursors, __view) {
+                this.__cursor = __cursor;
+                this.__cursors = __cursors;
+                this.__view = __view;
+            }
+        }
+        traverse(SchemaCursorProperty, property.children);
+        Object.defineProperty(parent.prototype, property.id, {
+            get() {
+                let v = this.__cursors[index];
+                if (!v) {
+                    v = new SchemaCursorProperty(this.__cursor, this.__cursors, this.__view);
+                    this.__cursors[index] = v;
+                }
+                return v;
+            },
+            set(value) {
+                //  (this as SchemaClassBase).__data.current[index] = value;
+            },
+        });
+    }
+}
+export function createSchemaBinaryObjectCursorClass(schema) {
+    const SchemaCursor = createBaseSchemaCursor();
+    traverse(SchemaCursor, schema.root.children);
+    return SchemaCursor;
+}

package/Schema/Functions/createSchemaIndex.d.ts

@@ -0,0 +1,3 @@
+import { SchemaCursorIndex } from "../Schema.types";
+import { Schema } from "../Schema";
+export declare function createSchemaIndex<T = any>(schema: Schema): SchemaCursorIndex<T>;