@buerli.io/core 0.13.0 → 0.13.1-beta.1

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

@@ -1,157 +1,157 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geometryApi = exports.geometryData = void 0;
-const THREE = __importStar(require("three"));
-const ThreeGeometryCreator_1 = require("../../geometry/ThreeGeometryCreator");
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-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: {} },
-});
-exports.geometryData = geometryData;
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-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_1.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;
-    },
-});
-exports.geometryApi = geometryApi;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometryApi = exports.geometryData = void 0;
+const THREE = __importStar(require("three"));
+const ThreeGeometryCreator_1 = require("../../geometry/ThreeGeometryCreator");
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+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: {} },
+});
+exports.geometryData = geometryData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+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_1.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;
+    },
+});
+exports.geometryApi = geometryApi;

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

@@ -1,112 +1,112 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphicApi = exports.graphicData = void 0;
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-const graphicData = () => ({
-    containers: {},
-});
-exports.graphicData = graphicData;
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-const graphicApi = (set, get, buerliApi) => ({
-    addPackages: (packages) => {
-        // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
-        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;
-    },
-});
-exports.graphicApi = graphicApi;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphicApi = exports.graphicData = void 0;
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+const graphicData = () => ({
+    containers: {},
+});
+exports.graphicData = graphicData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+const graphicApi = (set, get, buerliApi) => ({
+    addPackages: (packages) => {
+        // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
+        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;
+    },
+});
+exports.graphicApi = graphicApi;