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

package/build/{esm/geometry → geometry}/ThreeGeometryCreator.js

@@ -65,17 +65,14 @@ export class ThreeGeometryCreator {
             });
         }
         const points = Object.values(pointMap);
-        return {
-            graphicId,
+        return Object.assign({ graphicId,
             map,
             meshes,
             lines,
             edges,
             arcs,
             points,
-            box,
-            ...this.getMetadata(null, container, color),
-        };
+            box }, this.getMetadata(null, container, color));
     }
     createSurface(mesh, container, color = [0, 0, 0]) {
         let meshGeom = this.createMesh(mesh, container, color);
@@ -103,41 +100,38 @@ export class ThreeGeometryCreator {
         geometry.setIndex(mesh.indices);
         geometry.setAttribute('position', new THREE.Float32BufferAttribute(mesh.vertices, 3));
         mesh.normals && geometry.setAttribute('normal', new THREE.Float32BufferAttribute(mesh.normals, 3));
-        return {
+        return Object.assign({ 
             // TODO: The server should not send invalid meshes.
-            isValid: mesh.vertices && mesh.vertices.length > 0,
-            geometry,
+            isValid: mesh.vertices && mesh.vertices.length > 0, geometry,
             graphicId,
             type,
-            loops,
-            ...this.getMetadata(mesh, container, color),
-        };
+            loops }, this.getMetadata(mesh, container, color));
     }
     createPlane(mesh, meshGeom) {
         const type = GraphicType.PLANE;
         const { normal: n, pointOnPlane: p } = mesh.properties.surface;
         const pointOnPlane = new THREE.Vector3(p[0], p[1], p[2]);
         const normal = new THREE.Vector3(n[0], n[1], n[2]).normalize();
-        return { ...meshGeom, type, pointOnPlane, normal };
+        return Object.assign(Object.assign({}, meshGeom), { type, pointOnPlane, normal });
     }
     createCylinder(mesh, meshGeom) {
         const type = GraphicType.CYLINDER;
         const { origin: o, axis: a, height, radius } = mesh.properties.surface;
         const origin = new THREE.Vector3(o[0], o[1], o[2]);
         const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
-        return { ...meshGeom, type, origin, axis, height, radius };
+        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radius });
     }
     createCone(mesh, meshGeom) {
         const type = GraphicType.CONE;
         const { origin: o, axis: a, height, radiusBottom, radiusTop } = mesh.properties.surface;
         const origin = new THREE.Vector3(o[0], o[1], o[2]);
         const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
-        return { ...meshGeom, type, origin, axis, height, radiusBottom, radiusTop };
+        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radiusBottom, radiusTop });
     }
     createSphere(mesh, meshGeom) {
         const type = GraphicType.SPHERE;
         const { radius } = mesh.properties.surface;
-        return { ...meshGeom, type, radius };
+        return Object.assign(Object.assign({}, meshGeom), { type, radius });
     }
     createLine(line, container, points, color = [0, 0, 0]) {
         const graphicId = line.id;
@@ -149,14 +143,9 @@ export class ThreeGeometryCreator {
         this.insertPoint(container, `${startId}|point`, startId, start.clone(), line.id, 'start', points);
         this.insertPoint(container, `${endId}|point`, endId, end.clone(), line.id, 'end', points);
         const geometry = new THREE.BufferGeometry().setFromPoints([start.clone(), end.clone()]);
-        return {
-            geometry,
+        return Object.assign(Object.assign({ geometry,
             graphicId,
-            type,
-            ...this.getMetadata(line, container, color),
-            start: start.clone(),
-            end: end.clone(),
-        };
+            type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
     }
     createEdge(edge, container, points, color = [0, 0, 0]) {
         const threePts = [];
@@ -182,14 +171,9 @@ export class ThreeGeometryCreator {
         this.insertPoint(container, `${startId}|point`, startId, start, edge.id, 'start', points);
         this.insertPoint(container, `${endId}|point`, endId, end, edge.id, 'end', points);
         const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
-        return {
-            geometry,
+        return Object.assign(Object.assign({ geometry,
             graphicId,
-            type,
-            ...this.getMetadata(edge, container, color),
-            start: start.clone(),
-            end: end.clone(),
-        };
+            type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
     }
     createArc(arc, container, points, color = [0, 0, 0]) {
         const graphicId = arc.id;
@@ -233,27 +217,13 @@ export class ThreeGeometryCreator {
         this.insertPoint(container, `${startId}|point`, startId, start, arc.id, 'start', points);
         this.insertPoint(container, `${endId}|point`, endId, end, arc.id, 'end', points);
         const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
-        return {
-            geometry,
+        return Object.assign(Object.assign({ geometry,
             graphicId,
-            type,
-            ...this.getMetadata(arc, container, color),
-            normal: normal.clone(),
-            center: center.clone(),
-            radius: arc.radius,
-            angle: arc.angle,
-        };
+            type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), radius: arc.radius, angle: arc.angle });
     }
     createPoint(container, key, graphicId, position, ownerId, type) {
-        return {
-            key,
-            graphicId,
-            type: GraphicType.POINT,
-            ...this.getMetadata(null, container),
-            position: position.clone(),
-            geometry: position.clone(),
-            owners: [{ ownerId, type }],
-        };
+        return Object.assign(Object.assign({ key,
+            graphicId, type: GraphicType.POINT }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
     }
     insertPoint(container, key, graphicId, position, ownerId, type, points) {
         const existingPoint = points[key];

package/build/index.d.ts

@@ -0,0 +1,36 @@
+export * from './store';
+export * from './geometry';
+export * from './types';
+export * from './utils/Math';
+export * from './utils/Measure';
+export * from './utils/Timing';
+export * from './store/subscribtion/subscribeToDrawing';
+/**
+ * Because babel typescript tools can not handle the type definitions
+ * in an other way, they have to be re-exported as you can see in this code region.
+ *
+ * Please have a look at https://github.com/awv-informatik/buerli/pull/129 for more information.
+ */
+import { BuerliState as BS } from './store/states/buerli';
+export declare type BuerliState = BS;
+import { DrawingAPI as DrawingAPI1, DrawingID as DrawingID1, DrawingState as DrawingState1 } from './store/states/drawing';
+export declare type DrawingID = DrawingID1;
+export declare type DrawingState = DrawingState1;
+export declare type DrawingAPI = DrawingAPI1;
+import { GeometryConfig as GeometryConfig1, GeometryBounds as GeometryBounds1 } from './store/states/geometry';
+export declare type GeometryConfig = GeometryConfig1;
+export declare type GeometryBounds = GeometryBounds1;
+import { Plugin as Plugin1, PluginDescription as PluginDescription1, PluginID as PluginID1, PluginState as PluginState1 } from './store/states/plugin';
+export declare type Plugin = Plugin1;
+export declare type PluginDescription<InternalState = any> = PluginDescription1<InternalState>;
+export declare type PluginID = PluginID1;
+export declare type PluginState<InternalState = any> = PluginState1<InternalState>;
+import { SeletedItemData, SelectedItem as SelectedItem1, SelectionFilter as SelectionFilter1, SelectionScope as SelectionScope1, Selector as Selector1, SelectorID as SelectorID1, CustomSelect as CustomSelect1 } from './store/states/selection';
+export declare type SelectedItem<T extends SeletedItemData<any> = any> = SelectedItem1<T>;
+export declare type SelectionFilter = SelectionFilter1;
+export declare type SelectionScope = SelectionScope1;
+export declare type Selector<T extends SeletedItemData<any> = any> = Selector1<T>;
+export declare type SelectorID = SelectorID1;
+export declare type CustomSelect = CustomSelect1;
+import { Message as Message1 } from './store/states/message';
+export declare type Message = Message1;

package/build/{esm/store → store}/index.js

@@ -7,8 +7,9 @@ function getDrawing(id) {
  * @returns PluginState or undefined if either drawing or plugin don't exist
  */
 function getPlugin(drawingId, pluginId) {
+    var _a;
     const { drawing } = api.getState();
-    return drawing.refs[drawingId]?.plugin.refs[pluginId];
+    return (_a = drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.plugin.refs[pluginId];
 }
 function init(sel) {
     api.getState().api.init(typeof sel === 'function' ? sel(api.getState()) || {} : sel);

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createState = void 0;
-const drawing_1 = require("./drawing");
-const message_1 = require("./message");
+import { createDrawingState } from './drawing';
+import { getInitialMessageState } from './message';
 const initError = 'Please call the init action before you use the buerli store.';
-const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
+export const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
         url: '',
         elements: {},
         plugins: {},
@@ -23,8 +20,7 @@ const createState = (set, get, api) => (Object.assign({ initDone: false, options
         ids: [],
         refs: {},
         active: null,
-    }, api: Object.assign(Object.assign({}, generalApi(set, get)), drawingManagementApi(set, get, api)) }, message_1.getInitialMessageState(set, get, api)));
-exports.createState = createState;
+    }, api: Object.assign(Object.assign({}, generalApi(set, get)), drawingManagementApi(set, get, api)) }, getInitialMessageState(set, get, api)));
 const generalApi = (set, get) => ({
     // TODO: rename init to setOptions and remove initDone if everything is ok
     /**
@@ -42,7 +38,7 @@ const drawingManagementApi = (set, get, api) => ({
         const { initDone, drawing } = get();
         if (!initDone)
             throw new Error(initError);
-        const drawingState = drawing_1.createDrawingState(sel => set(state => {
+        const drawingState = createDrawingState(sel => set(state => {
             const newState = typeof sel === 'function' ? sel(state.drawing.refs[drawingState.id]) : sel;
             return {
                 drawing: Object.assign(Object.assign({}, state.drawing), { refs: Object.assign(Object.assign({}, state.drawing.refs), { [drawingState.id]: Object.assign(Object.assign({}, state.drawing.refs[drawingState.id]), newState) }) }),

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

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.canvasApi = exports.canvasData = void 0;
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
-const canvasData = () => ({
+export const canvasData = () => ({
     controls: { isInteracting: false, enabled: true },
 });
-exports.canvasData = canvasData;
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-const canvasApi = (set, get) => ({
+export const canvasApi = (set, get) => ({
     setInteraction: (isInteracting) => set(state => ({ canvas: Object.assign(Object.assign({}, state.canvas), { controls: Object.assign(Object.assign({}, state.canvas.controls), { isInteracting }) }) })),
     setControlsEnabled: (enabled) => set(state => ({ canvas: Object.assign(Object.assign({}, state.canvas), { controls: Object.assign(Object.assign({}, state.canvas.controls), { enabled }) }) })),
 });
-exports.canvasApi = canvasApi;

package/build/{types/store → store}/states/drawing.d.ts

@@ -22,6 +22,7 @@ export declare type DrawingAPI = {
     geometry: GeometryApi;
     graphic: GraphicApi;
     canvas: CanvasApi;
+    setCustom: (key: string, value: Record<string, any>) => void;
 };
 declare type StateData = {
     id: DrawingID;
@@ -32,6 +33,7 @@ declare type StateData = {
     canvas: CanvasData;
     selection: SelectionData;
     plugin: PluginData;
+    custom: any;
 };
 export declare type DrawingState = Readonly<StateData> & Readonly<{
     api: DrawingAPI;

package/build/{esm/store → store}/states/drawing.js

@@ -26,6 +26,7 @@ export const createDrawingState = (set, get, api, drawingNumber, name) => {
         geometry: geometryData(),
         graphic: graphicData(),
         canvas: canvasData(),
+        custom: {},
         api: {
             structure: structureApi(set, get),
             selection: selectionApi(set, get),
@@ -33,6 +34,9 @@ export const createDrawingState = (set, get, api, drawingNumber, name) => {
             geometry: geometryApi(set, get),
             graphic: graphicApi(set, get),
             canvas: canvasApi(set, get),
+            setCustom: (key, value) => {
+                set(state => (Object.assign(Object.assign({}, state), { custom: Object.assign(Object.assign({}, state.custom), { [key]: Object.assign(Object.assign({}, state.custom[key]), value) }) })));
+            },
         },
         id: drawingId,
         name: name || `Drawing #${drawingNumber}`,

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

@@ -1,31 +1,9 @@
-"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.geometryApi = exports.geometryData = void 0;
-const THREE = __importStar(require("three"));
-const ThreeGeometryCreator_1 = require("../../geometry/ThreeGeometryCreator");
+import * as THREE from 'three';
+import { ThreeGeometryCreator } from '../../geometry/ThreeGeometryCreator';
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
-const geometryData = () => ({
+export const geometryData = () => ({
     cache: {},
     stamp: -1,
     bounds: {
@@ -36,11 +14,10 @@ const geometryData = () => ({
     },
     config: { product: {} },
 });
-exports.geometryData = geometryData;
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-const geometryApi = (set, get) => ({
+export const geometryApi = (set, get) => ({
     /**
      * Updates the @see geometry.bounds depending on all products of the model.
      * The update will only happen, if at least one solid of one product is available.
@@ -58,7 +35,7 @@ const geometryApi = (set, get) => ({
         if (!geom) {
             const container = graphic.containers[containerId];
             if (container) {
-                geom = new ThreeGeometryCreator_1.ThreeGeometryCreator().createGeometry(container, color);
+                geom = new ThreeGeometryCreator().createGeometry(container, color);
                 set(state => {
                     const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: geom });
                     return {
@@ -107,4 +84,3 @@ const geometryApi = (set, get) => ({
         });
     },
 });
-exports.geometryApi = geometryApi;

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

@@ -1,17 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphicApi = exports.graphicData = void 0;
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
-const graphicData = () => ({
+export const graphicData = () => ({
     containers: {},
 });
-exports.graphicData = graphicData;
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-const graphicApi = (set, get) => ({
+export const graphicApi = (set, get) => ({
     addPackages: (packages) => {
         // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
         let cacheChanged = false;
@@ -84,4 +80,3 @@ const graphicApi = (set, get) => ({
         }
     },
 });
-exports.graphicApi = graphicApi;

package/build/{esm/store → store}/states/message.js

@@ -11,11 +11,11 @@ const messageApi = (set, get, api) => ({
     show(message) {
         const newId = uuidv4();
         const msg = get().message;
-        set({ message: { ...msg, data: { id: newId, ...message }, timestamp: Date.now() } });
+        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: { ...msg, data: { id, ...message }, timestamp: Date.now() } });
+        set({ message: Object.assign(Object.assign({}, msg), { data: Object.assign({ id }, message), timestamp: Date.now() }) });
     },
 });

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromisePlugin = exports.pluginApi = exports.pluginData = void 0;
-const uuid_1 = require("uuid");
-const pluginData = () => ({
+import { v4 as uuidv4 } from 'uuid';
+export const pluginData = () => ({
     feature: [],
     global: [],
     refs: {},
@@ -12,8 +9,7 @@ const pluginData = () => ({
     },
     visible: [],
 });
-exports.pluginData = pluginData;
-const pluginApi = (set, get) => ({
+export const pluginApi = (set, get) => ({
     setActiveFeature: (id) => {
         set(state => {
             let plugins = state.plugin.refs;
@@ -55,7 +51,7 @@ const pluginApi = (set, get) => ({
     },
     // TODO remove defaultId and useEmbeddedPlugin ?
     createPlugin: (def, defaultId, drawingId, objectId) => {
-        const id = defaultId !== void 0 ? defaultId : uuid_1.v4();
+        const id = defaultId !== void 0 ? defaultId : uuidv4();
         function init(definition) {
             const { description, Root = null, View = null } = definition;
             const initialState = description.initialState || {};
@@ -106,8 +102,6 @@ const pluginApi = (set, get) => ({
         };
     },
 });
-exports.pluginApi = pluginApi;
-function isPromisePlugin(def) {
+export function isPromisePlugin(def) {
     return def.then !== undefined;
 }
-exports.isPromisePlugin = isPromisePlugin;

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

@@ -1,23 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGraphicItem = exports.selectionApi = exports.selectionData = exports.BuerliScope = void 0;
-const selection_1 = require("../subscribtion/selection");
+import { subscribeItems, unsubscribeItems } from '../subscribtion/selection';
 ////////////////////////////////////////////////////
 // CONSTANTS
 ////////////////////////////////////////////////////
-exports.BuerliScope = 'ClassCAD';
-const selectionData = () => ({
+export const BuerliScope = 'ClassCAD';
+export const selectionData = () => ({
     refs: {},
     active: null,
 });
-exports.selectionData = selectionData;
-const selectionApi = (set, get) => ({
+export 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);
+            unsubscribeItems(drawingId, activeSelector, unselItems);
             set(state => {
                 const selector = state.selection.refs[activeSelector];
                 return {
@@ -33,7 +29,7 @@ const selectionApi = (set, get) => ({
             // 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);
+            unsubscribeItems(drawingId, activeSelectorId, unselItems);
             if (selector.customUnSelect) {
                 // Find recently unselected items
                 const diff = selector.items.filter(item1 => {
@@ -92,9 +88,9 @@ const selectionApi = (set, get) => ({
             }
             else {
                 // subscribe items which will be selected
-                selection_1.subscribeItems(drawingId, activeSelectorId, result);
+                subscribeItems(drawingId, activeSelectorId, result);
                 // unsubscribe items which will be unselected
-                selection_1.unsubscribeItems(drawingId, activeSelectorId, unsubItems);
+                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 }) }) }),
@@ -142,7 +138,7 @@ const selectionApi = (set, get) => ({
         return () => {
             if (get && get()) {
                 const drawingId = get().id;
-                selection_1.unsubscribeItems(drawingId, selectorId);
+                unsubscribeItems(drawingId, selectorId);
                 set(state => {
                     const refs = state.selection.refs;
                     delete refs[selectorId];
@@ -180,8 +176,8 @@ const selectionApi = (set, get) => ({
         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);
+        unsubscribeItems(drawingId, id, curItems);
+        subscribeItems(drawingId, id, items);
         set(state => {
             const selector = state.selection.refs[id];
             return {
@@ -200,27 +196,25 @@ const selectionApi = (set, get) => ({
             if (graphicId !== undefined) {
                 const geomElem = container.map[graphicId];
                 if (geomElem) {
-                    return exports.createGraphicItem(productId, geomElem);
+                    return 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,
+        scope: BuerliScope,
         label: (type[0] + type[1]).toUpperCase(),
     };
 };
-const createGraphicItem = (productId, el) => {
+export 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/{esm/store → store}/states/structure.js

@@ -6,7 +6,7 @@ import { MathUtils } from '../../utils/Math';
 // DATA
 ////////////////////////////////////////////////////
 export const structureData = () => {
-    return { ...DEFAULT_STRUCTURE_TREE(), visibleContainers: [], products: [] };
+    return Object.assign(Object.assign({}, DEFAULT_STRUCTURE_TREE()), { visibleContainers: [], products: [] });
 };
 ////////////////////////////////////////////////////
 // API
@@ -20,10 +20,7 @@ export const structureApi = (set, get) => ({
         // TODO: clear object selection if needed
         // 1. set the state
         set({
-            structure: {
-                ...get().structure,
-                ...structure,
-            },
+            structure: Object.assign(Object.assign({}, get().structure), structure),
         });
         // 2. collect and cleanup data
         api.graphic.cleanupGraphicRecords();
@@ -42,10 +39,7 @@ export const structureApi = (set, get) => ({
                 console.error(e);
             }
             return {
-                structure: {
-                    ...get().structure,
-                    ...structure,
-                },
+                structure: Object.assign(Object.assign({}, get().structure), structure),
             };
         });
         const { api } = get();
@@ -122,7 +116,7 @@ export const structureApi = (set, get) => ({
         // 3. Add the result to the state
         //////////
         set(state => ({
-            structure: { ...state.structure, visibleContainers: solidIds, products: productIds },
+            structure: Object.assign(Object.assign({}, state.structure), { visibleContainers: solidIds, products: productIds }),
         }));
     },
     /**

package/build/{esm/store → store}/subscribtion/selection.js

@@ -16,9 +16,10 @@ function subscribeItem(drawingId, selectorId, item) {
     if (item.removeCondition && !unsubs[getId(selectorId, item.id)]) {
         const selApi = getDrawing(drawingId).api.selection;
         unsubs[getId(selectorId, item.id)] = subscribeToDrawing(drawingId, (d) => item.removeCondition && item.removeCondition(d), (removeCond) => {
+            var _a;
             // Unselect item whose removeCondition got true
             if (removeCond) {
-                const newItems = getDrawing(drawingId).selection.refs[selectorId]?.items || [];
+                const newItems = ((_a = getDrawing(drawingId).selection.refs[selectorId]) === null || _a === void 0 ? void 0 : _a.items) || [];
                 selApi.setItems(selectorId, newItems.filter(item_ => item_.id !== item.id));
             }
         });