@buerli.io/core 0.13.1-beta.8.apiversion → 1.0.0

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

@@ -1,219 +1,219 @@
-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';
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-export const structureData = () => {
-    return Object.assign(Object.assign({}, DEFAULT_STRUCTURE_TREE()), { visibleContainers: [], products: [] });
-};
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-export 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 = fastpatch.applyPatch(state.structure, block, false, false).newDocument;
-                    }
-                    else {
-                        structure = jsonpatch.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 = 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,
-});
+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';
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+export const structureData = () => {
+    return Object.assign(Object.assign({}, DEFAULT_STRUCTURE_TREE()), { visibleContainers: [], products: [] });
+};
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+export 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 = fastpatch.applyPatch(state.structure, block, false, false).newDocument;
+                    }
+                    else {
+                        structure = jsonpatch.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 = 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,
+});

package/build/esm/store/store.js

@@ -1,3 +1,3 @@
-import vanillaCreate from 'zustand/vanilla';
-import { createState } from './states/buerli';
-export const api = vanillaCreate()(createState);
+import vanillaCreate from 'zustand/vanilla';
+import { createState } from './states/buerli';
+export const api = vanillaCreate()(createState);

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

@@ -1,44 +1,44 @@
-// This is the solution for cases when object was deleted from tree and we need to remove corresponding selectedItem.
-import { subscribeToDrawing } from './subscribeToDrawing';
-// This object contains unsubscibe function for all existing selections in all drawings
-export const unsubs = {};
-function getId(selectorId, itemId) {
-    return `${selectorId}_${itemId}`;
-}
-export 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);
-    });
-}
-function subscribeItem(buerliApi, drawingId, selectorId, item) {
-    if (item.removeCondition && !unsubs[getId(selectorId, item.id)]) {
-        const selApi = buerliApi.getState().drawing.refs[drawingId].api.selection;
-        unsubs[getId(selectorId, item.id)] = 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));
-            }
-        });
-    }
-}
-export 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);
-    });
-}
-function unsubscribeItem(selectorId, item) {
-    if (item.removeCondition) {
-        const id = getId(selectorId, item.id);
-        if (unsubs[id]) {
-            unsubs[id]();
-            delete unsubs[id];
-        }
-    }
-}
+// This is the solution for cases when object was deleted from tree and we need to remove corresponding selectedItem.
+import { subscribeToDrawing } from './subscribeToDrawing';
+// This object contains unsubscibe function for all existing selections in all drawings
+export const unsubs = {};
+function getId(selectorId, itemId) {
+    return `${selectorId}_${itemId}`;
+}
+export 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);
+    });
+}
+function subscribeItem(buerliApi, drawingId, selectorId, item) {
+    if (item.removeCondition && !unsubs[getId(selectorId, item.id)]) {
+        const selApi = buerliApi.getState().drawing.refs[drawingId].api.selection;
+        unsubs[getId(selectorId, item.id)] = 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));
+            }
+        });
+    }
+}
+export 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);
+    });
+}
+function unsubscribeItem(selectorId, item) {
+    if (item.removeCondition) {
+        const id = getId(selectorId, item.id);
+        if (unsubs[id]) {
+            unsubs[id]();
+            delete unsubs[id];
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
-export function subscribeToDrawing(buerliApi, drawingId, sel, callback) {
-    const unsub = buerliApi.subscribe((state, prev) => {
-        const curDrawing = state.drawing.refs[drawingId] && sel(state.drawing.refs[drawingId]);
-        const prevDrawing = prev.drawing.refs[drawingId] && sel(prev.drawing.refs[drawingId]);
-        if (curDrawing !== prevDrawing)
-            callback(curDrawing);
-    });
-    return unsub;
-}
+export function subscribeToDrawing(buerliApi, drawingId, sel, callback) {
+    const unsub = buerliApi.subscribe((state, prev) => {
+        const curDrawing = state.drawing.refs[drawingId] && sel(state.drawing.refs[drawingId]);
+        const prevDrawing = prev.drawing.refs[drawingId] && sel(prev.drawing.refs[drawingId]);
+        if (curDrawing !== prevDrawing)
+            callback(curDrawing);
+    });
+    return unsub;
+}

package/build/esm/types/InteractionInfo.js

@@ -1,6 +1,6 @@
-export const createInfo = (data) => {
-    return Object.assign({ uniqueIdent: createUniqueIdent(data) }, data);
-};
-export const createUniqueIdent = (data) => {
-    return `${[data.prodRefId, data.objectId, data.containerId, data.graphicId]}`;
-};
+export const createInfo = (data) => {
+    return Object.assign({ uniqueIdent: createUniqueIdent(data) }, data);
+};
+export const createUniqueIdent = (data) => {
+    return `${[data.prodRefId, data.objectId, data.containerId, data.graphicId]}`;
+};

package/build/esm/types/index.js

@@ -1,16 +1,16 @@
-import { NOID } from '../re-export';
-export * from './InteractionInfo';
-/**
- * Defines the default structure tree.
- * Should be used to initialize a new structure tree.
- */
-export const DEFAULT_STRUCTURE_TREE = () => {
-    return {
-        tree: {},
-        root: NOID,
-        currentProduct: NOID,
-        currentNode: NOID,
-        currentInstance: NOID,
-        testRoot: NOID,
-    };
-};
+import { NOID } from '../re-export';
+export * from './InteractionInfo';
+/**
+ * Defines the default structure tree.
+ * Should be used to initialize a new structure tree.
+ */
+export const DEFAULT_STRUCTURE_TREE = () => {
+    return {
+        tree: {},
+        root: NOID,
+        currentProduct: NOID,
+        currentNode: NOID,
+        currentInstance: NOID,
+        testRoot: NOID,
+    };
+};