@buerli.io/core 1.1.0-beta.8 → 1.2.0

package/build/cjs/store/states/immutablePatch.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * applyPatchImmutable — RFC 6902 (JSON Patch) applied with structural sharing.
+ *
+ * Never mutates the input document. Copies exactly the containers on the path
+ * of each operation (copy-on-write); untouched siblings keep their identity,
+ * so store subscribers with reference-equality selectors only wake where
+ * something actually changed.
+ *
+ * The speed trick: a per-batch `cloned` set tracks containers that are already
+ * fresh copies owned by this batch — those are mutated in place. A batch of
+ * N ops therefore costs one shallow copy per DISTINCT touched container (plus
+ * the walk), not one copy chain per op. No full deep clone, ever.
+ *
+ * This replaces the previous two-library setup (jsonpatch for small blocks,
+ * fast-json-patch with a full deep clone for blocks > 100 ops): it is faster
+ * than either in its own domain AND keeps identities correct, so the 100-op
+ * threshold and its discontinuous identity behavior are gone.
+ *
+ * Supported ops: add, remove, replace, move, copy, test (the full RFC set;
+ * the engine's json::diff emits only add/remove/replace). Throws on invalid
+ * paths/ops — the caller decides how to recover, exactly like the previous
+ * jsonpatch behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPatchImmutable = void 0;
+/** '/a/b~1c/0' → ['a', 'b/c', '0'] with RFC 6901 unescaping (~1 → '/', ~0 → '~'). */
+const parsePointer = (path) => {
+    if (path === '')
+        return [];
+    if (path[0] !== '/')
+        throw new Error(`invalid JSON pointer: ${path}`);
+    return path
+        .slice(1)
+        .split('/')
+        .map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+};
+const toIndex = (seg, arr, allowEnd) => {
+    const idx = seg === '-' ? arr.length : Number(seg);
+    if (!Number.isInteger(idx) || idx < 0 || idx > arr.length - (allowEnd ? 0 : 1)) {
+        throw new Error(`array index out of bounds: ${seg}`);
+    }
+    return idx;
+};
+const deepEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const ka = Object.keys(a);
+    if (ka.length !== Object.keys(b).length)
+        return false;
+    return ka.every(k => deepEqual(a[k], b[k]));
+};
+const getAtPath = (doc, segs) => {
+    let cur = doc;
+    for (const seg of segs) {
+        if (cur === null || typeof cur !== 'object')
+            throw new Error('path not found');
+        cur = Array.isArray(cur) ? cur[toIndex(seg, cur, false)] : cur[seg];
+        if (cur === undefined)
+            throw new Error('path not found');
+    }
+    return cur;
+};
+/** Portable deep clone for the rare `copy` op (structuredClone needs node >= 17). */
+const deepClone = (v) => typeof structuredClone === 'function' ? structuredClone(v) : JSON.parse(JSON.stringify(v));
+function applyPatchImmutable(doc, ops) {
+    // Containers created by THIS batch — safe to mutate in place. Keyed by the
+    // copies themselves, so shared history from the input doc is never touched.
+    const cloned = new Set();
+    /** Return a batch-owned version of `container` (copying it if needed). */
+    const own = (container) => {
+        if (cloned.has(container))
+            return container;
+        const copy = (Array.isArray(container) ? container.slice() : Object.assign({}, container));
+        cloned.add(copy);
+        return copy;
+    };
+    let root = doc;
+    const applyOne = (op) => {
+        var _a, _b, _c;
+        const segs = parsePointer(op.path);
+        // Whole-document operations.
+        if (segs.length === 0) {
+            switch (op.op) {
+                case 'replace':
+                case 'add':
+                    root = op.value;
+                    return;
+                case 'test':
+                    if (!deepEqual(root, op.value))
+                        throw new Error('test failed at root');
+                    return;
+                default:
+                    throw new Error(`op "${op.op}" not allowed on document root`);
+            }
+        }
+        // move/copy decompose into get + remove/add. Reusing the moved reference
+        // is safe (it ends up at exactly one location); copy inserts a detached
+        // clone so a later op on one copy can never alias into the other.
+        if (op.op === 'move') {
+            const value = getAtPath(root, parsePointer((_a = op.from) !== null && _a !== void 0 ? _a : ''));
+            applyOne({ op: 'remove', path: (_b = op.from) !== null && _b !== void 0 ? _b : '' });
+            applyOne({ op: 'add', path: op.path, value });
+            return;
+        }
+        if (op.op === 'copy') {
+            applyOne({ op: 'add', path: op.path, value: deepClone(getAtPath(root, parsePointer((_c = op.from) !== null && _c !== void 0 ? _c : ''))) });
+            return;
+        }
+        // Copy-on-write walk: own every container from the root down to the
+        // operation's parent, re-linking each owned copy into its (owned) parent.
+        root = own(root);
+        let parent = root;
+        for (let i = 0; i < segs.length - 1; i++) {
+            const key = Array.isArray(parent) ? toIndex(segs[i], parent, false) : segs[i];
+            const child = parent[key];
+            if (child === null || typeof child !== 'object')
+                throw new Error(`path not found: ${op.path}`);
+            const owned = own(child);
+            if (owned !== child)
+                parent[key] = owned; // parent is owned → safe
+            parent = owned;
+        }
+        const last = segs[segs.length - 1];
+        switch (op.op) {
+            case 'replace':
+                if (Array.isArray(parent))
+                    parent[toIndex(last, parent, false)] = op.value;
+                else if (last in parent)
+                    parent[last] = op.value;
+                else
+                    throw new Error(`replace target missing: ${op.path}`);
+                return;
+            case 'add':
+                if (Array.isArray(parent))
+                    parent.splice(toIndex(last, parent, true), 0, op.value);
+                else
+                    parent[last] = op.value;
+                return;
+            case 'remove':
+                if (Array.isArray(parent))
+                    parent.splice(toIndex(last, parent, false), 1);
+                else if (last in parent)
+                    delete parent[last];
+                else
+                    throw new Error(`remove target missing: ${op.path}`);
+                return;
+            case 'test': {
+                const actual = Array.isArray(parent) ? parent[toIndex(last, parent, false)] : parent[last];
+                if (!deepEqual(actual, op.value))
+                    throw new Error(`test failed: ${op.path}`);
+                return;
+            }
+            default:
+                throw new Error(`unknown op: ${op.op}`);
+        }
+    };
+    for (const op of ops)
+        applyOne(op);
+    return root;
+}
+exports.applyPatchImmutable = applyPatchImmutable;

package/build/cjs/store/states/structure.js

@@ -22,16 +22,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.structureApi = exports.structureData = void 0;
-const fast_json_patch_1 = __importDefault(require("fast-json-patch"));
-const jsonpatch_1 = __importDefault(require("jsonpatch"));
 const THREE = __importStar(require("three"));
 const types_1 = require("../../types");
 const Math_1 = require("../../utils/Math");
+const immutablePatch_1 = require("./immutablePatch");
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
@@ -58,28 +54,33 @@ const structureApi = (set, get, buerliApi) => ({
         // console.log('cleanup')
         api.structure.postProcessStructureUpdate();
     },
+    /**
+     * Applies structure patches to the tree. Returns `false` when a patch block
+     * failed to apply — the tree is then diverged from the server's baseline and
+     * stays diverged (patches are relative), so the caller should recover by
+     * re-fetching the full tree.
+     */
     applyPatches: (patches) => {
         const before = get().structure.products.concat(get().structure.visibleContainers);
+        let ok = true;
         const applyBlock = (block) => {
             if (block.length === 0)
                 return;
             set(state => {
                 let structure = state.structure;
                 try {
-                    // TODO: keep an eye on the patch behaviour in general.
-                    // For large changes 'fast-json-patch' is much more performant than 'jsonpatch'.
-                    // However, for smaller changes 'jsonpatch' is more performant than 'fast-json-patch'.
-                    if (block.length > 100) {
-                        structure = fast_json_patch_1.default.applyPatch(state.structure, block, false, false).newDocument;
-                    }
-                    else {
-                        structure = jsonpatch_1.default.apply_patch(state.structure, block);
-                    }
+                    // Structural-sharing patch application: only containers on a patched
+                    // path get new identities, untouched subtrees stay reference-equal —
+                    // so identity-sensitive subscribers/effects only react to genuine
+                    // changes. Replaces the former jsonpatch/fast-json-patch split (the
+                    // > 100 ops fast-json-patch path deep-cloned the WHOLE document and
+                    // gave every node a new identity on every large block).
+                    structure = (0, immutablePatch_1.applyPatchImmutable)(state.structure, block);
                 }
                 catch (e) {
+                    ok = false;
                     console.error(e);
                 }
-                // console.info('currentProduct in new patched structure: ', structure.currentProduct)
                 return { structure: Object.assign(Object.assign({}, state.structure), structure) };
             });
         };
@@ -111,6 +112,7 @@ const structureApi = (set, get, buerliApi) => ({
         if (before.sort().join() !== after.sort().join()) {
             api.geometry.updateBounds();
         }
+        return ok;
     },
     filterTree: (tree, filter) => {
         const objs = [];

package/build/esm/store/states/immutablePatch.js

@@ -0,0 +1,162 @@
+/**
+ * applyPatchImmutable — RFC 6902 (JSON Patch) applied with structural sharing.
+ *
+ * Never mutates the input document. Copies exactly the containers on the path
+ * of each operation (copy-on-write); untouched siblings keep their identity,
+ * so store subscribers with reference-equality selectors only wake where
+ * something actually changed.
+ *
+ * The speed trick: a per-batch `cloned` set tracks containers that are already
+ * fresh copies owned by this batch — those are mutated in place. A batch of
+ * N ops therefore costs one shallow copy per DISTINCT touched container (plus
+ * the walk), not one copy chain per op. No full deep clone, ever.
+ *
+ * This replaces the previous two-library setup (jsonpatch for small blocks,
+ * fast-json-patch with a full deep clone for blocks > 100 ops): it is faster
+ * than either in its own domain AND keeps identities correct, so the 100-op
+ * threshold and its discontinuous identity behavior are gone.
+ *
+ * Supported ops: add, remove, replace, move, copy, test (the full RFC set;
+ * the engine's json::diff emits only add/remove/replace). Throws on invalid
+ * paths/ops — the caller decides how to recover, exactly like the previous
+ * jsonpatch behavior.
+ */
+/** '/a/b~1c/0' → ['a', 'b/c', '0'] with RFC 6901 unescaping (~1 → '/', ~0 → '~'). */
+const parsePointer = (path) => {
+    if (path === '')
+        return [];
+    if (path[0] !== '/')
+        throw new Error(`invalid JSON pointer: ${path}`);
+    return path
+        .slice(1)
+        .split('/')
+        .map(s => s.replace(/~1/g, '/').replace(/~0/g, '~'));
+};
+const toIndex = (seg, arr, allowEnd) => {
+    const idx = seg === '-' ? arr.length : Number(seg);
+    if (!Number.isInteger(idx) || idx < 0 || idx > arr.length - (allowEnd ? 0 : 1)) {
+        throw new Error(`array index out of bounds: ${seg}`);
+    }
+    return idx;
+};
+const deepEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const ka = Object.keys(a);
+    if (ka.length !== Object.keys(b).length)
+        return false;
+    return ka.every(k => deepEqual(a[k], b[k]));
+};
+const getAtPath = (doc, segs) => {
+    let cur = doc;
+    for (const seg of segs) {
+        if (cur === null || typeof cur !== 'object')
+            throw new Error('path not found');
+        cur = Array.isArray(cur) ? cur[toIndex(seg, cur, false)] : cur[seg];
+        if (cur === undefined)
+            throw new Error('path not found');
+    }
+    return cur;
+};
+/** Portable deep clone for the rare `copy` op (structuredClone needs node >= 17). */
+const deepClone = (v) => typeof structuredClone === 'function' ? structuredClone(v) : JSON.parse(JSON.stringify(v));
+export function applyPatchImmutable(doc, ops) {
+    // Containers created by THIS batch — safe to mutate in place. Keyed by the
+    // copies themselves, so shared history from the input doc is never touched.
+    const cloned = new Set();
+    /** Return a batch-owned version of `container` (copying it if needed). */
+    const own = (container) => {
+        if (cloned.has(container))
+            return container;
+        const copy = (Array.isArray(container) ? container.slice() : Object.assign({}, container));
+        cloned.add(copy);
+        return copy;
+    };
+    let root = doc;
+    const applyOne = (op) => {
+        var _a, _b, _c;
+        const segs = parsePointer(op.path);
+        // Whole-document operations.
+        if (segs.length === 0) {
+            switch (op.op) {
+                case 'replace':
+                case 'add':
+                    root = op.value;
+                    return;
+                case 'test':
+                    if (!deepEqual(root, op.value))
+                        throw new Error('test failed at root');
+                    return;
+                default:
+                    throw new Error(`op "${op.op}" not allowed on document root`);
+            }
+        }
+        // move/copy decompose into get + remove/add. Reusing the moved reference
+        // is safe (it ends up at exactly one location); copy inserts a detached
+        // clone so a later op on one copy can never alias into the other.
+        if (op.op === 'move') {
+            const value = getAtPath(root, parsePointer((_a = op.from) !== null && _a !== void 0 ? _a : ''));
+            applyOne({ op: 'remove', path: (_b = op.from) !== null && _b !== void 0 ? _b : '' });
+            applyOne({ op: 'add', path: op.path, value });
+            return;
+        }
+        if (op.op === 'copy') {
+            applyOne({ op: 'add', path: op.path, value: deepClone(getAtPath(root, parsePointer((_c = op.from) !== null && _c !== void 0 ? _c : ''))) });
+            return;
+        }
+        // Copy-on-write walk: own every container from the root down to the
+        // operation's parent, re-linking each owned copy into its (owned) parent.
+        root = own(root);
+        let parent = root;
+        for (let i = 0; i < segs.length - 1; i++) {
+            const key = Array.isArray(parent) ? toIndex(segs[i], parent, false) : segs[i];
+            const child = parent[key];
+            if (child === null || typeof child !== 'object')
+                throw new Error(`path not found: ${op.path}`);
+            const owned = own(child);
+            if (owned !== child)
+                parent[key] = owned; // parent is owned → safe
+            parent = owned;
+        }
+        const last = segs[segs.length - 1];
+        switch (op.op) {
+            case 'replace':
+                if (Array.isArray(parent))
+                    parent[toIndex(last, parent, false)] = op.value;
+                else if (last in parent)
+                    parent[last] = op.value;
+                else
+                    throw new Error(`replace target missing: ${op.path}`);
+                return;
+            case 'add':
+                if (Array.isArray(parent))
+                    parent.splice(toIndex(last, parent, true), 0, op.value);
+                else
+                    parent[last] = op.value;
+                return;
+            case 'remove':
+                if (Array.isArray(parent))
+                    parent.splice(toIndex(last, parent, false), 1);
+                else if (last in parent)
+                    delete parent[last];
+                else
+                    throw new Error(`remove target missing: ${op.path}`);
+                return;
+            case 'test': {
+                const actual = Array.isArray(parent) ? parent[toIndex(last, parent, false)] : parent[last];
+                if (!deepEqual(actual, op.value))
+                    throw new Error(`test failed: ${op.path}`);
+                return;
+            }
+            default:
+                throw new Error(`unknown op: ${op.op}`);
+        }
+    };
+    for (const op of ops)
+        applyOne(op);
+    return root;
+}

package/build/esm/store/states/structure.js

@@ -1,8 +1,7 @@
-import fastpatch from 'fast-json-patch';
-import jsonpatch from 'jsonpatch';
 import * as THREE from 'three';
 import { DEFAULT_STRUCTURE_TREE } from '../../types';
 import { MathUtils } from '../../utils/Math';
+import { applyPatchImmutable } from './immutablePatch';
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
@@ -28,28 +27,33 @@ export const structureApi = (set, get, buerliApi) => ({
         // console.log('cleanup')
         api.structure.postProcessStructureUpdate();
     },
+    /**
+     * Applies structure patches to the tree. Returns `false` when a patch block
+     * failed to apply — the tree is then diverged from the server's baseline and
+     * stays diverged (patches are relative), so the caller should recover by
+     * re-fetching the full tree.
+     */
     applyPatches: (patches) => {
         const before = get().structure.products.concat(get().structure.visibleContainers);
+        let ok = true;
         const applyBlock = (block) => {
             if (block.length === 0)
                 return;
             set(state => {
                 let structure = state.structure;
                 try {
-                    // TODO: keep an eye on the patch behaviour in general.
-                    // For large changes 'fast-json-patch' is much more performant than 'jsonpatch'.
-                    // However, for smaller changes 'jsonpatch' is more performant than 'fast-json-patch'.
-                    if (block.length > 100) {
-                        structure = fastpatch.applyPatch(state.structure, block, false, false).newDocument;
-                    }
-                    else {
-                        structure = jsonpatch.apply_patch(state.structure, block);
-                    }
+                    // Structural-sharing patch application: only containers on a patched
+                    // path get new identities, untouched subtrees stay reference-equal —
+                    // so identity-sensitive subscribers/effects only react to genuine
+                    // changes. Replaces the former jsonpatch/fast-json-patch split (the
+                    // > 100 ops fast-json-patch path deep-cloned the WHOLE document and
+                    // gave every node a new identity on every large block).
+                    structure = applyPatchImmutable(state.structure, block);
                 }
                 catch (e) {
+                    ok = false;
                     console.error(e);
                 }
-                // console.info('currentProduct in new patched structure: ', structure.currentProduct)
                 return { structure: Object.assign(Object.assign({}, state.structure), structure) };
             });
         };
@@ -81,6 +85,7 @@ export const structureApi = (set, get, buerliApi) => ({
         if (before.sort().join() !== after.sort().join()) {
             api.geometry.updateBounds();
         }
+        return ok;
     },
     filterTree: (tree, filter) => {
         const objs = [];

package/build/types/store/states/immutablePatch.d.ts

@@ -0,0 +1,30 @@
+/**
+ * applyPatchImmutable — RFC 6902 (JSON Patch) applied with structural sharing.
+ *
+ * Never mutates the input document. Copies exactly the containers on the path
+ * of each operation (copy-on-write); untouched siblings keep their identity,
+ * so store subscribers with reference-equality selectors only wake where
+ * something actually changed.
+ *
+ * The speed trick: a per-batch `cloned` set tracks containers that are already
+ * fresh copies owned by this batch — those are mutated in place. A batch of
+ * N ops therefore costs one shallow copy per DISTINCT touched container (plus
+ * the walk), not one copy chain per op. No full deep clone, ever.
+ *
+ * This replaces the previous two-library setup (jsonpatch for small blocks,
+ * fast-json-patch with a full deep clone for blocks > 100 ops): it is faster
+ * than either in its own domain AND keeps identities correct, so the 100-op
+ * threshold and its discontinuous identity behavior are gone.
+ *
+ * Supported ops: add, remove, replace, move, copy, test (the full RFC set;
+ * the engine's json::diff emits only add/remove/replace). Throws on invalid
+ * paths/ops — the caller decides how to recover, exactly like the previous
+ * jsonpatch behavior.
+ */
+export declare type JsonPatchOp = {
+    op: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
+    path: string;
+    value?: unknown;
+    from?: string;
+};
+export declare function applyPatchImmutable<T>(doc: T, ops: JsonPatchOp[]): T;

package/build/types/store/states/structure.d.ts

@@ -12,7 +12,13 @@ export declare const structureData: () => StructureData;
 export declare const structureApi: (set: StoreApi<DrawingState>['setState'], get: StoreApi<DrawingState>['getState'], buerliApi: StoreApi<BuerliState>) => {
     get: () => StructureData;
     set: (structure: IStructureProtocol) => void;
-    applyPatches: (patches: IStructurePatch[]) => void;
+    /**
+     * Applies structure patches to the tree. Returns `false` when a patch block
+     * failed to apply — the tree is then diverged from the server's baseline and
+     * stays diverged (patches are relative), so the caller should recover by
+     * re-fetching the full tree.
+     */
+    applyPatches: (patches: IStructurePatch[]) => boolean;
     filterTree: (tree: IStructureTree, filter: (obj: IStructureObject) => boolean) => IStructureObject[];
     findTree: (tree: IStructureTree, filter: (obj: IStructureObject) => boolean) => IStructureObject | undefined;
     collectUsedSolidIds: () => ObjectID[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/core",
-  "version": "1.1.0-beta.8",
+  "version": "1.2.0",
   "description": "buerli state management",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "license": "ISC",
@@ -29,13 +29,11 @@
     "babel-plugin-transform-class-properties": "^6.24.1",
     "jest": "^26.1.0",
     "rimraf": "^2.6.3",
-    "three": "^0.165",
+    "three": "^0.153",
     "typescript": "4.8.4"
   },
   "dependencies": {
     "@classcad/api-js": "https://awvstatic.com/classcad/download/release/21.2.0/js/classcad-api-js-21.2.0.tgz",
-    "fast-json-patch": "^3.1.1",
-    "jsonpatch": "^3.1.0",
     "uuid": "^9.0.0",
     "zustand": "^4.1.4"
   },