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

package/build/{store → cjs/store}/states/selection.js

@@ -1,15 +1,23 @@
+"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
 ////////////////////////////////////////////////////
-export const BuerliScope = 'ClassCAD';
-export const selectionData = () => ({
+exports.BuerliScope = 'ClassCAD';
+const selectionData = () => ({
     refs: {},
     active: null,
 });
-export const selectionApi = (set, get) => ({
+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 {
@@ -19,12 +27,13 @@ export const selectionApi = (set, get) => ({
         }
     },
     unselect(...unselItems) {
-        const { selection } = get();
+        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 => {
@@ -43,7 +52,7 @@ export const selectionApi = (set, get) => ({
         }
     },
     select(...newItems) {
-        const { selection, api } = get();
+        const { selection, api, id: drawingId } = get();
         const activeSelectorId = selection.active;
         const { isItemSelected } = api.selection;
         if (activeSelectorId) {
@@ -53,20 +62,25 @@ export const selectionApi = (set, get) => ({
             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 = [...curItems, ...filteredItems].slice(extraItems);
+                    result = allItems.slice(extraItems);
+                    unsubItems = allItems.slice(0, extraItems);
                 }
             }
             if (selector.customSelect !== undefined) {
@@ -77,6 +91,10 @@ export const selectionApi = (set, get) => ({
                 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 }) }) }),
@@ -121,15 +139,19 @@ export const selectionApi = (set, get) => ({
                         customUnSelect,
                     } }) }),
         }));
-        return () => get &&
-            get() &&
-            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 }),
-                };
-            });
+        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();
@@ -155,6 +177,11 @@ export const selectionApi = (set, get) => ({
         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 {
@@ -173,25 +200,27 @@ export const selectionApi = (set, get) => ({
             if (graphicId !== undefined) {
                 const geomElem = container.map[graphicId];
                 if (geomElem) {
-                    return createGraphicItem(productId, 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: BuerliScope,
+        scope: exports.BuerliScope,
         label: (type[0] + type[1]).toUpperCase(),
     };
 };
-export const createGraphicItem = (productId, el) => {
+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;

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

@@ -0,0 +1,47 @@
+"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 __1 = require("../..");
+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(drawingId, selectorId, items) {
+    const items_ = items || __1.getDrawing(drawingId).selection.refs[selectorId].items;
+    items_.forEach(item => {
+        subscribeItem(drawingId, selectorId, item);
+    });
+}
+exports.subscribeItems = subscribeItems;
+function subscribeItem(drawingId, selectorId, item) {
+    if (item.removeCondition && !exports.unsubs[getId(selectorId, item.id)]) {
+        const selApi = __1.getDrawing(drawingId).api.selection;
+        exports.unsubs[getId(selectorId, item.id)] = subscribeToDrawing_1.subscribeToDrawing(drawingId, (d) => item.removeCondition && item.removeCondition(d), (removeCond) => {
+            var _a;
+            // Unselect item whose removeCondition got true
+            if (removeCond) {
+                const newItems = ((_a = __1.getDrawing(drawingId).selection.refs[selectorId]) === null || _a === void 0 ? void 0 : _a.items) || [];
+                selApi.setItems(selectorId, newItems.filter(item_ => item_.id !== item.id));
+            }
+        });
+    }
+}
+function unsubscribeItems(drawingId, selectorId, items) {
+    const items_ = items || __1.getDrawing(drawingId).selection.refs[selectorId].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];
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToDrawing = void 0;
+const store_1 = require("../store");
+function subscribeToDrawing(drawingId, sel, callback) {
+    const unsub = store_1.api.subscribe(callback, state => state.drawing.refs[drawingId] && sel(state.drawing.refs[drawingId]));
+    return unsub;
+}
+exports.subscribeToDrawing = subscribeToDrawing;

package/build/cjs/types/ErrorTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/IGraphicPackage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Primitives = exports.LineSegments = exports.Surfaces = exports.AllTypes = exports.GraphicType = void 0;
+var GraphicType;
+(function (GraphicType) {
+    GraphicType["POINT"] = "point";
+    GraphicType["LINE"] = "line";
+    GraphicType["EDGE"] = "edge";
+    GraphicType["ARC"] = "arc";
+    GraphicType["CIRCLE"] = "circle";
+    GraphicType["PLANE"] = "plane";
+    GraphicType["CYLINDER"] = "cylinder";
+    GraphicType["CONE"] = "cone";
+    GraphicType["SPHERE"] = "sphere";
+    GraphicType["NURBS"] = "nurbs";
+    GraphicType["NURBSSURFACE"] = "nurbsSurface";
+    GraphicType["LOOP"] = "loop";
+    GraphicType["SOLID"] = "solid";
+})(GraphicType = exports.GraphicType || (exports.GraphicType = {}));
+const G = GraphicType;
+exports.AllTypes = Object.keys(G).map(key => G[key]);
+exports.Surfaces = [G.PLANE, G.CYLINDER, G.CONE, G.SPHERE, G.NURBS, G.NURBSSURFACE];
+exports.LineSegments = [G.LINE, G.EDGE, G.ARC, G.CIRCLE];
+exports.Primitives = exports.Surfaces.concat(exports.LineSegments).concat([G.POINT]);

package/build/cjs/types/IStructurePatch.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/types/IStructureTree.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberType = exports.NOID = exports.DEFAULT_STRUCTURE_TREE = void 0;
+/**
+ * Defines the default structure tree.
+ * Should be used to initialize a new structure tree.
+ */
+const DEFAULT_STRUCTURE_TREE = () => {
+    return {
+        tree: {},
+        root: exports.NOID,
+        currentProduct: exports.NOID,
+        currentNode: exports.NOID,
+        testRoot: exports.NOID,
+    };
+};
+exports.DEFAULT_STRUCTURE_TREE = DEFAULT_STRUCTURE_TREE;
+/** Zero is no Id in classcad, and no object will exist in the CCDatabase for Id === 0! */
+exports.NOID = 0;
+var MemberType;
+(function (MemberType) {
+    MemberType["ARRAY"] = "array";
+    MemberType["ID"] = "id";
+    MemberType["POINT"] = "point";
+    MemberType["REAL"] = "real";
+    MemberType["STRING"] = "string";
+})(MemberType = exports.MemberType || (exports.MemberType = {}));

package/build/cjs/types/index.js

@@ -0,0 +1,16 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ErrorTypes"), exports);
+__exportStar(require("./IGraphicPackage"), exports);
+__exportStar(require("./IStructurePatch"), exports);
+__exportStar(require("./IStructureTree"), exports);

package/build/cjs/utils/Math.js

@@ -0,0 +1,33 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathUtils = void 0;
+const THREE = __importStar(require("three"));
+exports.MathUtils = {
+    convertToMatrix4: function (coordinateSystem) {
+        const [orig, vx, vy, vz] = coordinateSystem.map(row => new THREE.Vector3().fromArray(row));
+        return new THREE.Matrix4().makeBasis(vx, vy, vz).setPosition(orig);
+    },
+    convertToMatrix3: function (coordinateSystem) {
+        const [, vx, vy, vz] = coordinateSystem;
+        return new THREE.Matrix3().fromArray([...vx, ...vy, ...vz]);
+    },
+};