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

package/build/esm/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/esm/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/esm/store/states/buerli.js

@@ -1,9 +1,7 @@
 import { createDrawingState } from './drawing';
 import { getInitialMessageState } from './message';
 const initError = 'Please call the init action before you use the buerli store.';
-export const createState = (set, get, api) => ({
-    initDone: false,
-    options: {
+export const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
         url: '',
         elements: {},
         plugins: {},
@@ -18,18 +16,11 @@ export const createState = (set, get, api) => ({
         config: {
             geometry: {},
         },
-    },
-    drawing: {
+    }, drawing: {
         ids: [],
         refs: {},
         active: null,
-    },
-    api: {
-        ...generalApi(set, get),
-        ...drawingManagementApi(set, get, api),
-    },
-    ...getInitialMessageState(set, get, api),
-});
+    }, 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
     /**
@@ -39,7 +30,7 @@ const generalApi = (set, get) => ({
      * @param options - options which will be set into state.options
      */
     init(options) {
-        set(state => ({ options: { ...state.options, ...options }, initDone: true }));
+        set(state => ({ options: Object.assign(Object.assign({}, state.options), options), initDone: true }));
     },
 });
 const drawingManagementApi = (set, get, api) => ({
@@ -50,25 +41,11 @@ const drawingManagementApi = (set, get, api) => ({
         const drawingState = createDrawingState(sel => set(state => {
             const newState = typeof sel === 'function' ? sel(state.drawing.refs[drawingState.id]) : sel;
             return {
-                drawing: {
-                    ...state.drawing,
-                    refs: {
-                        ...state.drawing.refs,
-                        [drawingState.id]: {
-                            ...state.drawing.refs[drawingState.id],
-                            ...newState,
-                        },
-                    },
-                },
+                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) }) }),
             };
         }), () => get().drawing.refs[drawingState.id], api, drawing.ids.length, name);
         set(state => ({
-            drawing: {
-                ...state.drawing,
-                refs: { ...state.drawing.refs, [drawingState.id]: drawingState },
-                ids: [...state.drawing.ids, drawingState.id],
-                active: drawingState.id,
-            },
+            drawing: Object.assign(Object.assign({}, state.drawing), { refs: Object.assign(Object.assign({}, state.drawing.refs), { [drawingState.id]: drawingState }), ids: [...state.drawing.ids, drawingState.id], active: drawingState.id }),
         }));
         // Initialize global plugins
         get().options.globalPlugins.forEach(def => get().drawing.refs[drawingState.id].api.plugin.createPlugin(def));
@@ -96,21 +73,21 @@ const drawingManagementApi = (set, get, api) => ({
             const active = index >= 0 && state.drawing.active === id
                 ? state.drawing.ids[index + 1] || state.drawing.ids[index - 1] || null
                 : state.drawing.active;
-            return { drawing: { ...state.drawing, active } };
+            return { drawing: Object.assign(Object.assign({}, state.drawing), { active }) };
         });
         // 2.
         // Remove drawing from store.
         set(state => {
-            const refs = { ...state.drawing.refs };
+            const refs = Object.assign({}, state.drawing.refs);
             const ids = state.drawing.ids.filter(d => d !== id);
             delete refs[id];
-            return { drawing: { ...state.drawing, refs, ids } };
+            return { drawing: Object.assign(Object.assign({}, state.drawing), { refs, ids }) };
         });
     },
     setActiveDrawing(id) {
         const { initDone, drawing } = get();
         if (!initDone)
             throw new Error(initError);
-        set({ drawing: { ...drawing, active: id } });
+        set({ drawing: Object.assign(Object.assign({}, drawing), { active: id }) });
     },
 });

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

@@ -8,6 +8,6 @@ export const canvasData = () => ({
 // API
 ////////////////////////////////////////////////////
 export const canvasApi = (set, get) => ({
-    setInteraction: (isInteracting) => set(state => ({ canvas: { ...state.canvas, controls: { ...state.canvas.controls, isInteracting } } })),
-    setControlsEnabled: (enabled) => set(state => ({ canvas: { ...state.canvas, controls: { ...state.canvas.controls, enabled } } })),
+    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 }) }) })),
 });

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

@@ -26,7 +26,7 @@ export const geometryApi = (set, get) => ({
         const { api, structure } = get();
         if (structure.visibleContainers.length > 0) {
             const bb = api.structure.calculateProductBounds(structure.root);
-            set(state => ({ geometry: { ...state.geometry, stamp: Date.now(), bounds: bb } }));
+            set(state => ({ geometry: Object.assign(Object.assign({}, state.geometry), { stamp: Date.now(), bounds: bb }) }));
         }
     },
     createGeometryIfNotCached: (containerId, color) => {
@@ -37,13 +37,9 @@ export const geometryApi = (set, get) => ({
             if (container) {
                 geom = new ThreeGeometryCreator().createGeometry(container, color);
                 set(state => {
-                    const geometryCache = { ...state.geometry.cache, [containerId]: geom };
+                    const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: geom });
                     return {
-                        geometry: {
-                            ...state.geometry,
-                            cache: geometryCache,
-                            stamp: Date.now(),
-                        },
+                        geometry: Object.assign(Object.assign({}, state.geometry), { cache: geometryCache, stamp: Date.now() }),
                     };
                 });
             }
@@ -52,47 +48,39 @@ export const geometryApi = (set, get) => ({
     },
     setColor: (containerId, r, g, b) => {
         const thCol = new THREE.Color(r, g, b);
-        const cachedGeom = { ...get().geometry.cache[containerId] };
+        const cachedGeom = Object.assign({}, get().geometry.cache[containerId]);
         cachedGeom.color = thCol;
         cachedGeom.meshes.forEach(mesh => (mesh.color = thCol));
         set(state => ({
-            geometry: {
-                ...state.geometry,
-                cache: { ...state.geometry.cache, [containerId]: cachedGeom },
-                stamp: Date.now(),
-            },
+            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: cachedGeom }), stamp: Date.now() }),
         }));
     },
     setOpacity: (containerId, opacity) => {
-        const cachedGeom = { ...get().geometry.cache[containerId], opacity };
+        const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { opacity });
         cachedGeom.meshes.forEach(mesh => (mesh.opacity = opacity));
         set(state => ({
-            geometry: {
-                ...state.geometry,
-                cache: { ...state.geometry.cache, [containerId]: cachedGeom },
-                stamp: Date.now(),
-            },
+            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: cachedGeom }), stamp: Date.now() }),
         }));
     },
     setConfig: (objId, config) => {
         set(state => {
-            const productConfigs = { ...state.geometry.config.product };
+            const productConfigs = Object.assign({}, state.geometry.config.product);
             if (config) {
-                const newConfig = { ...state.geometry.config.product[objId] };
+                const newConfig = Object.assign({}, state.geometry.config.product[objId]);
                 if ('disabled' in config)
                     newConfig.disabled = config.disabled;
                 if ('edges' in config)
-                    newConfig.edges = { ...newConfig.edges, ...config.edges };
+                    newConfig.edges = Object.assign(Object.assign({}, newConfig.edges), config.edges);
                 if ('meshes' in config)
-                    newConfig.meshes = { ...newConfig.meshes, ...config.meshes };
+                    newConfig.meshes = Object.assign(Object.assign({}, newConfig.meshes), config.meshes);
                 if ('points' in config)
-                    newConfig.points = { ...newConfig.points, ...config.points };
+                    newConfig.points = Object.assign(Object.assign({}, newConfig.points), config.points);
                 productConfigs[objId] = newConfig;
             }
             else {
                 delete productConfigs[objId];
             }
-            return { geometry: { ...state.geometry, config: { ...state.geometry.config, product: productConfigs } } };
+            return { geometry: Object.assign(Object.assign({}, state.geometry), { config: Object.assign(Object.assign({}, state.geometry.config), { product: productConfigs }) }) };
         });
     },
 });

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

@@ -11,7 +11,7 @@ export const graphicApi = (set, get) => ({
     addPackages: (packages) => {
         // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
         let cacheChanged = false;
-        const newChache = { ...get().geometry.cache };
+        const newChache = Object.assign({}, get().geometry.cache);
         const addedContainers = {};
         packages.forEach(gr => {
             gr.containers.forEach(cont => {
@@ -25,8 +25,8 @@ export const graphicApi = (set, get) => ({
             });
         });
         set(state => ({
-            graphic: { ...state.graphic, containers: { ...state.graphic.containers, ...addedContainers } },
-            geometry: cacheChanged ? { ...state.geometry, cache: newChache, stamp: Date.now() } : state.geometry,
+            graphic: Object.assign(Object.assign({}, state.graphic), { containers: Object.assign(Object.assign({}, state.graphic.containers), addedContainers) }),
+            geometry: cacheChanged ? Object.assign(Object.assign({}, state.geometry), { cache: newChache, stamp: Date.now() }) : state.geometry,
         }));
         const { graphic, api } = get();
         /**
@@ -62,7 +62,7 @@ export const graphicApi = (set, get) => ({
                     usedContainers[contId] = existingContainers[contId];
                 }
             });
-            set({ graphic: { ...graphic, containers: usedContainers } });
+            set({ graphic: Object.assign(Object.assign({}, graphic), { containers: usedContainers }) });
             // console.log('graphicContainers after cleanup:', Object.getOwnPropertyNames(get().graphic.ontainers))
         }
         // cleanup the cached geometry depending on the uses solids
@@ -76,7 +76,7 @@ export const graphicApi = (set, get) => ({
                     usedGeometry[contId] = existingGeometry[contId];
                 }
             });
-            set({ geometry: { ...geometry, cache: usedGeometry, stamp: Date.now() } });
+            set({ geometry: Object.assign(Object.assign({}, geometry), { cache: usedGeometry, stamp: Date.now() }) });
         }
     },
 });

package/build/esm/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/esm/store/states/plugin.js

@@ -17,17 +17,11 @@ export const pluginApi = (set, get) => ({
             if (oldPlugin && state.plugin.active.feature !== id && !oldPlugin.persistent && id !== null) {
                 // Reset plugin-state when the plugin is re-activated, not persistent and has not been active all along
                 const initState = oldPlugin.initialState || {};
-                plugins = {
-                    ...plugins,
-                    [oldPlugin.id]: {
-                        ...oldPlugin,
-                        state: typeof initState === 'function' ? initState(get().id, id) : initState,
-                    },
-                };
+                plugins = Object.assign(Object.assign({}, plugins), { [oldPlugin.id]: Object.assign(Object.assign({}, oldPlugin), { state: typeof initState === 'function' ? initState(get().id, id) : initState }) });
             }
             return {
-                plugin: { ...state.plugin, active: { ...state.plugin.active, feature: id }, refs: plugins },
-                selection: { ...state.selection, active: null },
+                plugin: Object.assign(Object.assign({}, state.plugin), { active: Object.assign(Object.assign({}, state.plugin.active), { feature: id }), refs: plugins }),
+                selection: Object.assign(Object.assign({}, state.selection), { active: null }),
             };
         });
     },
@@ -37,10 +31,7 @@ export const pluginApi = (set, get) => ({
             if (visible)
                 filtered.push(id);
             return {
-                plugin: {
-                    ...currentState.plugin,
-                    visible: filtered,
-                },
+                plugin: Object.assign(Object.assign({}, currentState.plugin), { visible: filtered }),
             };
         });
     },
@@ -54,13 +45,7 @@ export const pluginApi = (set, get) => ({
             if (active)
                 filtered.push(id);
             return {
-                plugin: {
-                    ...currentState.plugin,
-                    active: {
-                        ...currentState.plugin.active,
-                        global: filtered,
-                    },
-                },
+                plugin: Object.assign(Object.assign({}, currentState.plugin), { active: Object.assign(Object.assign({}, currentState.plugin.active), { global: filtered }) }),
             };
         });
     },
@@ -72,42 +57,21 @@ export const pluginApi = (set, get) => ({
             const initialState = description.initialState || {};
             const localState = typeof initialState === 'function' ? initialState(drawingId, objectId) : initialState;
             set(currentState => {
-                const newPlugin = {
-                    id,
-                    ...description,
-                    drawingId,
-                    objectId,
-                    state: localState,
-                    Root,
-                    View,
-                    set: (sel) => {
+                const newPlugin = Object.assign(Object.assign({ id }, description), { drawingId,
+                    objectId, state: localState, Root,
+                    View, set: (sel) => {
                         // set function can be called when drawing doesn't exist anymore, in this case nothing should be done.
                         if (get() === undefined)
                             return;
                         set(state => {
                             const newState = typeof sel === 'function' ? sel(state.plugin.refs[id].state) : sel;
                             return {
-                                plugin: {
-                                    ...state.plugin,
-                                    refs: {
-                                        ...state.plugin.refs,
-                                        [id]: {
-                                            ...state.plugin.refs[id],
-                                            state: { ...state.plugin.refs[id].state, ...newState },
-                                        },
-                                    },
-                                },
+                                plugin: Object.assign(Object.assign({}, state.plugin), { refs: Object.assign(Object.assign({}, state.plugin.refs), { [id]: Object.assign(Object.assign({}, state.plugin.refs[id]), { state: Object.assign(Object.assign({}, state.plugin.refs[id].state), newState) }) }) }),
                             };
                         });
-                    },
-                };
+                    } });
                 return {
-                    plugin: {
-                        ...currentState.plugin,
-                        feature: description.global ? currentState.plugin.feature : [...currentState.plugin.feature, id],
-                        global: description.global ? [...currentState.plugin.global, id] : currentState.plugin.global,
-                        refs: { ...currentState.plugin.refs, [id]: { ...currentState.plugin.refs[id], ...newPlugin } },
-                    },
+                    plugin: Object.assign(Object.assign({}, currentState.plugin), { feature: description.global ? currentState.plugin.feature : [...currentState.plugin.feature, id], global: description.global ? [...currentState.plugin.global, id] : currentState.plugin.global, refs: Object.assign(Object.assign({}, currentState.plugin.refs), { [id]: Object.assign(Object.assign({}, currentState.plugin.refs[id]), newPlugin) }) }),
                 };
             });
         }
@@ -129,19 +93,10 @@ export const pluginApi = (set, get) => ({
             get &&
                 get() &&
                 set(state => {
-                    const newPlugins = { ...state.plugin.refs };
+                    const newPlugins = Object.assign({}, state.plugin.refs);
                     delete newPlugins[id];
                     return {
-                        plugin: {
-                            ...state.plugin,
-                            active: {
-                                ...state.plugin.active,
-                                feature: deactivate ? null : state.plugin.active.feature,
-                            },
-                            feature: state.plugin.feature.filter(pluginId => pluginId !== id),
-                            global: state.plugin.global.filter(pluginId => pluginId !== id),
-                            refs: newPlugins,
-                        },
+                        plugin: Object.assign(Object.assign({}, state.plugin), { active: Object.assign(Object.assign({}, state.plugin.active), { feature: deactivate ? null : state.plugin.active.feature }), feature: state.plugin.feature.filter(pluginId => pluginId !== id), global: state.plugin.global.filter(pluginId => pluginId !== id), refs: newPlugins }),
                     };
                 });
         };

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

@@ -17,10 +17,7 @@ export const selectionApi = (set, get) => ({
             set(state => {
                 const selector = state.selection.refs[activeSelector];
                 return {
-                    selection: {
-                        ...state.selection,
-                        refs: { ...state.selection.refs, [activeSelector]: { ...selector, items: [] } },
-                    },
+                    selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelector]: Object.assign(Object.assign({}, selector), { items: [] }) }) }),
                 };
             });
         }
@@ -43,16 +40,7 @@ export const selectionApi = (set, get) => ({
             else {
                 set(state => {
                     return {
-                        selection: {
-                            ...state.selection,
-                            refs: {
-                                ...state.selection.refs,
-                                [activeSelectorId]: {
-                                    ...state.selection.refs[activeSelectorId],
-                                    items: newItems,
-                                },
-                            },
-                        },
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelectorId]: Object.assign(Object.assign({}, state.selection.refs[activeSelectorId]), { items: newItems }) }) }),
                     };
                 });
             }
@@ -105,10 +93,7 @@ export const selectionApi = (set, get) => ({
                 unsubscribeItems(drawingId, activeSelectorId, unsubItems);
                 set(state => {
                     return {
-                        selection: {
-                            ...state.selection,
-                            refs: { ...state.selection.refs, [activeSelectorId]: { ...selector, items: result } },
-                        },
+                        selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [activeSelectorId]: Object.assign(Object.assign({}, selector), { items: result }) }) }),
                     };
                 });
             }
@@ -121,16 +106,7 @@ export const selectionApi = (set, get) => ({
             return;
         const selId = selection.active || selectorId;
         set(state => ({
-            selection: {
-                ...state.selection,
-                refs: {
-                    ...state.selection.refs,
-                    [selId]: {
-                        ...state.selection.refs[selId],
-                        hoveredItem: item,
-                    },
-                },
-            },
+            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) {
@@ -139,19 +115,10 @@ export const selectionApi = (set, get) => ({
             const curSelectorId = state.selection.active;
             if (curSelectorId) {
                 // Reset hoveredItem
-                refs[curSelectorId] = {
-                    ...refs[curSelectorId],
-                    hoveredItem: null,
-                };
+                refs[curSelectorId] = Object.assign(Object.assign({}, refs[curSelectorId]), { hoveredItem: null });
             }
             return {
-                selection: {
-                    ...state.selection,
-                    active: state.selection.active === selectorId ? null : selectorId,
-                    refs: {
-                        ...refs,
-                    },
-                },
+                selection: Object.assign(Object.assign({}, state.selection), { active: state.selection.active === selectorId ? null : selectorId, refs: Object.assign({}, refs) }),
             };
         });
     },
@@ -159,21 +126,14 @@ export const selectionApi = (set, get) => ({
         if (maxLen > 0 && initialItems.length > maxLen)
             console.error('Number initialItems should be less or equal to selector.maxLen');
         set(state => ({
-            selection: {
-                ...state.selection,
-                active: activate ? selectorId : state.selection.active,
-                refs: {
-                    ...state.selection.refs,
-                    [selectorId]: {
+            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()) {
@@ -183,11 +143,7 @@ export const selectionApi = (set, get) => ({
                     const refs = state.selection.refs;
                     delete refs[selectorId];
                     return {
-                        selection: {
-                            ...state.selection,
-                            active: state.selection.active === selectorId ? null : state.selection.active,
-                            refs,
-                        },
+                        selection: Object.assign(Object.assign({}, state.selection), { active: state.selection.active === selectorId ? null : state.selection.active, refs }),
                     };
                 });
             }
@@ -217,14 +173,15 @@ 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 = selection.refs[id]?.items || [];
+        const curItems = ((_a = selection.refs[id]) === null || _a === void 0 ? void 0 : _a.items) || [];
         unsubscribeItems(drawingId, id, curItems);
         subscribeItems(drawingId, id, items);
         set(state => {
             const selector = state.selection.refs[id];
             return {
-                selection: { ...state.selection, refs: { ...state.selection.refs, [id]: { ...selector, items } } },
+                selection: Object.assign(Object.assign({}, state.selection), { refs: Object.assign(Object.assign({}, state.selection.refs), { [id]: Object.assign(Object.assign({}, selector), { items }) }) }),
             };
         });
     },
@@ -257,13 +214,7 @@ const createGraphicIdent = (productId, graphicId, type) => {
     };
 };
 export const createGraphicItem = (productId, el) => {
-    return {
-        ...createGraphicIdent(productId, el.graphicId, el.type),
-        data: {
-            ...el,
-            productId,
-        },
-    };
+    return Object.assign(Object.assign({}, createGraphicIdent(productId, el.graphicId, el.type)), { data: Object.assign(Object.assign({}, el), { productId }) });
 };
 //#endregion GLOBAL FUNCTIONS
 ////////////////////////////////////////////////////

package/build/esm/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/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));
             }
         });

package/build/esm/utils/Measure.js

@@ -18,7 +18,7 @@ export const Measure = {
         for (const item of items) {
             const matrix = drawing.api.structure.calculateGlobalTransformation(item.productId);
             const matrix3 = new THREE.Matrix3().setFromMatrix4(matrix);
-            const newItem = { ...item };
+            const newItem = Object.assign({}, item);
             switch (newItem.type) {
                 case GraphicType.POINT:
                     const point = newItem;

package/build/esm/utils/Timing.js

@@ -9,7 +9,7 @@ const measure = (key, mode = 'fromStart') => {
         return Number.NaN;
     const curr = performance.now();
     const prev = mode === 'fromPrevious' ? cache[key].previousTime : cache[key].startTime;
-    cache[key] = { ...cache[key], previousTime: curr };
+    cache[key] = Object.assign(Object.assign({}, cache[key]), { previousTime: curr });
     return curr - prev;
 };
 const stop = (key) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buerli.io/core",
-  "version": "0.0.35-beta.0",
+  "version": "0.0.35-beta.1",
   "description": "buerli state management",
   "author": "AWV Informatik AG <info@awv-informatik.ch>",
   "repository": {},
@@ -14,7 +14,7 @@
     "clean": "rimraf ./build && rimraf ./coverage",
     "build": "npm run build:esm -- --sourceMap true --declaration true --declarationDir ./build/types",
     "build:dist": "npm run clean && npm run build:esm && npm run build:cjs && npm run build:types && echo DONE",
-    "build:esm": "tsc --target es2020 --module esNext --declaration false --declarationDir null --sourceMap false --outDir ./build/esm",
+    "build:esm": "tsc --target es2017 --module esNext --declaration false --declarationDir null --sourceMap false --outDir ./build/esm",
     "build:cjs": "tsc --target es2017 --module commonjs --declaration false --declarationDir null --sourceMap false --outDir ./build/cjs",
     "build:types": "tsc --declaration --emitDeclarationOnly --outDir ./build/types",
     "lint": "eslint \"./src/**/*.ts?(x)\"",