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

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

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createState = void 0;
-const drawing_1 = require("./drawing");
-const message_1 = require("./message");
-const initError = 'Please call the init action before you use the buerli store.';
-const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
-        url: '',
-        elements: {},
-        plugins: {},
-        globalPlugins: [],
-        theme: {
-            primary: '#e36b7c',
-            secondary: '#fcc7cb',
-            dark: '#54545d',
-            highlightedGeom: '#e36b7c',
-            hoveredGeom: '#40a9ff',
-        },
-        config: {
-            geometry: {},
-        },
-    }, drawing: {
-        ids: [],
-        refs: {},
-        active: null,
-    }, api: Object.assign(Object.assign({}, generalApi(set, get)), drawingManagementApi(set, get, api)) }, message_1.getInitialMessageState(set, get, api)));
-exports.createState = createState;
-const generalApi = (set, get) => ({
-    // TODO: rename init to setOptions and remove initDone if everything is ok
-    /**
-     * This api method initializes state. Considering user can accidentally ommit some important like elements,
-     * there is a warning disaplying for these cases.
-     *
-     * @param options - options which will be set into state.options
-     */
-    init(options) {
-        set(state => ({ options: Object.assign(Object.assign({}, state.options), options), initDone: true }));
-    },
-});
-const drawingManagementApi = (set, get, api) => ({
-    async createDrawing(name) {
-        const { initDone, drawing } = get();
-        if (!initDone)
-            throw new Error(initError);
-        const drawingState = drawing_1.createDrawingState(sel => set(state => {
-            const newState = typeof sel === 'function' ? sel(state.drawing.refs[drawingState.id]) : sel;
-            return {
-                drawing: Object.assign(Object.assign({}, state.drawing), { refs: Object.assign(Object.assign({}, state.drawing.refs), { [drawingState.id]: Object.assign(Object.assign({}, state.drawing.refs[drawingState.id]), newState) }) }),
-            };
-        }), () => get().drawing.refs[drawingState.id], api, drawing.ids.length, name);
-        set(state => ({
-            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));
-        return drawingState;
-    },
-    removeDrawing(id) {
-        const { initDone } = get();
-        if (!initDone)
-            throw new Error(initError);
-        // Note:
-        // Since it can lead to unexpected behaviour because of updating everything at once
-        // split the state modification into two parts.
-        // 1. Reset active drawing
-        // 2. Remove drawing from state
-        // Give the listeners the possibility to handle the active drawing before it is removed.
-        // There was exactly such a situation in buerli-examples, where a cad instance of buerli-headless
-        // was destroyed (removes drawing as well) while a components is going to be unmounted, but an
-        // other component already binds to the active drawing before it is removed. Yes, it can be handled
-        // by the application but it makes sense to pay attention to this behaviour at this place already.
-        // 1.
-        // Calculate and set the active drawing before removing the drawing from the store.
-        set(state => {
-            const index = state.drawing.ids.indexOf(id);
-            // Pick close by drawing unless another drawing has been active all along
-            const active = index >= 0 && state.drawing.active === id
-                ? state.drawing.ids[index + 1] || state.drawing.ids[index - 1] || null
-                : state.drawing.active;
-            return { drawing: Object.assign(Object.assign({}, state.drawing), { active }) };
-        });
-        // 2.
-        // Remove drawing from store.
-        set(state => {
-            const refs = Object.assign({}, state.drawing.refs);
-            const ids = state.drawing.ids.filter(d => d !== id);
-            delete refs[id];
-            return { drawing: Object.assign(Object.assign({}, state.drawing), { refs, ids }) };
-        });
-    },
-    setActiveDrawing(id) {
-        const { initDone, drawing } = get();
-        if (!initDone)
-            throw new Error(initError);
-        set({ drawing: Object.assign(Object.assign({}, drawing), { active: id }) });
-    },
-});

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

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

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

@@ -1,44 +0,0 @@
-"use strict";
-/**!
- * The Drawing manages all necessary data that belong to a model.
- *
- * On the one hand these are the structure and graphic data by which the
- * CAD model is defined, on the other hand it administers additional data
- * for the support with the client-sided development.
- *
- * @image /doc/assets/core/drawing.png
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDrawingState = void 0;
-const uuid_1 = require("uuid");
-const canvas_1 = require("./canvas");
-const geometry_1 = require("./geometry");
-const graphic_1 = require("./graphic");
-const plugin_1 = require("./plugin");
-const selection_1 = require("./selection");
-const structure_1 = require("./structure");
-////////////////////////////////////////////////////
-// DATA
-////////////////////////////////////////////////////
-const createDrawingState = (set, get, api, drawingNumber, name) => {
-    const drawingId = uuid_1.v4();
-    return {
-        structure: structure_1.structureData(),
-        selection: selection_1.selectionData(),
-        plugin: plugin_1.pluginData(),
-        geometry: geometry_1.geometryData(),
-        graphic: graphic_1.graphicData(),
-        canvas: canvas_1.canvasData(),
-        api: {
-            structure: structure_1.structureApi(set, get),
-            selection: selection_1.selectionApi(set, get),
-            plugin: plugin_1.pluginApi(set, get),
-            geometry: geometry_1.geometryApi(set, get),
-            graphic: graphic_1.graphicApi(set, get),
-            canvas: canvas_1.canvasApi(set, get),
-        },
-        id: drawingId,
-        name: name || `Drawing #${drawingNumber}`,
-    };
-};
-exports.createDrawingState = createDrawingState;

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

@@ -1,110 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geometryApi = exports.geometryData = void 0;
-const THREE = __importStar(require("three"));
-const ThreeGeometryCreator_1 = require("../../geometry/ThreeGeometryCreator");
-////////////////////////////////////////////////////
-// 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) => ({
-    /**
-     * 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]: geom });
-                    return {
-                        geometry: Object.assign(Object.assign({}, state.geometry), { cache: geometryCache, stamp: Date.now() }),
-                    };
-                });
-            }
-        }
-        return geom;
-    },
-    setColor: (containerId, r, g, b) => {
-        const thCol = new THREE.Color(r, g, b);
-        const cachedGeom = Object.assign({}, get().geometry.cache[containerId]);
-        cachedGeom.color = thCol;
-        cachedGeom.meshes.forEach(mesh => (mesh.color = thCol));
-        set(state => ({
-            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 = Object.assign(Object.assign({}, get().geometry.cache[containerId]), { opacity });
-        cachedGeom.meshes.forEach(mesh => (mesh.opacity = opacity));
-        set(state => ({
-            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 = 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 }) }) };
-        });
-    },
-});
-exports.geometryApi = geometryApi;

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

@@ -1,87 +0,0 @@
-"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) => ({
-    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);
-        const createGeometry = async () => {
-            for (const id of containerIds) {
-                api.geometry.createGeometryIfNotCached(id);
-            }
-        };
-        createGeometry().catch();
-        // 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() }) });
-        }
-    },
-});
-exports.graphicApi = graphicApi;

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

@@ -1,25 +0,0 @@
-"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 = 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,113 +0,0 @@
-"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) => ({
-    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 : 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;