@buerli.io/core 1.0.0 → 1.0.1-beta.2

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

@@ -1,250 +1,250 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : 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 };
-};
-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");
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-const structureData = () => {
-    return Object.assign(Object.assign({}, (0, types_1.DEFAULT_STRUCTURE_TREE)()), { visibleContainers: [], products: [] });
-};
-exports.structureData = structureData;
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-const structureApi = (set, get, buerliApi) => ({
-    get: () => {
-        return get().structure;
-    },
-    set: (structure) => {
-        const { api } = get();
-        // TODO: clear object selection if needed
-        // 1. set the state
-        set({
-            structure: Object.assign(Object.assign({}, get().structure), structure),
-        });
-        // 2. collect and cleanup data
-        api.graphic.cleanupGraphicRecords();
-        // console.log('cleanup')
-        api.structure.postProcessStructureUpdate();
-    },
-    applyPatches: (patches) => {
-        const before = get().structure.products.concat(get().structure.visibleContainers);
-        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);
-                    }
-                }
-                catch (e) {
-                    console.error(e);
-                }
-                // console.info('currentProduct in new patched structure: ', structure.currentProduct)
-                return { structure: Object.assign(Object.assign({}, state.structure), structure) };
-            });
-        };
-        const treePatches = [];
-        const otherPatches = [];
-        for (const patch of patches) {
-            if (patch.path.startsWith('/tree/')) {
-                treePatches.push(patch);
-            }
-            else {
-                otherPatches.push(patch);
-            }
-        }
-        // console.info(JSON.stringify(otherPatches))
-        //////////////////////////////////////////////////////////////////////////////
-        // The following split of the state update helps very much in some cases to
-        // prevent not existing object access in many React hooks.
-        // 1. Perform meta information update as the first step (root, currentProduct, ...)
-        applyBlock(otherPatches);
-        // 2. Perform tree update as a second, separate step
-        applyBlock(treePatches);
-        // TODO: The update behaviour for structure updates in buerli/zustand/react-hooks
-        //       has to be analyzed in more detail based on a very simple example.
-        //////////////////////////////////////////////////////////////////////////////
-        const { api } = get();
-        api.structure.postProcessStructureUpdate();
-        // Update the bounds, but only if products or visible containers changed.
-        const after = get().structure.products.concat(get().structure.visibleContainers);
-        if (before.sort().join() !== after.sort().join()) {
-            api.geometry.updateBounds();
-        }
-    },
-    filterTree: (tree, filter) => {
-        const objs = [];
-        const keys = Object.getOwnPropertyNames(tree);
-        for (const key of keys) {
-            const obj = tree[key];
-            if (filter(obj)) {
-                objs.push(obj);
-            }
-        }
-        return objs;
-    },
-    findTree: (tree, filter) => {
-        const keys = Object.getOwnPropertyNames(tree);
-        for (const key of keys) {
-            const obj = tree[key];
-            if (filter(obj)) {
-                return obj;
-            }
-        }
-        return undefined;
-    },
-    collectUsedSolidIds: () => {
-        const { api, structure } = get();
-        const solidObjs = api.structure.filterTree(structure.tree, obj => typeof obj.geometryIdList !== 'undefined');
-        const solidIds = [];
-        solidObjs.forEach(solidObj => solidIds.push(...(solidObj.geometryIdList || [])));
-        return solidIds;
-    },
-    collectProducts: (root) => {
-        const { structure } = get();
-        const products = [];
-        const recursive = (id) => {
-            const obj = structure.tree[id];
-            if (obj) {
-                if ((obj.solids && obj.solids.length > 0) || obj.link) {
-                    products.push(obj);
-                }
-                if (obj.children) {
-                    for (const child of obj.children) {
-                        recursive(child);
-                    }
-                }
-            }
-        };
-        recursive(root);
-        return products;
-    },
-    getProductSolidIds: (productId) => {
-        const { structure } = get();
-        let solids;
-        const product = structure.tree[productId];
-        if (product.link !== undefined) {
-            solids = structure.tree[product.link].solids || [];
-        }
-        else {
-            solids = product.solids || [];
-        }
-        return [...solids];
-    },
-    postProcessStructureUpdate: () => {
-        const { api, structure } = get();
-        //////////
-        // 1. Collect the products
-        //////////
-        const searchRoot = structure.root; // || structure.currentInstance || structure.currentProduct
-        const productIds = api.structure.collectProducts(searchRoot).map(p => p.id);
-        //////////
-        // 2. Collect the solid ids
-        //////////
-        let solidIds = [];
-        productIds.forEach(prodId => solidIds.push(...(api.structure.getProductSolidIds(prodId) || [])));
-        // remove duplicates
-        solidIds = solidIds.filter((item, index) => solidIds.indexOf(item) === index);
-        //////////
-        // 3. Add the result to the state
-        //////////
-        set(state => ({
-            structure: Object.assign(Object.assign({}, state.structure), { visibleContainers: solidIds, products: productIds }),
-        }));
-    },
-    /**
-     * Calculates the global transformation matrix for the given _objectId_.
-     *
-     * @param objectId The object to calculate the global transformation for.
-     * @param matrix The initial matrix (mainly used for recursion). It is an out parameter and in the end, it will contain the same matrix as the return value of this function.
-     * @returns The global transformation matrix for the given _objectId_.
-     */
-    calculateGlobalTransformation: (objectId, matrix = new THREE.Matrix4().identity()) => {
-        const { structure, api } = get();
-        const { tree, root } = structure;
-        const obj = tree[objectId];
-        if (obj && obj.coordinateSystem) {
-            const objMatrix = Math_1.MathUtils.convertToMatrix4(obj.coordinateSystem);
-            matrix = matrix.clone().premultiply(objMatrix);
-        }
-        if (objectId !== root && obj.parent) {
-            matrix = api.structure.calculateGlobalTransformation(obj.parent, matrix);
-        }
-        return matrix;
-    },
-    calculateProductBounds: (productId, base) => {
-        const { graphic, api } = get();
-        const posInf = Number.POSITIVE_INFINITY;
-        const negInf = Number.NEGATIVE_INFINITY;
-        const baseMin = base ? base.min.clone() : new THREE.Vector3(posInf, posInf, posInf);
-        const baseMax = base ? base.max.clone() : new THREE.Vector3(negInf, negInf, negInf);
-        let box = new THREE.Box3(baseMin, baseMax);
-        const productIds = api.structure.collectProducts(productId).map(p => p.id);
-        for (const pId of productIds) {
-            const matrix = api.structure.calculateGlobalTransformation(pId);
-            const contIds = api.structure.getProductSolidIds(pId);
-            for (const contId of contIds) {
-                const cont = graphic.containers[contId];
-                if (cont) {
-                    const min = new THREE.Vector3().fromArray(cont.properties.min);
-                    const max = new THREE.Vector3().fromArray(cont.properties.max);
-                    const b = new THREE.Box3(min.clone(), max.clone());
-                    b.applyMatrix4(matrix);
-                    box = box.union(b);
-                }
-            }
-        }
-        const sphere = new THREE.Sphere();
-        box.getBoundingSphere(sphere);
-        return { center: sphere.center, radius: sphere.radius, max: box.max, min: box.min };
-    },
-    /**
-     * This is a workaround to get the corresponding drawing id via API.
-     *
-     * > !!! Should not be used in user code !!!
-     *
-     * @returns The drawing id.
-     */
-    getDrawingId: () => get().id,
-});
-exports.structureApi = structureApi;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : 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 };
+};
+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");
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+const structureData = () => {
+    return Object.assign(Object.assign({}, (0, types_1.DEFAULT_STRUCTURE_TREE)()), { visibleContainers: [], products: [] });
+};
+exports.structureData = structureData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+const structureApi = (set, get, buerliApi) => ({
+    get: () => {
+        return get().structure;
+    },
+    set: (structure) => {
+        const { api } = get();
+        // TODO: clear object selection if needed
+        // 1. set the state
+        set({
+            structure: Object.assign(Object.assign({}, get().structure), structure),
+        });
+        // 2. collect and cleanup data
+        api.graphic.cleanupGraphicRecords();
+        // console.log('cleanup')
+        api.structure.postProcessStructureUpdate();
+    },
+    applyPatches: (patches) => {
+        const before = get().structure.products.concat(get().structure.visibleContainers);
+        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);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                // console.info('currentProduct in new patched structure: ', structure.currentProduct)
+                return { structure: Object.assign(Object.assign({}, state.structure), structure) };
+            });
+        };
+        const treePatches = [];
+        const otherPatches = [];
+        for (const patch of patches) {
+            if (patch.path.startsWith('/tree/')) {
+                treePatches.push(patch);
+            }
+            else {
+                otherPatches.push(patch);
+            }
+        }
+        // console.info(JSON.stringify(otherPatches))
+        //////////////////////////////////////////////////////////////////////////////
+        // The following split of the state update helps very much in some cases to
+        // prevent not existing object access in many React hooks.
+        // 1. Perform meta information update as the first step (root, currentProduct, ...)
+        applyBlock(otherPatches);
+        // 2. Perform tree update as a second, separate step
+        applyBlock(treePatches);
+        // TODO: The update behaviour for structure updates in buerli/zustand/react-hooks
+        //       has to be analyzed in more detail based on a very simple example.
+        //////////////////////////////////////////////////////////////////////////////
+        const { api } = get();
+        api.structure.postProcessStructureUpdate();
+        // Update the bounds, but only if products or visible containers changed.
+        const after = get().structure.products.concat(get().structure.visibleContainers);
+        if (before.sort().join() !== after.sort().join()) {
+            api.geometry.updateBounds();
+        }
+    },
+    filterTree: (tree, filter) => {
+        const objs = [];
+        const keys = Object.getOwnPropertyNames(tree);
+        for (const key of keys) {
+            const obj = tree[key];
+            if (filter(obj)) {
+                objs.push(obj);
+            }
+        }
+        return objs;
+    },
+    findTree: (tree, filter) => {
+        const keys = Object.getOwnPropertyNames(tree);
+        for (const key of keys) {
+            const obj = tree[key];
+            if (filter(obj)) {
+                return obj;
+            }
+        }
+        return undefined;
+    },
+    collectUsedSolidIds: () => {
+        const { api, structure } = get();
+        const solidObjs = api.structure.filterTree(structure.tree, obj => typeof obj.geometryIdList !== 'undefined');
+        const solidIds = [];
+        solidObjs.forEach(solidObj => solidIds.push(...(solidObj.geometryIdList || [])));
+        return solidIds;
+    },
+    collectProducts: (root) => {
+        const { structure } = get();
+        const products = [];
+        const recursive = (id) => {
+            const obj = structure.tree[id];
+            if (obj) {
+                if ((obj.solids && obj.solids.length > 0) || obj.link) {
+                    products.push(obj);
+                }
+                if (obj.children) {
+                    for (const child of obj.children) {
+                        recursive(child);
+                    }
+                }
+            }
+        };
+        recursive(root);
+        return products;
+    },
+    getProductSolidIds: (productId) => {
+        const { structure } = get();
+        let solids;
+        const product = structure.tree[productId];
+        if (product.link !== undefined) {
+            solids = structure.tree[product.link].solids || [];
+        }
+        else {
+            solids = product.solids || [];
+        }
+        return [...solids];
+    },
+    postProcessStructureUpdate: () => {
+        const { api, structure } = get();
+        //////////
+        // 1. Collect the products
+        //////////
+        const searchRoot = structure.root; // || structure.currentInstance || structure.currentProduct
+        const productIds = api.structure.collectProducts(searchRoot).map(p => p.id);
+        //////////
+        // 2. Collect the solid ids
+        //////////
+        let solidIds = [];
+        productIds.forEach(prodId => solidIds.push(...(api.structure.getProductSolidIds(prodId) || [])));
+        // remove duplicates
+        solidIds = solidIds.filter((item, index) => solidIds.indexOf(item) === index);
+        //////////
+        // 3. Add the result to the state
+        //////////
+        set(state => ({
+            structure: Object.assign(Object.assign({}, state.structure), { visibleContainers: solidIds, products: productIds }),
+        }));
+    },
+    /**
+     * Calculates the global transformation matrix for the given _objectId_.
+     *
+     * @param objectId The object to calculate the global transformation for.
+     * @param matrix The initial matrix (mainly used for recursion). It is an out parameter and in the end, it will contain the same matrix as the return value of this function.
+     * @returns The global transformation matrix for the given _objectId_.
+     */
+    calculateGlobalTransformation: (objectId, matrix = new THREE.Matrix4().identity()) => {
+        const { structure, api } = get();
+        const { tree, root } = structure;
+        const obj = tree[objectId];
+        if (obj && obj.coordinateSystem) {
+            const objMatrix = Math_1.MathUtils.convertToMatrix4(obj.coordinateSystem);
+            matrix = matrix.clone().premultiply(objMatrix);
+        }
+        if (objectId !== root && obj.parent) {
+            matrix = api.structure.calculateGlobalTransformation(obj.parent, matrix);
+        }
+        return matrix;
+    },
+    calculateProductBounds: (productId, base) => {
+        const { graphic, api } = get();
+        const posInf = Number.POSITIVE_INFINITY;
+        const negInf = Number.NEGATIVE_INFINITY;
+        const baseMin = base ? base.min.clone() : new THREE.Vector3(posInf, posInf, posInf);
+        const baseMax = base ? base.max.clone() : new THREE.Vector3(negInf, negInf, negInf);
+        let box = new THREE.Box3(baseMin, baseMax);
+        const productIds = api.structure.collectProducts(productId).map(p => p.id);
+        for (const pId of productIds) {
+            const matrix = api.structure.calculateGlobalTransformation(pId);
+            const contIds = api.structure.getProductSolidIds(pId);
+            for (const contId of contIds) {
+                const cont = graphic.containers[contId];
+                if (cont) {
+                    const min = new THREE.Vector3().fromArray(cont.properties.min);
+                    const max = new THREE.Vector3().fromArray(cont.properties.max);
+                    const b = new THREE.Box3(min.clone(), max.clone());
+                    b.applyMatrix4(matrix);
+                    box = box.union(b);
+                }
+            }
+        }
+        const sphere = new THREE.Sphere();
+        box.getBoundingSphere(sphere);
+        return { center: sphere.center, radius: sphere.radius, max: box.max, min: box.min };
+    },
+    /**
+     * This is a workaround to get the corresponding drawing id via API.
+     *
+     * > !!! Should not be used in user code !!!
+     *
+     * @returns The drawing id.
+     */
+    getDrawingId: () => get().id,
+});
+exports.structureApi = structureApi;

package/build/cjs/store/store.js

@@ -1,9 +1,9 @@
-"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 buerli_1 = require("./states/buerli");
-exports.api = (0, vanilla_1.default)()(buerli_1.createState);
+"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 buerli_1 = require("./states/buerli");
+exports.api = (0, vanilla_1.default)()(buerli_1.createState);

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

@@ -1,49 +1,49 @@
-"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;
-const subscribeToDrawing_1 = require("./subscribeToDrawing");
-// This object contains unsubscibe function for all existing selections in all drawings
-exports.unsubs = {};
-function getId(selectorId, itemId) {
-    return `${selectorId}_${itemId}`;
-}
-function subscribeItems(buerliApi, drawingId, selectorId, items) {
-    const items_ = items || buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId].items;
-    items_.forEach(item => {
-        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;
-        exports.unsubs[getId(selectorId, item.id)] = (0, subscribeToDrawing_1.subscribeToDrawing)(buerliApi, drawingId, (d) => item.removeCondition && item.removeCondition(d), (removeCond) => {
-            var _a;
-            // Unselect item whose removeCondition got true
-            if (removeCond) {
-                const newItems = ((_a = buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId]) === null || _a === void 0 ? void 0 : _a.items) || [];
-                selApi.setItems(selectorId, newItems.filter(item_ => item_.id !== item.id));
-            }
-        });
-    }
-}
-function unsubscribeItems(buerliApi, drawingId, selectorId, items) {
-    var _a, _b, _c, _d;
-    // The following line leeds to exceptions if for example the corresponding drawing is going to be reset.
-    // To prevent those exceptions, check all properties for existance.
-    const items_ = items || ((_d = (_c = (_b = (_a = buerliApi.getState().drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.selection) === null || _b === void 0 ? void 0 : _b.refs) === null || _c === void 0 ? void 0 : _c[selectorId]) === null || _d === void 0 ? void 0 : _d.items) || [];
-    items_.forEach(item => {
-        unsubscribeItem(selectorId, item);
-    });
-}
-exports.unsubscribeItems = unsubscribeItems;
-function unsubscribeItem(selectorId, item) {
-    if (item.removeCondition) {
-        const id = getId(selectorId, item.id);
-        if (exports.unsubs[id]) {
-            exports.unsubs[id]();
-            delete exports.unsubs[id];
-        }
-    }
-}
+"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;
+const subscribeToDrawing_1 = require("./subscribeToDrawing");
+// This object contains unsubscibe function for all existing selections in all drawings
+exports.unsubs = {};
+function getId(selectorId, itemId) {
+    return `${selectorId}_${itemId}`;
+}
+function subscribeItems(buerliApi, drawingId, selectorId, items) {
+    const items_ = items || buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId].items;
+    items_.forEach(item => {
+        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;
+        exports.unsubs[getId(selectorId, item.id)] = (0, subscribeToDrawing_1.subscribeToDrawing)(buerliApi, drawingId, (d) => item.removeCondition && item.removeCondition(d), (removeCond) => {
+            var _a;
+            // Unselect item whose removeCondition got true
+            if (removeCond) {
+                const newItems = ((_a = buerliApi.getState().drawing.refs[drawingId].selection.refs[selectorId]) === null || _a === void 0 ? void 0 : _a.items) || [];
+                selApi.setItems(selectorId, newItems.filter(item_ => item_.id !== item.id));
+            }
+        });
+    }
+}
+function unsubscribeItems(buerliApi, drawingId, selectorId, items) {
+    var _a, _b, _c, _d;
+    // The following line leeds to exceptions if for example the corresponding drawing is going to be reset.
+    // To prevent those exceptions, check all properties for existance.
+    const items_ = items || ((_d = (_c = (_b = (_a = buerliApi.getState().drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.selection) === null || _b === void 0 ? void 0 : _b.refs) === null || _c === void 0 ? void 0 : _c[selectorId]) === null || _d === void 0 ? void 0 : _d.items) || [];
+    items_.forEach(item => {
+        unsubscribeItem(selectorId, item);
+    });
+}
+exports.unsubscribeItems = unsubscribeItems;
+function unsubscribeItem(selectorId, item) {
+    if (item.removeCondition) {
+        const id = getId(selectorId, item.id);
+        if (exports.unsubs[id]) {
+            exports.unsubs[id]();
+            delete exports.unsubs[id];
+        }
+    }
+}