@buerli.io/core 0.0.34-beta.0 → 0.0.35-beta.1

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphicApi = exports.graphicData = void 0;
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+const graphicData = () => ({
+    containers: {},
+});
+exports.graphicData = graphicData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+const graphicApi = (set, get) => ({
+    addPackages: (packages) => {
+        // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
+        let cacheChanged = false;
+        const newChache = Object.assign({}, get().geometry.cache);
+        const addedContainers = {};
+        packages.forEach(gr => {
+            gr.containers.forEach(cont => {
+                addedContainers[cont.id] = cont;
+                // If the cached geometry for the added container already exist,
+                // it has to be removed from the cache to ensure geometry updates.
+                if (newChache[cont.id]) {
+                    delete newChache[cont.id];
+                    cacheChanged = true;
+                }
+            });
+        });
+        set(state => ({
+            graphic: Object.assign(Object.assign({}, state.graphic), { containers: Object.assign(Object.assign({}, state.graphic.containers), addedContainers) }),
+            geometry: cacheChanged ? Object.assign(Object.assign({}, state.geometry), { cache: newChache, stamp: Date.now() }) : state.geometry,
+        }));
+        const { graphic, api } = get();
+        /**
+         * Update the bounds with the newly added graphic.
+         */
+        api.geometry.updateBounds();
+        /**
+         * Create the geometry for the graphic packages.
+         * Only the geometry which does not already exist will be created (@see createGeometryIfNotCached).
+         */
+        const containerIds = Object.getOwnPropertyNames(graphic.containers);
+        const createGeometry = async () => {
+            for (const id of containerIds) {
+                api.geometry.createGeometryIfNotCached(id);
+            }
+        };
+        createGeometry().catch();
+        // console.log('graphicContainers after add:', Object.getOwnPropertyNames(get().graphic.containers))
+    },
+    cleanupGraphicRecords: () => {
+        const { graphic, geometry, api } = get();
+        // collect the used solid ids from the structure tree
+        const solidIds = api.structure.collectUsedSolidIds();
+        // console.log('solidIds before cleanup:', solidIds)
+        // cleanup the graphic containers in the state
+        const usedContainers = {};
+        const existingContainers = graphic.containers;
+        const existingContainerIds = Object.getOwnPropertyNames(existingContainers);
+        if (existingContainerIds.length > 0) {
+            existingContainerIds.forEach(contIdStr => {
+                const contId = Number(contIdStr);
+                if (solidIds.indexOf(contId) >= 0) {
+                    usedContainers[contId] = existingContainers[contId];
+                }
+            });
+            set({ graphic: Object.assign(Object.assign({}, graphic), { containers: usedContainers }) });
+            // console.log('graphicContainers after cleanup:', Object.getOwnPropertyNames(get().graphic.ontainers))
+        }
+        // cleanup the cached geometry depending on the uses solids
+        const usedGeometry = {};
+        const existingGeometry = geometry.cache;
+        const existingGeometryIds = Object.getOwnPropertyNames(existingGeometry);
+        if (existingGeometryIds.length > 0) {
+            existingGeometryIds.forEach(contIdStr => {
+                const contId = Number(contIdStr);
+                if (solidIds.indexOf(contId) >= 0) {
+                    usedGeometry[contId] = existingGeometry[contId];
+                }
+            });
+            set({ geometry: Object.assign(Object.assign({}, geometry), { cache: usedGeometry, stamp: Date.now() }) });
+        }
+    },
+});
+exports.graphicApi = graphicApi;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitialMessageState = exports.BuerliMessageScope = void 0;
+const uuid_1 = require("uuid");
+exports.BuerliMessageScope = 'BuerliMessageScope';
+const getInitialMessageState = (set, get, api) => ({
+    message: {
+        data: null,
+        timestamp: -1,
+        api: messageApi(set, get, api),
+    },
+});
+exports.getInitialMessageState = getInitialMessageState;
+const messageApi = (set, get, api) => ({
+    show(message) {
+        const newId = uuid_1.v4();
+        const msg = get().message;
+        set({ message: Object.assign(Object.assign({}, msg), { data: Object.assign({ id: newId }, message), timestamp: Date.now() }) });
+        return newId;
+    },
+    update(id, message) {
+        const msg = get().message;
+        set({ message: Object.assign(Object.assign({}, msg), { data: Object.assign({ id }, message), timestamp: Date.now() }) });
+    },
+});

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromisePlugin = exports.pluginApi = exports.pluginData = void 0;
+const uuid_1 = require("uuid");
+const pluginData = () => ({
+    feature: [],
+    global: [],
+    refs: {},
+    active: {
+        feature: null,
+        global: [],
+    },
+    visible: [],
+});
+exports.pluginData = pluginData;
+const pluginApi = (set, get) => ({
+    setActiveFeature: (id) => {
+        set(state => {
+            let plugins = state.plugin.refs;
+            const oldPlugin = state.plugin.active.feature !== null && state.plugin.refs[state.plugin.active.feature];
+            if (oldPlugin && state.plugin.active.feature !== id && !oldPlugin.persistent && id !== null) {
+                // Reset plugin-state when the plugin is re-activated, not persistent and has not been active all along
+                const initState = oldPlugin.initialState || {};
+                plugins = Object.assign(Object.assign({}, plugins), { [oldPlugin.id]: Object.assign(Object.assign({}, oldPlugin), { state: typeof initState === 'function' ? initState(get().id, id) : initState }) });
+            }
+            return {
+                plugin: Object.assign(Object.assign({}, state.plugin), { active: Object.assign(Object.assign({}, state.plugin.active), { feature: id }), refs: plugins }),
+                selection: Object.assign(Object.assign({}, state.selection), { active: null }),
+            };
+        });
+    },
+    setVisiblePlugin: (id, visible) => {
+        set(currentState => {
+            const filtered = currentState.plugin.visible.filter(p => p !== id);
+            if (visible)
+                filtered.push(id);
+            return {
+                plugin: Object.assign(Object.assign({}, currentState.plugin), { visible: filtered }),
+            };
+        });
+    },
+    setActiveGlobal: (id, active) => {
+        set(currentState => {
+            if (currentState.plugin.global.indexOf(id) === -1) {
+                console.warn('Given plugin id does not exist.');
+                return currentState;
+            }
+            const filtered = currentState.plugin.active.global.filter(p => p !== id);
+            if (active)
+                filtered.push(id);
+            return {
+                plugin: Object.assign(Object.assign({}, currentState.plugin), { active: Object.assign(Object.assign({}, currentState.plugin.active), { global: filtered }) }),
+            };
+        });
+    },
+    // TODO remove defaultId and useEmbeddedPlugin ?
+    createPlugin: (def, defaultId, drawingId, objectId) => {
+        const id = defaultId !== void 0 ? defaultId : uuid_1.v4();
+        function init(definition) {
+            const { description, Root = null, View = null } = definition;
+            const initialState = description.initialState || {};
+            const localState = typeof initialState === 'function' ? initialState(drawingId, objectId) : initialState;
+            set(currentState => {
+                const newPlugin = Object.assign(Object.assign({ id }, description), { drawingId,
+                    objectId, state: localState, Root,
+                    View, set: (sel) => {
+                        // set function can be called when drawing doesn't exist anymore, in this case nothing should be done.
+                        if (get() === undefined)
+                            return;
+                        set(state => {
+                            const newState = typeof sel === 'function' ? sel(state.plugin.refs[id].state) : sel;
+                            return {
+                                plugin: Object.assign(Object.assign({}, state.plugin), { refs: Object.assign(Object.assign({}, state.plugin.refs), { [id]: Object.assign(Object.assign({}, state.plugin.refs[id]), { state: Object.assign(Object.assign({}, state.plugin.refs[id].state), newState) }) }) }),
+                            };
+                        });
+                    } });
+                return {
+                    plugin: Object.assign(Object.assign({}, currentState.plugin), { feature: description.global ? currentState.plugin.feature : [...currentState.plugin.feature, id], global: description.global ? [...currentState.plugin.global, id] : currentState.plugin.global, refs: Object.assign(Object.assign({}, currentState.plugin.refs), { [id]: Object.assign(Object.assign({}, currentState.plugin.refs[id]), newPlugin) }) }),
+                };
+            });
+        }
+        // Initialize plugin definition, which may be a promise or an object
+        if (isPromisePlugin(def)) {
+            // The definition is async, so we create a plugin slot right away and complete it later
+            init({
+                description: { author: '', name: '', persistent: false, global: false, version: '' },
+                Root: null,
+                View: null,
+            });
+            def.then(init).catch();
+        }
+        else
+            init(def);
+        // Return unsubscribe
+        return (deactivate = true) => {
+            // Use 'get' to check if the drawing still exists
+            get &&
+                get() &&
+                set(state => {
+                    const newPlugins = Object.assign({}, state.plugin.refs);
+                    delete newPlugins[id];
+                    return {
+                        plugin: Object.assign(Object.assign({}, state.plugin), { active: Object.assign(Object.assign({}, state.plugin.active), { feature: deactivate ? null : state.plugin.active.feature }), feature: state.plugin.feature.filter(pluginId => pluginId !== id), global: state.plugin.global.filter(pluginId => pluginId !== id), refs: newPlugins }),
+                    };
+                });
+        };
+    },
+});
+exports.pluginApi = pluginApi;
+function isPromisePlugin(def) {
+    return def.then !== undefined;
+}
+exports.isPromisePlugin = isPromisePlugin;

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

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphicItem = exports.selectionApi = exports.selectionData = exports.BuerliScope = void 0;
+const selection_1 = require("../subscribtion/selection");
+////////////////////////////////////////////////////
+// CONSTANTS
+////////////////////////////////////////////////////
+exports.BuerliScope = 'ClassCAD';
+const selectionData = () => ({
+    refs: {},
+    active: null,
+});
+exports.selectionData = selectionData;
+const selectionApi = (set, get) => ({
+    unselectAll() {
+        const drawingId = get().id;
+        const activeSelector = get().selection.active;
+        if (activeSelector) {
+            const unselItems = get().selection.refs[activeSelector].items;
+            selection_1.unsubscribeItems(drawingId, activeSelector, unselItems);
+            set(state => {
+                const selector = state.selection.refs[activeSelector];
+                return {
+                    selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelector]: Object.assign(Object.assign({}, selector), { items: [] }) }) }),
+                };
+            });
+        }
+    },
+    unselect(...unselItems) {
+        const { selection, id: drawingId } = get();
+        const activeSelectorId = selection.active;
+        if (activeSelectorId) {
+            // Remove unselItems from selector's items
+            const selector = selection.refs[activeSelectorId];
+            const newItems = selector.items.filter(item => unselItems.find(uItem => uItem.id === item.id) === undefined);
+            selection_1.unsubscribeItems(drawingId, activeSelectorId, unselItems);
+            if (selector.customUnSelect) {
+                // Find recently unselected items
+                const diff = selector.items.filter(item1 => {
+                    return newItems.find(item2 => item2.id === item1.id) === undefined;
+                });
+                selector.customUnSelect(activeSelectorId, newItems, diff);
+            }
+            else {
+                set(state => {
+                    return {
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelectorId]: Object.assign(Object.assign({}, state.selection.refs[activeSelectorId]), { items: newItems }) }) }),
+                    };
+                });
+            }
+            this.setHovered(null, activeSelectorId);
+        }
+    },
+    select(...newItems) {
+        const { selection, api, id: drawingId } = get();
+        const activeSelectorId = selection.active;
+        const { isItemSelected } = api.selection;
+        if (activeSelectorId) {
+            const selector = selection.refs[activeSelectorId];
+            const curItems = selector.items;
+            // Remove duplicates
+            let filteredItems = newItems.filter((item1, idx) => newItems.findIndex(item2 => item2.id === item1.id) === idx);
+            // Remove already selected items and duplicates
+            filteredItems = filteredItems.filter(item => !isItemSelected(item, activeSelectorId));
+            let unsubItems = [];
+            let result = [...curItems, ...filteredItems];
+            if (selector.maxLen > 0) {
+                if (filteredItems.length === selector.maxLen) {
+                    result = [...filteredItems];
+                    unsubItems = [...curItems];
+                }
+                else if (filteredItems.length > selector.maxLen) {
+                    const extraItems = filteredItems.length - selector.maxLen;
+                    // If filteredItems has bigger length then selector.maxLen, remove last few items from filteredItems.
+                    result = filteredItems.slice(0, -extraItems);
+                    unsubItems = [...curItems];
+                }
+                else if (filteredItems.length + curItems.length >= selector.maxLen) {
+                    const extraItems = filteredItems.length + curItems.length - selector.maxLen;
+                    const allItems = [...curItems, ...filteredItems];
+                    // If filteredItems.len + curItems.len > selector.maxLen, remove first few items from union of curItems and filteredItems.
+                    result = allItems.slice(extraItems);
+                    unsubItems = allItems.slice(0, extraItems);
+                }
+            }
+            if (selector.customSelect !== undefined) {
+                // Find items which weren't selected before.
+                const diff = result.filter(item1 => {
+                    return selector.items.find(item2 => item2.id === item1.id) === undefined;
+                });
+                selector.customSelect(activeSelectorId, result, diff);
+            }
+            else {
+                // subscribe items which will be selected
+                selection_1.subscribeItems(drawingId, activeSelectorId, result);
+                // unsubscribe items which will be unselected
+                selection_1.unsubscribeItems(drawingId, activeSelectorId, unsubItems);
+                set(state => {
+                    return {
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelectorId]: Object.assign(Object.assign({}, selector), { items: result }) }) }),
+                    };
+                });
+            }
+            this.setHovered(null, activeSelectorId);
+        }
+    },
+    setHovered(item, selectorId) {
+        const { selection } = get();
+        if (selection.active === null && selectorId === undefined)
+            return;
+        const selId = selection.active || selectorId;
+        set(state => ({
+            selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, state.selection.refs[selId]), { hoveredItem: item }) }) }),
+        }));
+    },
+    activateSelector(selectorId) {
+        set(state => {
+            const refs = state.selection.refs;
+            const curSelectorId = state.selection.active;
+            if (curSelectorId) {
+                // Reset hoveredItem
+                refs[curSelectorId] = Object.assign(Object.assign({}, refs[curSelectorId]), { hoveredItem: null });
+            }
+            return {
+                selection: Object.assign(Object.assign({}, state.selection), { active: state.selection.active === selectorId ? null : selectorId, refs: Object.assign({}, refs) }),
+            };
+        });
+    },
+    createSelector(selectorId, filter, activate = false, initialItems = [], maxLen = -1, customSelect, customUnSelect) {
+        if (maxLen > 0 && initialItems.length > maxLen)
+            console.error('Number initialItems should be less or equal to selector.maxLen');
+        set(state => ({
+            selection: Object.assign(Object.assign({}, state.selection), { active: activate ? selectorId : state.selection.active, refs: Object.assign(Object.assign({}, state.selection.refs), { [selectorId]: {
+                        items: maxLen > 0 && initialItems.length > maxLen ? [] : initialItems,
+                        hoveredItem: null,
+                        isSelectable: filter,
+                        maxLen,
+                        customSelect,
+                        customUnSelect,
+                    } }) }),
+        }));
+        return () => {
+            if (get && get()) {
+                const drawingId = get().id;
+                selection_1.unsubscribeItems(drawingId, selectorId);
+                set(state => {
+                    const refs = state.selection.refs;
+                    delete refs[selectorId];
+                    return {
+                        selection: Object.assign(Object.assign({}, state.selection), { active: state.selection.active === selectorId ? null : state.selection.active, refs }),
+                    };
+                });
+            }
+        };
+    },
+    areItemsSelected: (items, selectorId) => {
+        const { selection } = get();
+        if (selection.active === null && selectorId === undefined)
+            return false;
+        const selId = selection.active || selectorId;
+        const selector = selection.refs[selId];
+        let res = true;
+        items.forEach(item => {
+            const itemSelected = Boolean(selector.items.find(i => areItemsEqual(i, item)));
+            if (!itemSelected) {
+                res = false;
+            }
+        });
+        return res;
+    },
+    isItemSelected: (item, selectorId) => {
+        const { selection } = get();
+        if (selection.active === null && selectorId === undefined)
+            return false;
+        const selId = selection.active || selectorId;
+        const selector = selection.refs[selId];
+        return Boolean(selector.items.find(i => areItemsEqual(i, item)));
+    },
+    setItems(id, items) {
+        var _a;
+        const { selection, id: drawingId } = get();
+        const curItems = ((_a = selection.refs[id]) === null || _a === void 0 ? void 0 : _a.items) || [];
+        selection_1.unsubscribeItems(drawingId, id, curItems);
+        selection_1.subscribeItems(drawingId, id, items);
+        set(state => {
+            const selector = state.selection.refs[id];
+            return {
+                selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [id]: Object.assign(Object.assign({}, selector), { items }) }) }),
+            };
+        });
+    },
+    getGraphicItem: (productId, containerId, graphicId) => {
+        const { cache } = get().geometry;
+        const container = cache[containerId];
+        if (container) {
+            if (graphicId === undefined) {
+                const ids = Object.getOwnPropertyNames(container.map);
+                graphicId = ids.length > 0 ? Number(ids[0]) : undefined;
+            }
+            if (graphicId !== undefined) {
+                const geomElem = container.map[graphicId];
+                if (geomElem) {
+                    return exports.createGraphicItem(productId, geomElem);
+                }
+            }
+        }
+        return null;
+    },
+});
+exports.selectionApi = selectionApi;
+////////////////////////////////////////////////////
+//#region GLOBAL FUNCTIONS
+const areItemsEqual = (a, b) => a.id === b.id && a.scope === b.scope;
+const createGraphicIdent = (productId, graphicId, type) => {
+    return {
+        id: `${productId}|${graphicId}|${type}`,
+        scope: exports.BuerliScope,
+        label: (type[0] + type[1]).toUpperCase(),
+    };
+};
+const createGraphicItem = (productId, el) => {
+    return Object.assign(Object.assign({}, createGraphicIdent(productId, el.graphicId, el.type)), { data: Object.assign(Object.assign({}, el), { productId }) });
+};
+exports.createGraphicItem = createGraphicItem;
+//#endregion GLOBAL FUNCTIONS
+////////////////////////////////////////////////////

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

@@ -0,0 +1,203 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 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({}, types_1.DEFAULT_STRUCTURE_TREE()), { visibleContainers: [], products: [] });
+};
+exports.structureData = structureData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+const structureApi = (set, get) => ({
+    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);
+        // Timing.dump('load', 'received tree patches')
+        set(state => {
+            let structure = state.structure;
+            try {
+                structure = jsonpatch_1.default.apply_patch(state.structure, patches);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return {
+                structure: Object.assign(Object.assign({}, get().structure), structure),
+            };
+        });
+        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 = [];
+        Object.getOwnPropertyNames(tree).forEach(name => {
+            const obj = tree[name];
+            if (filter(obj)) {
+                objs.push(obj);
+            }
+        });
+        return objs;
+    },
+    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.currentNode || 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

@@ -0,0 +1,14 @@
+"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");
+const store = (set, get, buerliApi) => buerli_1.createState(set, get, buerliApi);
+const wnd = typeof window !== 'undefined' ? window : null;
+const middleware = wnd ? wnd.BUERLI_MIDDLEWARE || (wnd.BUERLI_MIDDLEWARE = []) : [];
+const buerliStore = middleware.reduceRight((acc, cur) => cur(acc), store);
+const api = vanilla_1.default(buerliStore);
+exports.api = api;