@amodx/ncs 0.0.24 → 0.0.27

package/Nodes/NodeComponents.js

@@ -24,7 +24,7 @@ export class NodeComponents {
         const components = this.components;
         const tempCursor = ComponentCursor.Get();
         for (let i = 0; i < components.length; i += 2) {
-            tempCursor.setInstance(this.node, components[i], components[i + 1]);
+            tempCursor.setInstance(this.node.index, this.node.graph, components[i], components[i + 1]);
             tempCursor.dispose();
         }
         tempCursor.returnCursor();
@@ -66,7 +66,7 @@ export class NodeComponents {
         compArray.observers.nodeAdded.notify(this.node.index);
         const temp = ComponentCursor.Get();
         if (this.node.hasObservers) {
-            temp.setInstance(this.node, typeId, componentIndex);
+            temp.setInstance(this.node.index, this.node.graph, typeId, componentIndex);
             this.node.observers.isComponentAddedSet &&
                 this.node.observers.componentAdded.notify(temp);
             this.node.observers.isComponentsUpdatedSet &&
@@ -92,7 +92,7 @@ export class NodeComponents {
         if (removeIndex == -1)
             return;
         const temp = ComponentCursor.Get();
-        temp.setInstance(this.node, numberId, removeComponentIndex);
+        temp.setInstance(this.node.index, this.node.graph, numberId, removeComponentIndex);
         this.components.splice(removeIndex, 2);
         if (this.node.hasObservers) {
             this.node.observers.isComponentRemovedSet &&
@@ -116,18 +116,24 @@ export class NodeComponents {
         }
         return false;
     }
-    get(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
+    get(type, cursor = null) {
         const components = this.components;
         if (!components)
             return null;
+        let usedTemp = false;
+        if (!cursor) {
+            cursor = ComponentCursor.Get();
+            usedTemp = true;
+        }
         const numberId = NCSRegister.components.idPalette.getNumberId(type);
         for (let i = 0; i < components.length; i += 2) {
             if (components[i] == numberId) {
-                nodeCursor.setNode(this.node.graph, this.node.index);
-                cursor.setInstance(nodeCursor, numberId, components[i + 1]);
+                cursor.setInstance(this.node.index, this.node.graph, numberId, components[i + 1]);
                 return cursor;
             }
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return null;
     }
     getAll(type) {
@@ -139,7 +145,7 @@ export class NodeComponents {
         for (let i = 0; i < components.length; i += 2) {
             if (components[i] == numberId) {
                 const cursor = ComponentCursor.Get();
-                cursor.setInstance(this.node, components[i], components[i + 1]);
+                cursor.setInstance(this.node.index, this.node.graph, components[i], components[i + 1]);
                 cursors.push(cursor);
             }
         }
@@ -153,7 +159,7 @@ export class NodeComponents {
         const tempCursor = ComponentCursor.Get();
         for (let i = components.length; i > 0; i -= 2) {
             if (components[i] == numberId) {
-                tempCursor.setInstance(this.node, components[i], components[i + 1]);
+                tempCursor.setInstance(this.node.index, this.node.graph, components[i], components[i + 1]);
                 this.components.splice(i, 2);
                 if (this.node.hasObservers) {
                     this.node.observers.isComponentRemovedSet &&
@@ -166,32 +172,47 @@ export class NodeComponents {
         tempCursor.returnCursor();
         return true;
     }
-    getChild(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
+    getChild(type, cursor = null) {
+        let usedTemp = false;
+        if (!cursor) {
+            cursor = ComponentCursor.Get();
+            usedTemp = true;
+        }
         const tempCursor = NodeCursor.Get();
         for (const child of this.node.traverseChildren(tempCursor)) {
             if (!child.components)
                 continue;
-            nodeCursor.setNode(this.node.graph, child.index);
-            const found = child.components.get(type, cursor, nodeCursor);
+            const found = child.components.get(type, cursor);
             if (found) {
                 tempCursor.returnCursor();
                 return found;
             }
         }
+        if (usedTemp) {
+            cursor.returnCursor();
+        }
         tempCursor.returnCursor();
         return null;
     }
-    getParent(type, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
+    getParent(type, cursor = null) {
+        let usedTemp = false;
+        if (!cursor) {
+            cursor = ComponentCursor.Get();
+            usedTemp = true;
+        }
         const tempCursor = NodeCursor.Get();
         for (const parent of this.node.traverseParents(tempCursor)) {
             if (!parent.components)
                 continue;
-            const found = parent.components.get(type, cursor, nodeCursor);
+            const found = parent.components.get(type, cursor);
             if (found) {
                 tempCursor.returnCursor();
                 return found;
             }
         }
+        if (usedTemp) {
+            cursor.returnCursor();
+        }
         tempCursor.returnCursor();
         return null;
     }

package/Nodes/NodeContext.js

@@ -26,7 +26,7 @@ export class NodeContext {
             defaultCursor.setContext(this.node, context[i]);
             defaultCursor.dispose();
         }
-        ContextCursor.Retrun(defaultCursor);
+        defaultCursor.returnCursor();
     }
     add(contextData) {
         const cursor = ContextCursor.Get();
@@ -54,7 +54,7 @@ export class NodeContext {
         contextData[2] = null;
         contextData[3] = null;
         NCSPools.createContextData.addItem(contextData);
-        ContextCursor.Retrun(cursor);
+        cursor.returnCursor();
         return newContext;
     }
     remove(type) {
@@ -70,11 +70,11 @@ export class NodeContext {
                         break;
                     }
                 }
-                ContextCursor.Retrun(cursor);
+                cursor.returnCursor();
                 return true;
             }
         }
-        ContextCursor.Retrun(cursor);
+        cursor.returnCursor();
         return false;
     }
     get(type) {
@@ -94,14 +94,14 @@ export class NodeContext {
                 for (let i = 0; i < context.length; i++) {
                     cursor.setContext(parent, context[i]);
                     if (cursor.type == type) {
-                        //@todo add anchor
                         cursor.setContext(parent, context[i]);
                         return cursor;
                     }
                 }
             }
         }
-        NodeCursor.Retrun(parentCursor);
+        parentCursor.returnCursor();
+        cursor.returnCursor();
         return null;
     }
 }

package/Nodes/NodeCursor.d.ts

@@ -10,7 +10,7 @@ export interface NodeCursor {
 }
 export declare class NodeCursor {
     static Get(): NodeCursor;
-    static Retrun(cursor: NodeCursor): void;
+    static Return(cursor: NodeCursor): void;
     clear(events: boolean, context: boolean, observers: boolean, compoents: boolean, tags: boolean): void;
     get index(): number;
     get id(): bigint | null;

package/Nodes/NodeCursor.js

@@ -14,7 +14,7 @@ export class NodeCursor {
             return new NodeCursor();
         return cursor;
     }
-    static Retrun(cursor) {
+    static Return(cursor) {
         if (cursor.index !== -1) {
             cursor.clear(cursor.hasEvents, cursor.hasContexts, cursor.hasObservers, cursor.hasComponents, cursor.hasTags);
         }
@@ -175,7 +175,9 @@ export class NodeCursor {
         if (!array)
             return false;
         const templChildArray = NCSPools.numberArray.get() || [];
-        for (let i = 0; i < array.length; i++) {
+        const length = array.length;
+        templChildArray.length = length;
+        for (let i = 0; i < length; i++) {
             templChildArray[i] = array[i];
         }
         let usedTemp = false;
@@ -183,7 +185,7 @@ export class NodeCursor {
             usedTemp = true;
             cursor = NodeCursor.Get();
         }
-        for (let i = 0; i < templChildArray.length; i++) {
+        for (let i = 0; i < length; i++) {
             cursor.setNode(this.graph, templChildArray[i]);
             yield cursor;
         }
@@ -204,7 +206,7 @@ export class NodeCursor {
             cursor = NodeCursor.Get();
         }
         while (children.length) {
-            const childrenArray = children.shift();
+            const childrenArray = children.pop();
             if (!childrenArray)
                 continue;
             for (let i = 0; i < childrenArray.length; i++) {
@@ -251,7 +253,7 @@ export class NodeCursor {
             cursor = ComponentCursor.Get();
         }
         for (let i = 0; i < components.length; i += 2) {
-            yield cursor.setInstance(this, components[i], components[i + 1]);
+            yield cursor.setInstance(this.index, this.graph, components[i], components[i + 1]);
         }
         if (usedTemp)
             cursor.returnCursor();
@@ -277,6 +279,7 @@ export class NodeCursor {
     dispose() {
         if (this.isDisposed)
             return;
+        this.graph._nodes._beingDisposed[this._index] = true;
         this.hasObservers &&
             this.observers.isDisposedSet &&
             this.observers.disposed.notify(this);
@@ -289,11 +292,13 @@ export class NodeCursor {
         if (this.childrenArray) {
             const templChildArray = NCSPools.numberArray.get() || [];
             const children = this.childrenArray;
-            for (let i = 0; i < children.length; i++) {
+            const length = children.length;
+            templChildArray.length = length;
+            for (let i = 0; i < length; i++) {
                 templChildArray[i] = children[i];
             }
             const tempCursor = NodeCursor.Get();
-            for (let i = 0; i < templChildArray.length; i++) {
+            for (let i = 0; i < length; i++) {
                 tempCursor.setNode(this.graph, templChildArray[i]);
                 tempCursor.dispose();
             }
@@ -307,8 +312,13 @@ export class NodeCursor {
             tempCursor.removeChild(tempCursor.getChildIndex(this.index));
             tempCursor.returnCursor();
         }
+        const hadEvents = this.hasEvents;
+        const hadContexts = this.hasContexts;
+        const hadObservers = this.hasObservers;
+        const hadComponents = this.hasComponents;
+        const hadTags = this.hasTags;
         this.graph.removeNode(this.index);
-        this.clear(this.hasEvents, this.hasContexts, this.hasObservers, this.hasComponents, this.hasTags);
+        this.clear(hadEvents, hadContexts, hadObservers, hadComponents, hadTags);
     }
     hasChild(node) {
         if (!this.childrenArray)
@@ -333,7 +343,7 @@ export class NodeCursor {
         this.parent = nodeToParentTo.index;
         this.hasObservers &&
             this.observers.isParentedSet &&
-            nodeToParentTo.observers.parented.notify(tempCursor);
+            this.observers.parented.notify(tempCursor);
         tempCursor.returnCursor();
     }
     getChild(index, cursor = NodeCursor.Get()) {
@@ -371,9 +381,10 @@ export class NodeCursor {
         return this.childrenArray.length - 1;
     }
     removeChild(index) {
-        if (!this.childrenArray || !this.childrenArray[index])
+        if (!this.childrenArray || this.childrenArray[index] === undefined)
             return;
         const child = this.childrenArray.splice(index, 1)[0];
+        this.arrays._parents[child] = -1;
         const tempCursor = NodeCursor.Get();
         tempCursor.setNode(this.graph, child);
         if (this.hasObservers) {
@@ -400,7 +411,7 @@ export class NodeCursor {
         return id;
     }
     returnCursor() {
-        return NodeCursor.Retrun(this);
+        return NodeCursor.Return(this);
     }
     cloneCursor(cursor) {
         const newCursor = cursor || NodeCursor.Get();

package/Nodes/NodeTags.js

@@ -77,6 +77,8 @@ export class NodeTags {
     get(type, cursor = TagCursor.Get()) {
         const tagId = NCSRegister.tags.idPalette.getNumberId(type);
         const tags = this.tags;
+        if (!this.tags)
+            return null;
         for (let i = 0; i < tags.length; i += 2) {
             if (tags[i] == tagId) {
                 cursor.setTag(this.node, tags[i], tags[i + 1]);

package/Register/registerComponent.d.ts

@@ -4,7 +4,8 @@ import { SerializedNodeData, SerializedComponentData } from "../Data/SerializedD
 import { ComponentCursor } from "../Components/ComponentCursor";
 import { SchemaCursor } from "../Schema/Schema.types";
 import { NodeCursor } from "../Nodes/NodeCursor";
-import { Nullable } from "Util/Util.types";
+import { Nullable } from "../Util/Util.types";
+import { CreateNodeData } from "../Nodes/Node.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>>;
@@ -19,12 +20,21 @@ type RegisteredComponent<ComponentSchema extends object = any, Data extends any
     getAll(node: NodeCursor): ComponentCursor<ComponentSchema, Data, Shared>[] | null;
     remove(node: NodeCursor): boolean;
     removeAll(node: NodeCursor): boolean;
-    nodeData: {
+    serializedNodeData: {
         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;
+        set(node: CreateNodeData, schema: string, schemaViewId?: string | null): SerializedComponentData<ComponentSchema>[] | null;
+    };
+    nodeData: {
+        get(node: CreateNodeData): CreateComponentData<ComponentSchema> | null;
+        set(node: CreateNodeData, componentSchema?: Partial<ComponentSchema>): void;
+        getAll(node: CreateNodeData): CreateComponentData<ComponentSchema>[] | null;
+        remove(node: CreateNodeData): CreateComponentData<ComponentSchema> | null;
+        removeAll(node: CreateNodeData): CreateComponentData<ComponentSchema>[] | null;
+        set(node: CreateNodeData, schema: string, schemaViewId?: string, remote?: true | null): CreateComponentData<ComponentSchema>[] | null;
     };
     type: string;
     typeId: number;

package/Register/registerComponent.js

@@ -3,12 +3,15 @@ import { ComponentCursor } from "../Components/ComponentCursor";
 import { NodeCursor } from "../Nodes/NodeCursor";
 import { NCSPools } from "../Pools/NCSPools";
 export const registerComponent = (data) => {
+    if (NCSRegister.components.has(data.type)) {
+        console.error(`Component of type: ${data.type} is already registered`);
+    }
     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[1] = schema || null;
         createData[2] = schemaView || "default";
         return createData;
     };
@@ -32,43 +35,43 @@ export const registerComponent = (data) => {
                 return false;
             for (let i = 0; i < array._disposed.length; i++) {
                 nodeCursor.setNode(graph, array._node[i]);
-                cursor.setInstance(nodeCursor, typeId, i);
+                cursor.setInstance(nodeCursor.index, graph, typeId, i);
                 yield cursor;
             }
             return true;
         },
         set(node, schema, schemaView, cursor = ComponentCursor.Get()) {
             const newComponent = node.components.add(createComponent(schema, schemaView));
-            cursor.setInstance(node, typeId, newComponent);
+            cursor.setInstance(node.index, node.graph, typeId, newComponent);
             node.graph._components[typeId].init(newComponent);
             return cursor;
         },
         has(node) {
             return node.components.has(data.type);
         },
-        get(node, cursor, nodeCursor) {
-            return node.components.get(data.type, cursor, nodeCursor);
+        get(node, cursor) {
+            return node.components.get(data.type, cursor);
         },
-        getRequired(node, cursor, nodeCursor) {
-            const found = node.components.get(data.type, cursor, nodeCursor);
+        getRequired(node, cursor) {
+            const found = node.components.get(data.type, cursor);
             if (!found)
                 throw new Error(`NCS: Node [${node.name}] does not have required component [${data.type}].`);
             return found;
         },
         getChild(node, cursor, nodeCursor) {
-            return node.components.getChild(data.type, cursor, nodeCursor);
+            return node.components.getChild(data.type, cursor);
         },
         getRequiredChild(node, cursor, nodeCursor) {
-            const comp = node.components.getChild(data.type, cursor, nodeCursor);
+            const comp = node.components.getChild(data.type, cursor);
             if (!comp)
                 throw new Error(`NCS: Node [${node.name}] does not have a child with required component [${data.type}].`);
             return comp;
         },
         getParent(node, cursor, nodeCursor) {
-            return node.components.getParent(data.type, cursor, nodeCursor);
+            return node.components.getParent(data.type, cursor);
         },
         getRequiredParent(node, cursor, nodeCursor) {
-            const comp = node.components.getParent(data.type, cursor, nodeCursor);
+            const comp = node.components.getParent(data.type, cursor);
             if (!comp)
                 throw new Error(`NCS: Node [${node.name}] does not have a parent with required component [${data.type}].`);
             return comp;
@@ -82,7 +85,7 @@ export const registerComponent = (data) => {
         remove(node) {
             return node.components.remove(data.type);
         },
-        nodeData: {
+        serializedNodeData: {
             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,
@@ -91,13 +94,67 @@ export const registerComponent = (data) => {
                 node.components = node.components?.filter((_) => _.type != data.type);
                 return all?.length ? all : null;
             },
-            set: (node, schema) => {
+            set: (node, schema, schemaViewId = null) => {
                 node.components ??= [];
                 node.components.push({
                     type: data.type,
-                    schema: {},
+                    ...(schema ? { schema } : {}),
+                    ...(schemaViewId ? { schemaViewId: schemaViewId } : {}),
                 });
             },
         },
+        nodeData: {
+            get: (node) => {
+                if (!node[2])
+                    return null;
+                for (const comp of node[2]) {
+                    if (!comp)
+                        continue;
+                    if (comp[0] == data.type)
+                        return comp;
+                }
+                return null;
+            },
+            getAll: (node) => {
+                const comps = [];
+                if (!node[2])
+                    return comps;
+                for (const comp of node[2]) {
+                    if (!comp)
+                        continue;
+                    if (comp[0] == data.type) {
+                        comps.push(comp);
+                    }
+                }
+                return comps;
+            },
+            remove: (node) => {
+                if (!node[2])
+                    return null;
+                for (let i = 0; i < node[2].length; i++) {
+                    const comp = node[2][i];
+                    if (!comp)
+                        continue;
+                    return node[2].splice(i, 1)[0];
+                }
+                return null;
+            },
+            removeAll(node) {
+                if (!node[2])
+                    return null;
+                for (let i = node[2].length - 1; i >= 0; i--) {
+                    const comp = node[2][i];
+                    if (!comp)
+                        continue;
+                    if (comp[0] == data.type) {
+                        node[2].splice(i, 1)[0];
+                    }
+                }
+                return null;
+            },
+            set: (node, schema, schemaViewId = "default", remote = null) => {
+                node[2]?.push([data.type, schema, schemaViewId, remote]);
+            },
+        },
     });
 };

package/Schema/Functions/createSchemaBinaryObjectCursorClass.js

@@ -75,7 +75,7 @@ function traverse(parent, properties) {
                     if (this.__cursor.hasProxy(index)) {
                         return this.__cursor.fetchProxyData(index);
                     }
-                    return getBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index]);
+                    return getBinaryObjectData(this.__cursor._cachedData, this.__view.meta[index], this.__view.byteOffset[index]);
                 },
                 set(value) {
                     let obs = this.__cursor.getObserver(index);
@@ -83,9 +83,9 @@ function traverse(parent, properties) {
                     if (obs) {
                         const oldVale = proxy
                             ? this.__cursor.fetchProxyData(index)
-                            : getBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index]);
+                            : getBinaryObjectData(this.__cursor._cachedData, this.__view.meta[index], this.__view.byteOffset[index]);
                         if (oldVale != value) {
-                            setBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index], value);
+                            setBinaryObjectData(this.__cursor._cachedData, this.__view.meta[index], this.__view.byteOffset[index], value);
                             if (proxy) {
                                 this.__cursor.setProxyData(index, value);
                             }
@@ -93,7 +93,7 @@ function traverse(parent, properties) {
                             return;
                         }
                     }
-                    setBinaryObjectData(this.__cursor.data, this.__view.meta[index], this.__view.byteOffset[index], value);
+                    setBinaryObjectData(this.__cursor._cachedData, this.__view.meta[index], this.__view.byteOffset[index], value);
                     if (proxy) {
                         this.__cursor.setProxyData(index, value);
                     }

package/Schema/Functions/createSchemaObjectCursorClass.js

@@ -9,7 +9,7 @@ function traverse(parent, properties) {
                     if (this.__cursor.hasProxy(index)) {
                         return this.__cursor.fetchProxyData(index);
                     }
-                    return this.__cursor.data[index];
+                    return this.__cursor._cachedData[index];
                 },
                 set(value) {
                     let obs = this.__cursor.getObserver(index);
@@ -17,9 +17,9 @@ function traverse(parent, properties) {
                     if (obs) {
                         const oldVale = proxy
                             ? this.__cursor.fetchProxyData(index)
-                            : this.__cursor.data[index];
+                            : this.__cursor._cachedData[index];
                         if (oldVale != value) {
-                            this.__cursor.data[index] = value;
+                            this.__cursor._cachedData[index] = value;
                             if (proxy) {
                                 this.__cursor.setProxyData(index, value);
                             }
@@ -27,7 +27,7 @@ function traverse(parent, properties) {
                             return;
                         }
                     }
-                    this.__cursor.data[index] = value;
+                    this.__cursor._cachedData[index] = value;
                     if (proxy) {
                         this.__cursor.setProxyData(index, value);
                     }

package/Schema/Functions/createSchemaTypedArrayCursorClass.js

@@ -9,7 +9,7 @@ function traverse(parent, properties) {
                     if (this.__cursor.hasProxy(index)) {
                         return this.__cursor.fetchProxyData(index);
                     }
-                    return this.__cursor.data[index];
+                    return this.__cursor._cachedData[index];
                 },
                 set(value) {
                     let obs = this.__cursor.getObserver(index);
@@ -17,9 +17,9 @@ function traverse(parent, properties) {
                     if (obs) {
                         const oldVale = proxy
                             ? this.__cursor.fetchProxyData(index)
-                            : this.__cursor.data[index];
+                            : this.__cursor._cachedData[index];
                         if (oldVale != value) {
-                            this.__cursor.data[index] = value;
+                            this.__cursor._cachedData[index] = value;
                             if (proxy) {
                                 this.__cursor.setProxyData(index, value);
                             }
@@ -27,7 +27,7 @@ function traverse(parent, properties) {
                             return;
                         }
                     }
-                    this.__cursor.data[index] = value;
+                    this.__cursor._cachedData[index] = value;
                     if (proxy) {
                         this.__cursor.setProxyData(index, value);
                     }

package/Schema/Schema.js

@@ -12,12 +12,13 @@ const traverseCreate = (parent, properties, index) => {
     for (let i = 0; i < properties.length; i++) {
         const data = properties[i];
         if (typeof data.value == "object" &&
+            data.value !== null &&
             !data.children?.length &&
             !Array.isArray(data.value)) {
             data.children ??= [];
             for (const key in data.value) {
                 const value = data.value[key];
-                const meta = structuredClone(data.meta || {});
+                const meta = data.meta || {};
                 meta.child = true;
                 data.children.push({
                     id: key,
@@ -62,8 +63,8 @@ const traverseArray = (parent, data, meta) => {
     for (let i = 0; i < parent.children.length; i++) {
         const property = parent.children[i];
         if (!property.children) {
-            data[Number(property.index)] = structuredClone(property.value);
-            property.meta && (meta[property.index] = structuredClone(property.meta));
+            data[Number(property.index)] = property.value;
+            property.meta && (meta[property.index] = property.meta);
         }
         else {
             traverseArray(property, data, meta);
@@ -83,7 +84,7 @@ function buildMeta(data, meta, metaOverrides) {
 function traverseCreateFromObject(object, property) {
     for (const id in object) {
         const value = object[id];
-        if (typeof value == "object") {
+        if (typeof value == "object" && value !== null) {
             property.children.push(traverseCreateFromObject(value, {
                 id,
                 value: {},
@@ -161,10 +162,7 @@ export class Schema {
     }
     createData(newData = [], overrides) {
         for (let i = 0; i < this._data.length; i++) {
-            newData[i] =
-                typeof this._data[i] == "object"
-                    ? structuredClone(this._data[i])
-                    : this._data[i];
+            newData[i] = this._data[i];
         }
         traverseCreateData(this.root, newData, overrides);
         return newData;

package/Schema/SchemaArrayCursor.d.ts

@@ -3,8 +3,7 @@ import { SchemaArray } from "./SchemaArray";
 export declare class SchemaArrayCursor {
     schemaArray: SchemaArray;
     constructor(schemaArray: SchemaArray);
-    get data(): any;
-    set data(value: any);
+    _cachedData: any | null;
     _index: number;
     setIndex(index: number): void;
     getObserver(propertyIndex: number): Observable<any> | null;

package/Schema/SchemaArrayCursor.js

@@ -5,15 +5,11 @@ export class SchemaArrayCursor {
     constructor(schemaArray) {
         this.schemaArray = schemaArray;
     }
-    get data() {
-        return this.schemaArray._data[this._index];
-    }
-    set data(value) {
-        this.schemaArray._data[this._index] = value;
-    }
+    _cachedData = null;
     _index = 0;
     setIndex(index) {
         this._index = index;
+        this._cachedData = this.schemaArray._data[index] ?? null;
     }
     getObserver(propertyIndex) {
         return this.schemaArray.getObserver(propertyIndex, this._index);

package/Schema/SchemaView.d.ts

@@ -12,8 +12,11 @@ export declare class SchemaView<Shape extends {} = any> {
     _createData: SchemaCreateData;
     private _cursorClass;
     _dataPool: ItemPool<unknown>;
+    _cursorPool: ItemPool<SchemaCursor<Shape>>;
+    private _tempData;
     constructor(schema: Schema<Shape>, id: string, meta: PropertyMetaData[], byteOffset: number[], byteSize: number, _createData: SchemaCreateData, _cursorClass: any);
     returnData(returnData: any): void;
+    returnCursor(cursor: SchemaCursor): void;
     createData(overrides?: RecursivePartial<Shape> | null): any;
     createCursor(): SchemaCursor<Shape>;
     /** Converts data for use of remote components */