@buerli.io/core 0.5.0-beta.1 → 0.5.0-beta.2

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

@@ -0,0 +1,258 @@
+"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, buerliApi) => ({
+    unselectAll(selectorId) {
+        const { selection, id: drawingId } = get();
+        const selId = (selectorId || selection.active);
+        if (selId) {
+            const unselItems = selection.refs[selId].items;
+            (0, selection_1.unsubscribeItems)(buerliApi, drawingId, selId, unselItems);
+            set(state => {
+                const selector = state.selection.refs[selId];
+                return {
+                    selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, selector), { items: [] }) }) }),
+                };
+            });
+        }
+    },
+    unselect(items, selectorId) {
+        const { selection, id: drawingId } = get();
+        const selId = (selectorId || selection.active);
+        if (selId) {
+            const unselItems = Array.isArray(items) ? items : [items];
+            // Remove unselItems from selector's items
+            const selector = selection.refs[selId];
+            const newItems = selector.items.filter(item => unselItems.find(uItem => uItem.id === item.id) === undefined);
+            (0, selection_1.unsubscribeItems)(buerliApi, drawingId, selId, 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(selId, newItems, diff);
+            }
+            else {
+                set(state => {
+                    return {
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, state.selection.refs[selId]), { items: newItems }) }) }),
+                    };
+                });
+            }
+            this.setHovered(null, selId);
+        }
+    },
+    select(items, selectorId) {
+        const { selection, api, id: drawingId } = get();
+        const selId = (selectorId || selection.active);
+        if (selId) {
+            const { isItemSelected } = api.selection;
+            const newItems = Array.isArray(items) ? items : [items];
+            const selector = selection.refs[selId];
+            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, selId));
+            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(selId, result, diff);
+            }
+            else {
+                // subscribe items which will be selected
+                (0, selection_1.subscribeItems)(buerliApi, drawingId, selId, result);
+                // unsubscribe items which will be unselected
+                (0, selection_1.unsubscribeItems)(buerliApi, drawingId, selId, unsubItems);
+                set(state => {
+                    return {
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [selId]: Object.assign(Object.assign({}, selector), { items: result, hoveredItem: null }) }) }),
+                    };
+                });
+            }
+        }
+    },
+    setHovered(item, selectorId) {
+        const { selection } = get();
+        if (selection.active === null && selectorId === undefined)
+            return;
+        const selId = (selectorId || selection.active);
+        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;
+                (0, selection_1.unsubscribeItems)(buerliApi, 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 = (selectorId || selection.active);
+        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 = (selectorId || selection.active);
+        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) || [];
+        (0, selection_1.unsubscribeItems)(buerliApi, drawingId, id, curItems);
+        (0, selection_1.subscribeItems)(buerliApi, 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 }) }) }),
+            };
+        });
+    },
+    selectGraphic: (selectorId, items, options) => {
+        const { api } = get();
+        const selItems = items
+            .map(i => api.selection.getGraphicItem(i.productId, i.containerId, i.graphicId))
+            .filter(i => Boolean(i));
+        if (options === null || options === void 0 ? void 0 : options.unselectExisting) {
+            api.selection.setItems(selectorId, selItems);
+        }
+        else {
+            api.selection.select(selItems, selectorId);
+        }
+    },
+    getGraphicItem: (productId, containerId, graphicId) => {
+        const { cache } = get().geometry;
+        const container = cache[containerId];
+        let useContainer = false;
+        if (container) {
+            if (graphicId === undefined) {
+                const ids = Object.getOwnPropertyNames(container.map);
+                graphicId = ids.length > 0 ? Number(ids[0]) : undefined;
+                useContainer = true;
+            }
+            if (graphicId !== undefined) {
+                let geomElem = container.map[graphicId];
+                if (!geomElem) {
+                    geomElem = container.points.find(p => p.graphicId === graphicId);
+                }
+                if (geomElem) {
+                    geomElem.graphicId = useContainer ? containerId : geomElem.graphicId;
+                    geomElem.type = useContainer ? container.type : geomElem.type;
+                    return (0, 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 getLabel = (type) => {
+    const uppLetters = type.replace(/[a-z]/g, '');
+    if (uppLetters.length >= 2) {
+        return uppLetters[0] + uppLetters[1];
+    }
+    else if (uppLetters.length === 1) {
+        return (type[0] + uppLetters[0]).toUpperCase();
+    }
+    else {
+        return (type[0] + type[1]).toUpperCase();
+    }
+};
+const createGraphicIdent = (productId, graphicId, type) => {
+    return {
+        id: `${productId}|${graphicId}|${type}`,
+        scope: exports.BuerliScope,
+        label: getLabel(type),
+    };
+};
+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,239 @@
+"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 = [];
+        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,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);

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

@@ -0,0 +1,46 @@
+"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) {
+    const items_ = items || buerliApi.getState().drawing.refs[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,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToDrawing = void 0;
+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;
+}
+exports.subscribeToDrawing = subscribeToDrawing;

package/build/cjs/types/IGraphicPackage.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointTypes = exports.EntityTypes = exports.CurveSegments = exports.Primitives = exports.LineSegments = exports.Surfaces = exports.AllTypes = exports.ContainerType = exports.GraphicType = void 0;
+var GraphicType;
+(function (GraphicType) {
+    // Primitives
+    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";
+    // Entities
+    GraphicType["NONE"] = "none";
+    GraphicType["BREP"] = "brep";
+    GraphicType["POLYBREP"] = "polyBrep";
+    GraphicType["CURVEARRAY"] = "curveArray";
+    // Curve array elements
+    GraphicType["CURVELINE"] = "curveLine";
+    GraphicType["CURVESPLINE"] = "curveSpline";
+    GraphicType["CURVEARC"] = "curveArc";
+    GraphicType["CURVECIRCLE"] = "curveCircle";
+    GraphicType["CURVEPOINT"] = "curvePoint";
+    // Custom type(s) (not defined by server protocol)
+    GraphicType["LOOP"] = "loop";
+})(GraphicType = exports.GraphicType || (exports.GraphicType = {}));
+var ContainerType;
+(function (ContainerType) {
+    ContainerType[ContainerType["NONE"] = 0] = "NONE";
+    ContainerType[ContainerType["BREP"] = 1] = "BREP";
+    ContainerType[ContainerType["CURVEARRAY"] = 2] = "CURVEARRAY";
+    ContainerType[ContainerType["POLYBREP"] = 3] = "POLYBREP";
+    // POINTARRAY = 4, // Not used at the moment
+    // GRAPHIC = 5, // Not used at the moment
+    // LIGHTWEIGHTBREP = 6, // Not used at the moment
+})(ContainerType = exports.ContainerType || (exports.ContainerType = {}));
+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]);
+exports.CurveSegments = [G.CURVELINE, G.CURVESPLINE, G.CURVEARC, G.CURVECIRCLE];
+exports.EntityTypes = [G.BREP, G.POLYBREP, G.CURVEARRAY];
+exports.PointTypes = [G.POINT, G.CURVEPOINT];

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/InteractionInfo.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUniqueIdent = exports.createInfo = void 0;
+const createInfo = (data) => {
+    return Object.assign({ uniqueIdent: (0, exports.createUniqueIdent)(data) }, data);
+};
+exports.createInfo = createInfo;
+const createUniqueIdent = (data) => {
+    return `${[data.prodRefId, data.objectId, data.containerId, data.graphicId]}`;
+};
+exports.createUniqueIdent = createUniqueIdent;