@buerli.io/core 1.0.0 → 1.0.1-beta.2

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

@@ -1,115 +1,115 @@
-"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}`)
-        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;
-    },
-});
-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}`)
+        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;
+    },
+});
+exports.graphicApi = graphicApi;

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

@@ -1,55 +1,55 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interactionApi = exports.interactionData = void 0;
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-const interactionData = () => ({
-    hovered: null,
-    selected: [],
-});
-exports.interactionData = interactionData;
-////////////////////////////////////////////////////
-// API
-////////////////////////////////////////////////////
-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);
-    },
-});
-exports.interactionApi = interactionApi;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactionApi = exports.interactionData = void 0;
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+const interactionData = () => ({
+    hovered: null,
+    selected: [],
+});
+exports.interactionData = interactionData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+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);
+    },
+});
+exports.interactionApi = interactionApi;

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

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInitialMessageState = exports.BuerliMessageScope = void 0;
-const uuid_1 = require("uuid");
-exports.BuerliMessageScope = 'BuerliMessageScope';
-const getInitialMessageState = (set, get, api) => ({
-    message: {
-        data: null,
-        timestamp: -1,
-        api: messageApi(set, get, api),
-    },
-});
-exports.getInitialMessageState = getInitialMessageState;
-const messageApi = (set, get, api) => ({
-    show(message) {
-        const newId = (0, uuid_1.v4)();
-        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() }) });
-    },
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitialMessageState = exports.BuerliMessageScope = void 0;
+const uuid_1 = require("uuid");
+exports.BuerliMessageScope = 'BuerliMessageScope';
+const getInitialMessageState = (set, get, api) => ({
+    message: {
+        data: null,
+        timestamp: -1,
+        api: messageApi(set, get, api),
+    },
+});
+exports.getInitialMessageState = getInitialMessageState;
+const messageApi = (set, get, api) => ({
+    show(message) {
+        const newId = (0, uuid_1.v4)();
+        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() }) });
+    },
+});

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

@@ -1,115 +1,115 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromisePlugin = exports.pluginApi = exports.pluginData = void 0;
-const uuid_1 = require("uuid");
-const pluginData = () => ({
-    feature: [],
-    global: [],
-    refs: {},
-    active: {
-        feature: null,
-        global: [],
-    },
-    visible: [],
-});
-exports.pluginData = pluginData;
-const pluginApi = (set, get, buerliApi) => ({
-    setActiveFeature: (id) => {
-        set(state => {
-            let plugins = state.plugin.refs;
-            const oldPlugin = state.plugin.active.feature !== null && state.plugin.refs[state.plugin.active.feature];
-            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 = Object.assign(Object.assign({}, plugins), { [oldPlugin.id]: Object.assign(Object.assign({}, oldPlugin), { state: typeof initState === 'function' ? initState(get().id, id) : initState }) });
-            }
-            return {
-                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 }),
-            };
-        });
-    },
-    setVisiblePlugin: (id, visible) => {
-        set(currentState => {
-            const filtered = currentState.plugin.visible.filter(p => p !== id);
-            if (visible)
-                filtered.push(id);
-            return {
-                plugin: Object.assign(Object.assign({}, currentState.plugin), { visible: filtered }),
-            };
-        });
-    },
-    setActiveGlobal: (id, active) => {
-        set(currentState => {
-            if (currentState.plugin.global.indexOf(id) === -1) {
-                console.warn('Given plugin id does not exist.');
-                return currentState;
-            }
-            const filtered = currentState.plugin.active.global.filter(p => p !== id);
-            if (active)
-                filtered.push(id);
-            return {
-                plugin: Object.assign(Object.assign({}, currentState.plugin), { active: Object.assign(Object.assign({}, currentState.plugin.active), { global: filtered }) }),
-            };
-        });
-    },
-    // TODO remove defaultId and useEmbeddedPlugin ?
-    createPlugin: (def, defaultId, drawingId, objectId) => {
-        const id = defaultId !== void 0 ? defaultId : (0, uuid_1.v4)();
-        function init(definition) {
-            const { description, Root = null, View = null } = definition;
-            const initialState = description.initialState || {};
-            const localState = typeof initialState === 'function' ? initialState(drawingId, objectId) : initialState;
-            set(currentState => {
-                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: 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: 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) }) }),
-                };
-            });
-        }
-        // Initialize plugin definition, which may be a promise or an object
-        if (isPromisePlugin(def)) {
-            // The definition is async, so we create a plugin slot right away and complete it later
-            init({
-                description: { author: '', name: '', persistent: false, global: false, version: '' },
-                Root: null,
-                View: null,
-            });
-            def.then(init).catch();
-        }
-        else
-            init(def);
-        // Return unsubscribe
-        return (deactivate = true) => {
-            // Use 'get' to check if the drawing still exists
-            get &&
-                get() &&
-                set(state => {
-                    const newPlugins = Object.assign({}, state.plugin.refs);
-                    delete newPlugins[id];
-                    return {
-                        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 }),
-                    };
-                });
-        };
-    },
-});
-exports.pluginApi = pluginApi;
-function isPromisePlugin(def) {
-    return def.then !== undefined;
-}
-exports.isPromisePlugin = isPromisePlugin;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromisePlugin = exports.pluginApi = exports.pluginData = void 0;
+const uuid_1 = require("uuid");
+const pluginData = () => ({
+    feature: [],
+    global: [],
+    refs: {},
+    active: {
+        feature: null,
+        global: [],
+    },
+    visible: [],
+});
+exports.pluginData = pluginData;
+const pluginApi = (set, get, buerliApi) => ({
+    setActiveFeature: (id) => {
+        set(state => {
+            let plugins = state.plugin.refs;
+            const oldPlugin = state.plugin.active.feature !== null && state.plugin.refs[state.plugin.active.feature];
+            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 = Object.assign(Object.assign({}, plugins), { [oldPlugin.id]: Object.assign(Object.assign({}, oldPlugin), { state: typeof initState === 'function' ? initState(get().id, id) : initState }) });
+            }
+            return {
+                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 }),
+            };
+        });
+    },
+    setVisiblePlugin: (id, visible) => {
+        set(currentState => {
+            const filtered = currentState.plugin.visible.filter(p => p !== id);
+            if (visible)
+                filtered.push(id);
+            return {
+                plugin: Object.assign(Object.assign({}, currentState.plugin), { visible: filtered }),
+            };
+        });
+    },
+    setActiveGlobal: (id, active) => {
+        set(currentState => {
+            if (currentState.plugin.global.indexOf(id) === -1) {
+                console.warn('Given plugin id does not exist.');
+                return currentState;
+            }
+            const filtered = currentState.plugin.active.global.filter(p => p !== id);
+            if (active)
+                filtered.push(id);
+            return {
+                plugin: Object.assign(Object.assign({}, currentState.plugin), { active: Object.assign(Object.assign({}, currentState.plugin.active), { global: filtered }) }),
+            };
+        });
+    },
+    // TODO remove defaultId and useEmbeddedPlugin ?
+    createPlugin: (def, defaultId, drawingId, objectId) => {
+        const id = defaultId !== void 0 ? defaultId : (0, uuid_1.v4)();
+        function init(definition) {
+            const { description, Root = null, View = null } = definition;
+            const initialState = description.initialState || {};
+            const localState = typeof initialState === 'function' ? initialState(drawingId, objectId) : initialState;
+            set(currentState => {
+                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: 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: 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) }) }),
+                };
+            });
+        }
+        // Initialize plugin definition, which may be a promise or an object
+        if (isPromisePlugin(def)) {
+            // The definition is async, so we create a plugin slot right away and complete it later
+            init({
+                description: { author: '', name: '', persistent: false, global: false, version: '' },
+                Root: null,
+                View: null,
+            });
+            def.then(init).catch();
+        }
+        else
+            init(def);
+        // Return unsubscribe
+        return (deactivate = true) => {
+            // Use 'get' to check if the drawing still exists
+            get &&
+                get() &&
+                set(state => {
+                    const newPlugins = Object.assign({}, state.plugin.refs);
+                    delete newPlugins[id];
+                    return {
+                        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 }),
+                    };
+                });
+        };
+    },
+});
+exports.pluginApi = pluginApi;
+function isPromisePlugin(def) {
+    return def.then !== undefined;
+}
+exports.isPromisePlugin = isPromisePlugin;