@buerli.io/core 1.0.1 → 1.1.0-beta.7

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

@@ -1,129 +1,129 @@
-import * as THREE from 'three';
-import { ThreeGeometryCreator } from '../../geometry/ThreeGeometryCreator';
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-export const geometryData = () => ({
-    cache: {},
-    stamp: -1,
-    bounds: {
-        center: new THREE.Vector3(0, 0, 0),
-        radius: 200,
-        min: new THREE.Vector3(-100, -100, -100),
-        max: new THREE.Vector3(100, 100, 100),
-    },
-    config: { product: {} },
-});
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-export const geometryApi = (set, get, buerliApi) => ({
-    /**
-     * 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.
-     */
-    updateBounds: () => {
-        const { api, structure } = get();
-        if (structure.visibleContainers.length > 0) {
-            const bb = api.structure.calculateProductBounds(structure.root);
-            set(state => ({ geometry: Object.assign(Object.assign({}, state.geometry), { stamp: Date.now(), bounds: bb }) }));
-        }
-    },
-    createGeometryIfNotCached: (containerId, color) => {
-        const { graphic, geometry } = get();
-        let geom = geometry.cache[containerId];
-        if (!geom) {
-            const container = graphic.containers[containerId];
-            if (container) {
-                geom = new ThreeGeometryCreator().createGeometry(container, color);
-                set(state => {
-                    const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, geom), { dirtyStamp: Date.now() }) });
-                    return {
-                        geometry: Object.assign(Object.assign({}, state.geometry), { cache: geometryCache, stamp: Date.now() }),
-                    };
-                });
-            }
-        }
-        return geom;
-    },
-    setGraphicColor: (containerId, graphicId, r, g, b) => {
-        // Provide values as a CSS color string, which will be gamma corrected by three.js
-        const color = new THREE.Color(`rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`);
-        set(state => {
-            // If container cache is empty return
-            if (!state.geometry.cache[containerId])
-                return state;
-            // Shallow clone meshes
-            const meshes = [...state.geometry.cache[containerId].meshes];
-            // Find graphic Object
-            const graphic = meshes.find(mesh => mesh.graphicId === graphicId);
-            if (!graphic)
-                return state;
-            // Apply color
-            meshes[meshes.indexOf(graphic)] = Object.assign(Object.assign({}, graphic), { color });
-            return {
-                geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, state.geometry.cache[containerId]), { meshes, dirtyStamp: Date.now() }) }) }),
-            };
-        });
-    },
-    setContainerColor: (containerId, r, g, b) => {
-        // Provide values as a CSS color string, which will be gamma corrected by three.js
-        const color = new THREE.Color(`rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`);
-        const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { color });
-        set(state => ({
-            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
-        }));
-    },
-    setOpacity: (containerId, opacity) => {
-        const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { opacity });
-        set(state => ({
-            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
-        }));
-    },
-    setConfig: (objId, config) => {
-        set(state => {
-            const productConfigs = Object.assign({}, state.geometry.config.product);
-            if (config) {
-                const newConfig = Object.assign({}, state.geometry.config.product[objId]);
-                if ('disabled' in config)
-                    newConfig.disabled = config.disabled;
-                if ('edges' in config)
-                    newConfig.edges = Object.assign(Object.assign({}, newConfig.edges), config.edges);
-                if ('meshes' in config)
-                    newConfig.meshes = Object.assign(Object.assign({}, newConfig.meshes), config.meshes);
-                if ('points' in config)
-                    newConfig.points = Object.assign(Object.assign({}, newConfig.points), config.points);
-                productConfigs[objId] = newConfig;
-            }
-            else {
-                delete productConfigs[objId];
-            }
-            return { geometry: Object.assign(Object.assign({}, state.geometry), { config: Object.assign(Object.assign({}, state.geometry.config), { product: productConfigs }) }) };
-        });
-    },
-    findDecorated: () => {
-        const { geometry: api } = get().api;
-        return api.filter(elem => { var _a, _b, _c, _d, _e; return Boolean((_b = (_a = elem.rawGraphic) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.label) || Boolean((_e = (_d = (_c = elem.rawGraphic) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.material) === null || _e === void 0 ? void 0 : _e.color); });
-    },
-    filter: (cb, options) => {
-        const result = [];
-        const { cache } = get().geometry;
-        const contIds = Object.getOwnPropertyNames(cache).map(n => Number(n));
-        for (const contId of contIds) {
-            if ((options === null || options === void 0 ? void 0 : options.containerId) && contId !== options.containerId) {
-                continue;
-            }
-            const ids = Object.getOwnPropertyNames(cache[contId].map).map(id => Number(id));
-            for (const id of ids) {
-                const elem = cache[contId].map[id];
-                if (cb(elem)) {
-                    result.push(elem);
-                    if (options === null || options === void 0 ? void 0 : options.onlyOne) {
-                        return result;
-                    }
-                }
-            }
-        }
-        return result;
-    },
-});
+import * as THREE from 'three';
+import { ThreeGeometryCreator } from '../../geometry/ThreeGeometryCreator';
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+export const geometryData = () => ({
+    cache: {},
+    stamp: -1,
+    bounds: {
+        center: new THREE.Vector3(0, 0, 0),
+        radius: 200,
+        min: new THREE.Vector3(-100, -100, -100),
+        max: new THREE.Vector3(100, 100, 100),
+    },
+    config: { product: {} },
+});
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+export const geometryApi = (set, get, buerliApi) => ({
+    /**
+     * 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.
+     */
+    updateBounds: () => {
+        const { api, structure } = get();
+        if (structure.visibleContainers.length > 0) {
+            const bb = api.structure.calculateProductBounds(structure.root);
+            set(state => ({ geometry: Object.assign(Object.assign({}, state.geometry), { stamp: Date.now(), bounds: bb }) }));
+        }
+    },
+    createGeometryIfNotCached: (containerId, color) => {
+        const { graphic, geometry } = get();
+        let geom = geometry.cache[containerId];
+        if (!geom) {
+            const container = graphic.containers[containerId];
+            if (container) {
+                geom = new ThreeGeometryCreator().createGeometry(container, color);
+                set(state => {
+                    const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, geom), { dirtyStamp: Date.now() }) });
+                    return {
+                        geometry: Object.assign(Object.assign({}, state.geometry), { cache: geometryCache, stamp: Date.now() }),
+                    };
+                });
+            }
+        }
+        return geom;
+    },
+    setGraphicColor: (containerId, graphicId, r, g, b) => {
+        // Provide values as a CSS color string, which will be gamma corrected by three.js
+        const color = new THREE.Color(`rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`);
+        set(state => {
+            // If container cache is empty return
+            if (!state.geometry.cache[containerId])
+                return state;
+            // Shallow clone meshes
+            const meshes = [...state.geometry.cache[containerId].meshes];
+            // Find graphic Object
+            const graphic = meshes.find(mesh => mesh.graphicId === graphicId);
+            if (!graphic)
+                return state;
+            // Apply color
+            meshes[meshes.indexOf(graphic)] = Object.assign(Object.assign({}, graphic), { color });
+            return {
+                geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, state.geometry.cache[containerId]), { meshes, dirtyStamp: Date.now() }) }) }),
+            };
+        });
+    },
+    setContainerColor: (containerId, r, g, b) => {
+        // Provide values as a CSS color string, which will be gamma corrected by three.js
+        const color = new THREE.Color(`rgb(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)})`);
+        const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { color });
+        set(state => ({
+            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
+        }));
+    },
+    setOpacity: (containerId, opacity) => {
+        const cachedGeom = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { opacity });
+        set(state => ({
+            geometry: Object.assign(Object.assign({}, state.geometry), { cache: Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: Object.assign(Object.assign({}, cachedGeom), { dirtyStamp: Date.now() }) }) }),
+        }));
+    },
+    setConfig: (objId, config) => {
+        set(state => {
+            const productConfigs = Object.assign({}, state.geometry.config.product);
+            if (config) {
+                const newConfig = Object.assign({}, state.geometry.config.product[objId]);
+                if ('disabled' in config)
+                    newConfig.disabled = config.disabled;
+                if ('edges' in config)
+                    newConfig.edges = Object.assign(Object.assign({}, newConfig.edges), config.edges);
+                if ('meshes' in config)
+                    newConfig.meshes = Object.assign(Object.assign({}, newConfig.meshes), config.meshes);
+                if ('points' in config)
+                    newConfig.points = Object.assign(Object.assign({}, newConfig.points), config.points);
+                productConfigs[objId] = newConfig;
+            }
+            else {
+                delete productConfigs[objId];
+            }
+            return { geometry: Object.assign(Object.assign({}, state.geometry), { config: Object.assign(Object.assign({}, state.geometry.config), { product: productConfigs }) }) };
+        });
+    },
+    findDecorated: () => {
+        const { geometry: api } = get().api;
+        return api.filter(elem => { var _a, _b, _c, _d, _e; return Boolean((_b = (_a = elem.rawGraphic) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.label) || Boolean((_e = (_d = (_c = elem.rawGraphic) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.material) === null || _e === void 0 ? void 0 : _e.color); });
+    },
+    filter: (cb, options) => {
+        const result = [];
+        const { cache } = get().geometry;
+        const contIds = Object.getOwnPropertyNames(cache).map(n => Number(n));
+        for (const contId of contIds) {
+            if ((options === null || options === void 0 ? void 0 : options.containerId) && contId !== options.containerId) {
+                continue;
+            }
+            const ids = Object.getOwnPropertyNames(cache[contId].map).map(id => Number(id));
+            for (const id of ids) {
+                const elem = cache[contId].map[id];
+                if (cb(elem)) {
+                    result.push(elem);
+                    if (options === null || options === void 0 ? void 0 : options.onlyOne) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return result;
+    },
+});

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

@@ -1,110 +1,110 @@
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-export const graphicData = () => ({
-    containers: {},
-});
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-export const graphicApi = (set, get, buerliApi) => ({
-    addPackages: (packages) => {
-        // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
-        if (!Array.isArray(packages)) {
-            packages = [packages];
-        }
-        let cacheChanged = false;
-        const newChache = Object.assign({}, get().geometry.cache);
-        const addedContainers = {};
-        packages.forEach(gr => {
-            gr.containers.forEach(cont => {
-                addedContainers[cont.id] = cont;
-                // If the cached geometry for the added container already exist,
-                // it has to be removed from the cache to ensure geometry updates.
-                if (newChache[cont.id]) {
-                    delete newChache[cont.id];
-                    cacheChanged = true;
-                }
-            });
-        });
-        set(state => ({
-            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();
-        /**
-         * Update the bounds with the newly added graphic.
-         */
-        api.geometry.updateBounds();
-        /**
-         * Create the geometry for the graphic packages.
-         * Only the geometry which does not already exist will be created (@see createGeometryIfNotCached).
-         */
-        const containerIds = Object.getOwnPropertyNames(graphic.containers);
-        for (const id of containerIds) {
-            api.geometry.createGeometryIfNotCached(id);
-        }
-        // console.log('graphicContainers after add:', Object.getOwnPropertyNames(get().graphic.containers))
-    },
-    cleanupGraphicRecords: () => {
-        const { graphic, geometry, api } = get();
-        // collect the used solid ids from the structure tree
-        const solidIds = api.structure.collectUsedSolidIds();
-        // console.log('solidIds before cleanup:', solidIds)
-        // cleanup the graphic containers in the state
-        const usedContainers = {};
-        const existingContainers = graphic.containers;
-        const existingContainerIds = Object.getOwnPropertyNames(existingContainers);
-        if (existingContainerIds.length > 0) {
-            existingContainerIds.forEach(contIdStr => {
-                const contId = Number(contIdStr);
-                if (solidIds.indexOf(contId) >= 0) {
-                    usedContainers[contId] = existingContainers[contId];
-                }
-            });
-            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
-        const usedGeometry = {};
-        const existingGeometry = geometry.cache;
-        const existingGeometryIds = Object.getOwnPropertyNames(existingGeometry);
-        if (existingGeometryIds.length > 0) {
-            existingGeometryIds.forEach(contIdStr => {
-                const contId = Number(contIdStr);
-                if (solidIds.indexOf(contId) >= 0) {
-                    usedGeometry[contId] = existingGeometry[contId];
-                }
-            });
-            set({ geometry: Object.assign(Object.assign({}, geometry), { cache: usedGeometry, stamp: Date.now() }) });
-        }
-    },
-    filter: (cb, options) => {
-        const result = [];
-        const { containers } = get().graphic;
-        const contIds = Object.getOwnPropertyNames(containers).map(n => Number(n));
-        for (const contId of contIds) {
-            if ((options === null || options === void 0 ? void 0 : options.containerId) && contId !== options.containerId) {
-                continue;
-            }
-            const cont = containers[contId];
-            const items = [
-                ...((cont === null || cont === void 0 ? void 0 : cont.arcs) || []),
-                ...((cont === null || cont === void 0 ? void 0 : cont.cones) || []),
-                ...((cont === null || cont === void 0 ? void 0 : cont.edges) || []),
-                ...((cont === null || cont === void 0 ? void 0 : cont.lines) || []),
-                ...((cont === null || cont === void 0 ? void 0 : cont.meshes) || []),
-                ...((cont === null || cont === void 0 ? void 0 : cont.vertices) || []),
-            ];
-            for (const elem of items) {
-                if (cb(elem)) {
-                    result.push({ elem, solidId: cont.owner, containerId: cont.id });
-                    if (options === null || options === void 0 ? void 0 : options.onlyOne) {
-                        return result;
-                    }
-                }
-            }
-        }
-        return result;
-    },
-});
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+export const graphicData = () => ({
+    containers: {},
+});
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+export const graphicApi = (set, get, buerliApi) => ({
+    addPackages: (packages) => {
+        // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
+        if (!Array.isArray(packages)) {
+            packages = [packages];
+        }
+        let cacheChanged = false;
+        const newChache = Object.assign({}, get().geometry.cache);
+        const addedContainers = {};
+        packages.forEach(gr => {
+            gr.containers.forEach(cont => {
+                addedContainers[cont.id] = cont;
+                // If the cached geometry for the added container already exist,
+                // it has to be removed from the cache to ensure geometry updates.
+                if (newChache[cont.id]) {
+                    delete newChache[cont.id];
+                    cacheChanged = true;
+                }
+            });
+        });
+        set(state => ({
+            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();
+        /**
+         * Update the bounds with the newly added graphic.
+         */
+        api.geometry.updateBounds();
+        /**
+         * Create the geometry for the graphic packages.
+         * Only the geometry which does not already exist will be created (@see createGeometryIfNotCached).
+         */
+        const containerIds = Object.getOwnPropertyNames(graphic.containers);
+        for (const id of containerIds) {
+            api.geometry.createGeometryIfNotCached(id);
+        }
+        // console.log('graphicContainers after add:', Object.getOwnPropertyNames(get().graphic.containers))
+    },
+    cleanupGraphicRecords: () => {
+        const { graphic, geometry, api } = get();
+        // collect the used solid ids from the structure tree
+        const solidIds = api.structure.collectUsedSolidIds();
+        // console.log('solidIds before cleanup:', solidIds)
+        // cleanup the graphic containers in the state
+        const usedContainers = {};
+        const existingContainers = graphic.containers;
+        const existingContainerIds = Object.getOwnPropertyNames(existingContainers);
+        if (existingContainerIds.length > 0) {
+            existingContainerIds.forEach(contIdStr => {
+                const contId = Number(contIdStr);
+                if (solidIds.indexOf(contId) >= 0) {
+                    usedContainers[contId] = existingContainers[contId];
+                }
+            });
+            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
+        const usedGeometry = {};
+        const existingGeometry = geometry.cache;
+        const existingGeometryIds = Object.getOwnPropertyNames(existingGeometry);
+        if (existingGeometryIds.length > 0) {
+            existingGeometryIds.forEach(contIdStr => {
+                const contId = Number(contIdStr);
+                if (solidIds.indexOf(contId) >= 0) {
+                    usedGeometry[contId] = existingGeometry[contId];
+                }
+            });
+            set({ geometry: Object.assign(Object.assign({}, geometry), { cache: usedGeometry, stamp: Date.now() }) });
+        }
+    },
+    filter: (cb, options) => {
+        const result = [];
+        const { containers } = get().graphic;
+        const contIds = Object.getOwnPropertyNames(containers).map(n => Number(n));
+        for (const contId of contIds) {
+            if ((options === null || options === void 0 ? void 0 : options.containerId) && contId !== options.containerId) {
+                continue;
+            }
+            const cont = containers[contId];
+            const items = [
+                ...((cont === null || cont === void 0 ? void 0 : cont.arcs) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.cones) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.edges) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.lines) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.meshes) || []),
+                ...((cont === null || cont === void 0 ? void 0 : cont.vertices) || []),
+            ];
+            for (const elem of items) {
+                if (cb(elem)) {
+                    result.push({ elem, solidId: cont.owner, containerId: cont.id });
+                    if (options === null || options === void 0 ? void 0 : options.onlyOne) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return result;
+    },
+});

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

@@ -1,50 +1,50 @@
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-export const interactionData = () => ({
-    hovered: null,
-    selected: [],
-});
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-export const interactionApi = (set, get, buerliApi) => ({
-    /**
-     * Sets the hovered item in the store to the given item.
-     *
-     * @param item The item.
-     */
-    setHovered: (item) => {
-        set(state => (Object.assign(Object.assign({}, state), { interaction: Object.assign(Object.assign({}, state.interaction), { hovered: item }) })));
-    },
-    /**
-     * Reset the 'selected' array to the given items.
-     *
-     * @param items The items.
-     */
-    setSelected: (items) => {
-        set(state => (Object.assign(Object.assign({}, state), { interaction: Object.assign(Object.assign({}, state.interaction), { selected: items }) })));
-    },
-    /**
-     * Adds the given item to the 'selected' array if it is not yet selected.
-     * If the item is already selected, it will be removed from the 'selected' array.
-     *
-     * With 'multi' enabled, the already selected items will remain selected.
-     *
-     * @param item The item to select.
-     * @param multi Do multi select.
-     */
-    select: (item, multi) => {
-        const setSelected = get().api.interaction.setSelected;
-        const selected = get().interaction.selected || [];
-        const newKey = item.uniqueIdent;
-        let newSel = selected.length === 1 && selected[0].uniqueIdent === newKey ? [] : [item];
-        if (multi) {
-            newSel = selected.filter(s => s.uniqueIdent != newKey);
-            if (newSel.length === selected.length) {
-                newSel.push(item);
-            }
-        }
-        setSelected(newSel);
-    },
-});
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+export const interactionData = () => ({
+    hovered: null,
+    selected: [],
+});
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+export const interactionApi = (set, get, buerliApi) => ({
+    /**
+     * Sets the hovered item in the store to the given item.
+     *
+     * @param item The item.
+     */
+    setHovered: (item) => {
+        set(state => (Object.assign(Object.assign({}, state), { interaction: Object.assign(Object.assign({}, state.interaction), { hovered: item }) })));
+    },
+    /**
+     * Reset the 'selected' array to the given items.
+     *
+     * @param items The items.
+     */
+    setSelected: (items) => {
+        set(state => (Object.assign(Object.assign({}, state), { interaction: Object.assign(Object.assign({}, state.interaction), { selected: items }) })));
+    },
+    /**
+     * Adds the given item to the 'selected' array if it is not yet selected.
+     * If the item is already selected, it will be removed from the 'selected' array.
+     *
+     * With 'multi' enabled, the already selected items will remain selected.
+     *
+     * @param item The item to select.
+     * @param multi Do multi select.
+     */
+    select: (item, multi) => {
+        const setSelected = get().api.interaction.setSelected;
+        const selected = get().interaction.selected || [];
+        const newKey = item.uniqueIdent;
+        let newSel = selected.length === 1 && selected[0].uniqueIdent === newKey ? [] : [item];
+        if (multi) {
+            newSel = selected.filter(s => s.uniqueIdent != newKey);
+            if (newSel.length === selected.length) {
+                newSel.push(item);
+            }
+        }
+        setSelected(newSel);
+    },
+});

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

@@ -1,21 +1,28 @@
-import { v4 as uuidv4 } from 'uuid';
-export const BuerliMessageScope = 'BuerliMessageScope';
-export const getInitialMessageState = (set, get, api) => ({
-    message: {
-        data: null,
-        timestamp: -1,
-        api: messageApi(set, get, api),
-    },
-});
-const messageApi = (set, get, api) => ({
-    show(message) {
-        const newId = uuidv4();
-        const msg = get().message;
-        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: Object.assign(Object.assign({}, msg), { data: Object.assign({ id }, message), timestamp: Date.now() }) });
-    },
-});
+import { v4 as uuidv4 } from 'uuid';
+export const BuerliMessageScope = 'BuerliMessageScope';
+export const getInitialMessageState = (set, get, api) => ({
+    message: {
+        data: null,
+        timestamp: -1,
+        api: messageApi(set, get, api),
+    },
+});
+const messageApi = (set, get, api) => ({
+    show(message) {
+        const newId = uuidv4();
+        const msg = get().message;
+        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: Object.assign(Object.assign({}, msg), { data: Object.assign({ id }, message), timestamp: Date.now() }) });
+    },
+    close(id) {
+        var _a;
+        const msg = get().message;
+        if (((_a = msg.data) === null || _a === void 0 ? void 0 : _a.id) === id) {
+            set({ message: Object.assign(Object.assign({}, msg), { data: null, timestamp: Date.now() }) });
+        }
+    },
+});