@buerli.io/core 1.1.0 → 2.0.0-beta.20261016085358

package/build/cjs/geometry/ThreeGeometryCreator.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEqualGeometry = exports.EMPTY_CONTAINER_GEOMETRY = exports.ThreeGeometryCreator = void 0;
 const THREE = __importStar(require("three"));

package/build/cjs/store/index.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.closeMessage = exports.updateMessage = exports.showMessage = exports.init = exports.getPlugin = exports.getDrawing = exports.api = exports.createGraphicItem = exports.BuerliScope = exports.BuerliMessageScope = void 0;
+exports.api = exports.createGraphicItem = exports.BuerliScope = exports.BuerliMessageScope = void 0;
+exports.getDrawing = getDrawing;
+exports.getPlugin = getPlugin;
+exports.init = init;
+exports.showMessage = showMessage;
+exports.updateMessage = updateMessage;
+exports.closeMessage = closeMessage;
 const store_1 = require("./store");
 function getDrawing(id) {
     const { drawing } = store_1.api.getState();
     return drawing.refs[id];
 }
-exports.getDrawing = getDrawing;
 /**
  * @returns PluginState or undefined if either drawing or plugin don't exist
  */
@@ -15,23 +20,18 @@ function getPlugin(drawingId, pluginId) {
     const { drawing } = store_1.api.getState();
     return (_a = drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.plugin.refs[pluginId];
 }
-exports.getPlugin = getPlugin;
 function init(options) {
     store_1.api.getState().api.init(options);
 }
-exports.init = init;
 function showMessage(message) {
     return store_1.api.getState().message.api.show(message);
 }
-exports.showMessage = showMessage;
 function updateMessage(id, message) {
     store_1.api.getState().message.api.update(id, message);
 }
-exports.updateMessage = updateMessage;
 function closeMessage(id) {
     store_1.api.getState().message.api.close(id);
 }
-exports.closeMessage = closeMessage;
 var message_1 = require("./states/message");
 Object.defineProperty(exports, "BuerliMessageScope", { enumerable: true, get: function () { return message_1.BuerliMessageScope; } });
 var selection_1 = require("./states/selection");

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

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.geometryApi = exports.geometryData = void 0;
 const THREE = __importStar(require("three"));

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

@@ -0,0 +1,165 @@
+"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 = applyPatchImmutable;
+/** '/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;
+}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromisePlugin = exports.pluginApi = exports.pluginData = void 0;
+exports.pluginApi = exports.pluginData = void 0;
+exports.isPromisePlugin = isPromisePlugin;
 const uuid_1 = require("uuid");
 const pluginData = () => ({
     feature: [],
@@ -112,4 +113,3 @@ exports.pluginApi = pluginApi;
 function isPromisePlugin(def) {
     return def.then !== undefined;
 }
-exports.isPromisePlugin = isPromisePlugin;

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

@@ -15,23 +15,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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 +64,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 +122,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/cjs/store/store.js

@@ -1,9 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.api = void 0;
-const vanilla_1 = __importDefault(require("zustand/vanilla"));
+const vanilla_1 = require("zustand/vanilla");
 const buerli_1 = require("./states/buerli");
-exports.api = (0, vanilla_1.default)()(buerli_1.createState);
+exports.api = (0, vanilla_1.createStore)()(buerli_1.createState);

package/build/cjs/store/subscribtion/selection.js

@@ -1,7 +1,9 @@
 "use strict";
 // This is the solution for cases when object was deleted from tree and we need to remove corresponding selectedItem.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unsubscribeItems = exports.subscribeItems = exports.unsubs = void 0;
+exports.unsubs = void 0;
+exports.subscribeItems = subscribeItems;
+exports.unsubscribeItems = unsubscribeItems;
 const subscribeToDrawing_1 = require("./subscribeToDrawing");
 // This object contains unsubscibe function for all existing selections in all drawings
 exports.unsubs = {};
@@ -14,7 +16,6 @@ function subscribeItems(buerliApi, drawingId, selectorId, items) {
         subscribeItem(buerliApi, drawingId, selectorId, item);
     });
 }
-exports.subscribeItems = subscribeItems;
 function subscribeItem(buerliApi, drawingId, selectorId, item) {
     if (item.removeCondition && !exports.unsubs[getId(selectorId, item.id)]) {
         const selApi = buerliApi.getState().drawing.refs[drawingId].api.selection;
@@ -37,7 +38,6 @@ function unsubscribeItems(buerliApi, drawingId, selectorId, items) {
         unsubscribeItem(selectorId, item);
     });
 }
-exports.unsubscribeItems = unsubscribeItems;
 function unsubscribeItem(selectorId, item) {
     if (item.removeCondition) {
         const id = getId(selectorId, item.id);

package/build/cjs/store/subscribtion/subscribeToDrawing.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribeToDrawing = void 0;
+exports.subscribeToDrawing = subscribeToDrawing;
 function subscribeToDrawing(buerliApi, drawingId, sel, callback) {
     const unsub = buerliApi.subscribe((state, prev) => {
         const curDrawing = state.drawing.refs[drawingId] && sel(state.drawing.refs[drawingId]);
@@ -10,4 +10,3 @@ function subscribeToDrawing(buerliApi, drawingId, sel, callback) {
     });
     return unsub;
 }
-exports.subscribeToDrawing = subscribeToDrawing;

package/build/cjs/utils/Math.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MathUtils = void 0;
 const THREE = __importStar(require("three"));

package/build/cjs/utils/Measure.js

@@ -15,16 +15,25 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Measure = exports.MeasureResultType = void 0;
-/* eslint-disable max-lines */
 const THREE = __importStar(require("three"));
 const re_export_1 = require("../re-export");
 const store_1 = require("./../store");
@@ -36,7 +45,7 @@ var MeasureResultType;
     MeasureResultType["ANGLE"] = "angular";
     MeasureResultType["VECTOR"] = "vector";
     MeasureResultType["POSITION"] = "position";
-})(MeasureResultType = exports.MeasureResultType || (exports.MeasureResultType = {}));
+})(MeasureResultType || (exports.MeasureResultType = MeasureResultType = {}));
 const tolerance = 1e-3;
 exports.Measure = {
     transform(items, drawingId) {