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

package/build/cjs/geometry/ThreeGeometryCreator.js

@@ -0,0 +1,284 @@
+"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.isEqualGeometry = exports.EMPTY_CONTAINER_GEOMETRY = exports.ThreeGeometryCreator = void 0;
+const THREE = __importStar(require("three"));
+const types_1 = require("./../types");
+/**
+ * Creates THREE geometry based on the data within a @see IGraphicContainer.
+ */
+class ThreeGeometryCreator {
+    constructor() {
+        this.coordHeightTolerance = 0.01;
+    }
+    getMetadata(geometry, container, color = [0, 0, 0], opacity = 0) {
+        const contProps = container.properties; // container has always properties
+        const geomProps = geometry ? geometry.properties : {};
+        let col = container.properties.material.color || color;
+        let opa = container.properties.material.opacity || opacity;
+        if (geomProps && geomProps.material) {
+            col = geomProps.material.color || col;
+            opa = geomProps.material.opacity || opa;
+        }
+        const rgbColor = new THREE.Color(col[0] / 255, col[1] / 255, col[2] / 255);
+        const layer = geomProps && geomProps.layer ? geomProps.layer : contProps.layer;
+        return { color: rgbColor, opacity: opa, layer, container: { id: container.id, ownerId: container.owner } };
+    }
+    createGeometry(container, color = [0, 0, 0]) {
+        const graphicId = container.id;
+        const { properties } = container;
+        const box = { min: new THREE.Vector3(...properties.min), max: new THREE.Vector3(...properties.max) };
+        const meshes = [];
+        const lines = [];
+        const edges = [];
+        const arcs = [];
+        const pointMap = {};
+        const map = {};
+        if (container.meshes) {
+            container.meshes.forEach(mesh => {
+                const elem = this.createSurface(mesh, container, color);
+                if (elem.isValid) {
+                    meshes.push(elem);
+                    map[mesh.id] = elem;
+                }
+                else {
+                    // TODO: The server should not send invalid meshes.
+                    console.warn(`Invalid mesh detected`);
+                }
+            });
+        }
+        if (container.lines) {
+            container.lines.forEach(line => {
+                const elem = this.createLine(line, container, pointMap, color);
+                lines.push(elem);
+                map[line.id] = elem;
+            });
+        }
+        if (container.edges) {
+            container.edges.forEach(edge => {
+                const elem = this.createEdge(edge, container, pointMap, color);
+                edges.push(elem);
+                map[edge.id] = elem;
+            });
+        }
+        if (container.arcs) {
+            container.arcs.forEach(arc => {
+                const elem = this.createArc(arc, container, pointMap, color);
+                arcs.push(elem);
+                map[arc.id] = elem;
+            });
+        }
+        const points = Object.values(pointMap);
+        return Object.assign({ graphicId,
+            map,
+            meshes,
+            lines,
+            edges,
+            arcs,
+            points,
+            box }, this.getMetadata(null, container, color));
+    }
+    createSurface(mesh, container, color = [0, 0, 0]) {
+        let meshGeom = this.createMesh(mesh, container, color);
+        switch (meshGeom.type) {
+            case types_1.GraphicType.PLANE:
+                meshGeom = this.createPlane(mesh, meshGeom);
+                break;
+            case types_1.GraphicType.CYLINDER:
+                meshGeom = this.createCylinder(mesh, meshGeom);
+                break;
+            case types_1.GraphicType.CONE:
+                meshGeom = this.createCone(mesh, meshGeom);
+                break;
+            case types_1.GraphicType.SPHERE:
+                meshGeom = this.createSphere(mesh, meshGeom);
+                break;
+        }
+        return meshGeom;
+    }
+    createMesh(mesh, container, color = [0, 0, 0]) {
+        const graphicId = mesh.id;
+        const loops = mesh.loops;
+        const type = mesh.properties.surface.type;
+        const geometry = new THREE.BufferGeometry();
+        geometry.setIndex(mesh.indices);
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(mesh.vertices, 3));
+        mesh.normals && geometry.setAttribute('normal', new THREE.Float32BufferAttribute(mesh.normals, 3));
+        return Object.assign({ 
+            // TODO: The server should not send invalid meshes.
+            isValid: mesh.vertices && mesh.vertices.length > 0, geometry,
+            graphicId,
+            type,
+            loops }, this.getMetadata(mesh, container, color));
+    }
+    createPlane(mesh, meshGeom) {
+        const type = types_1.GraphicType.PLANE;
+        const { normal: n, pointOnPlane: p } = mesh.properties.surface;
+        const pointOnPlane = new THREE.Vector3(p[0], p[1], p[2]);
+        const normal = new THREE.Vector3(n[0], n[1], n[2]).normalize();
+        return Object.assign(Object.assign({}, meshGeom), { type, pointOnPlane, normal });
+    }
+    createCylinder(mesh, meshGeom) {
+        const type = types_1.GraphicType.CYLINDER;
+        const { origin: o, axis: a, height, radius } = mesh.properties.surface;
+        const origin = new THREE.Vector3(o[0], o[1], o[2]);
+        const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
+        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radius });
+    }
+    createCone(mesh, meshGeom) {
+        const type = types_1.GraphicType.CONE;
+        const { origin: o, axis: a, height, radiusBottom, radiusTop } = mesh.properties.surface;
+        const origin = new THREE.Vector3(o[0], o[1], o[2]);
+        const axis = new THREE.Vector3(a[0], a[1], a[2]).normalize();
+        return Object.assign(Object.assign({}, meshGeom), { type, origin, axis, height, radiusBottom, radiusTop });
+    }
+    createSphere(mesh, meshGeom) {
+        const type = types_1.GraphicType.SPHERE;
+        const { radius } = mesh.properties.surface;
+        return Object.assign(Object.assign({}, meshGeom), { type, radius });
+    }
+    createLine(line, container, points, color = [0, 0, 0]) {
+        const graphicId = line.id;
+        const type = types_1.GraphicType.LINE;
+        const pts = line.points;
+        const [startId, endId] = line.pointIds;
+        const start = new THREE.Vector3(pts[0], pts[1], pts[2]);
+        const end = new THREE.Vector3(pts[3], pts[4], pts[5]);
+        this.insertPoint(container, `${startId}|point`, startId, start.clone(), line.id, 'start', points);
+        this.insertPoint(container, `${endId}|point`, endId, end.clone(), line.id, 'end', points);
+        const geometry = new THREE.BufferGeometry().setFromPoints([start.clone(), end.clone()]);
+        return Object.assign(Object.assign({ geometry,
+            graphicId,
+            type }, this.getMetadata(line, container, color)), { start: start.clone(), end: end.clone() });
+    }
+    createEdge(edge, container, points, color = [0, 0, 0]) {
+        const threePts = [];
+        const graphicId = edge.id;
+        const type = types_1.GraphicType.EDGE;
+        const pts = edge.points;
+        for (let i = 0, length = pts.length / 3; i < length; i++) {
+            threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
+            // Each segment has to be defined with start and end to use it for BufferGeometry
+            if (i > 0) {
+                threePts.push(new THREE.Vector3(pts[i * 3], pts[i * 3 + 1], pts[i * 3 + 2]));
+            }
+        }
+        // Seems like the three BufferGeometryUtils expect an edge to have an even number of points.
+        // Just add the end point twice if this is not the case.
+        if (threePts.length % 2 !== 0) {
+            threePts.push(threePts[threePts.length - 1].clone());
+        }
+        const start = threePts[0].clone();
+        const end = threePts[threePts.length - 1].clone();
+        const startId = edge.pointIds[0];
+        const endId = edge.pointIds[edge.pointIds.length - 1];
+        this.insertPoint(container, `${startId}|point`, startId, start, edge.id, 'start', points);
+        this.insertPoint(container, `${endId}|point`, endId, end, edge.id, 'end', points);
+        const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
+        return Object.assign(Object.assign({ geometry,
+            graphicId,
+            type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
+    }
+    createArc(arc, container, points, color = [0, 0, 0]) {
+        const graphicId = arc.id;
+        const type = arc.isCircle ? types_1.GraphicType.CIRCLE : types_1.GraphicType.ARC;
+        // take half of coordHeightTolerance used for faces, as classcad does it in the tessellation process
+        const coordHeight = this.coordHeightTolerance / 2;
+        const radius = arc.radius;
+        const center = new THREE.Vector3(arc.center[0], arc.center[1], arc.center[2]);
+        const normal = new THREE.Vector3(arc.zAxis[0], arc.zAxis[1], arc.zAxis[2]).normalize();
+        const startVector = new THREE.Vector3(arc.xAxis[0], arc.xAxis[1], arc.xAxis[2]).normalize().multiplyScalar(radius);
+        const theta = arc.isCircle ? Math.PI * 2 : arc.angle;
+        // calculate angle for one segment to fulfill coordHeight tolerance
+        let alpha = 2 * Math.acos(1 - coordHeight / radius);
+        // calculate number of segments
+        let segments = Math.ceil(Math.abs(arc.angle) / alpha);
+        // choose at minimum three segments
+        segments = Math.max(3, segments);
+        // adjust angle to match with number of segments, still fulfilling coordHeigth tolerance
+        alpha = theta / segments;
+        const threePts = [];
+        const matrix = new THREE.Matrix4().makeRotationAxis(normal, alpha);
+        const startPoint = center.clone();
+        startPoint.add(startVector);
+        threePts.push(startPoint);
+        for (let i = 0; i < segments; i++) {
+            startVector.applyMatrix4(matrix);
+            const nextPoint = center.clone();
+            nextPoint.add(startVector);
+            threePts.push(nextPoint.clone());
+            // Each segment has to be defined with start and end to use it for BufferGeometry
+            threePts.push(nextPoint.clone());
+        }
+        // Seems like the three BufferGeometryUtils expect an edge to have an even number of points.
+        // Just add the end point twice if this is not the case.
+        if (threePts.length % 2 !== 0) {
+            threePts.push(threePts[threePts.length - 1].clone());
+        }
+        const [startId, endId] = arc.pointIds;
+        const start = threePts[0].clone();
+        const end = threePts[threePts.length - 1].clone();
+        this.insertPoint(container, `${startId}|point`, startId, start, arc.id, 'start', points);
+        this.insertPoint(container, `${endId}|point`, endId, end, arc.id, 'end', points);
+        const geometry = new THREE.BufferGeometry().setFromPoints(threePts);
+        return Object.assign(Object.assign({ geometry,
+            graphicId,
+            type }, this.getMetadata(arc, container, color)), { normal: normal.clone(), center: center.clone(), radius: arc.radius, angle: arc.angle });
+    }
+    createPoint(container, key, graphicId, position, ownerId, type) {
+        return Object.assign(Object.assign({ key,
+            graphicId, type: types_1.GraphicType.POINT }, this.getMetadata(null, container)), { position: position.clone(), geometry: position.clone(), owners: [{ ownerId, type }] });
+    }
+    insertPoint(container, key, graphicId, position, ownerId, type, points) {
+        const existingPoint = points[key];
+        if (existingPoint) {
+            const filteredOwners = existingPoint.owners.filter(gr => gr.ownerId === ownerId && gr.type === type);
+            if (filteredOwners.length <= 0) {
+                existingPoint.owners.push({ ownerId, type });
+            }
+        }
+        else {
+            points[key] = this.createPoint(container, key, graphicId, position, ownerId, type);
+        }
+    }
+}
+exports.ThreeGeometryCreator = ThreeGeometryCreator;
+const EMPTY_CONTAINER_GEOMETRY = () => {
+    return {
+        graphicId: Number.NaN,
+        map: {},
+        meshes: [],
+        lines: [],
+        edges: [],
+        arcs: [],
+        points: [],
+        box: { min: new THREE.Vector3(), max: new THREE.Vector3() },
+        container: { id: NaN, ownerId: NaN },
+        color: new THREE.Color(),
+        opacity: 1.0,
+        layer: null,
+    };
+};
+exports.EMPTY_CONTAINER_GEOMETRY = EMPTY_CONTAINER_GEOMETRY;
+const isEqualGeometry = (a, b) => {
+    return a.graphicId === b.graphicId && a.type === b.type;
+};
+exports.isEqualGeometry = isEqualGeometry;

package/build/cjs/geometry/index.js

@@ -0,0 +1,13 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ThreeGeometryCreator"), exports);

package/build/cjs/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./store"), exports);
+__exportStar(require("./geometry"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/Math"), exports);
+__exportStar(require("./utils/Measure"), exports);
+__exportStar(require("./utils/Timing"), exports);
+__exportStar(require("./store/subscribtion/subscribeToDrawing"), exports);
+//#endregion Re-export type definitions

package/build/cjs/store/index.js

@@ -0,0 +1,46 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateMessage = exports.showMessage = exports.init = exports.getPlugin = exports.getDrawing = exports.createGraphicItem = exports.BuerliScope = exports.BuerliMessageScope = void 0;
+const store_1 = require("./store");
+function getDrawing(id) {
+    const { drawing } = store_1.api.getState();
+    return drawing.refs[id];
+}
+exports.getDrawing = getDrawing;
+/**
+ * @returns PluginState or undefined if either drawing or plugin don't exist
+ */
+function getPlugin(drawingId, pluginId) {
+    var _a;
+    const { drawing } = store_1.api.getState();
+    return (_a = drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.plugin.refs[pluginId];
+}
+exports.getPlugin = getPlugin;
+function init(sel) {
+    store_1.api.getState().api.init(typeof sel === 'function' ? sel(store_1.api.getState()) || {} : sel);
+}
+exports.init = init;
+function showMessage(message) {
+    return store_1.api.getState().message.api.show(message);
+}
+exports.showMessage = showMessage;
+function updateMessage(id, message) {
+    store_1.api.getState().message.api.update(id, message);
+}
+exports.updateMessage = updateMessage;
+var message_1 = require("./states/message");
+Object.defineProperty(exports, "BuerliMessageScope", { enumerable: true, get: function () { return message_1.BuerliMessageScope; } });
+var selection_1 = require("./states/selection");
+Object.defineProperty(exports, "BuerliScope", { enumerable: true, get: function () { return selection_1.BuerliScope; } });
+Object.defineProperty(exports, "createGraphicItem", { enumerable: true, get: function () { return selection_1.createGraphicItem; } });
+__exportStar(require("./store"), exports);

package/build/{store → cjs/store}/states/buerli.js

@@ -1,7 +1,10 @@
-import { createDrawingState } from './drawing';
-import { getInitialMessageState } from './message';
+"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.';
-export const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
+const createState = (set, get, api) => (Object.assign({ initDone: false, options: {
         url: '',
         elements: {},
         plugins: {},
@@ -20,7 +23,8 @@ export const createState = (set, get, api) => (Object.assign({ initDone: false,
         ids: [],
         refs: {},
         active: null,
-    }, api: Object.assign(Object.assign({}, generalApi(set, get)), drawingManagementApi(set, get, api)) }, getInitialMessageState(set, get, api)));
+    }, 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
     /**
@@ -38,7 +42,7 @@ const drawingManagementApi = (set, get, api) => ({
         const { initDone, drawing } = get();
         if (!initDone)
             throw new Error(initError);
-        const drawingState = createDrawingState(sel => set(state => {
+        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) }) }),

package/build/{store → cjs/store}/states/canvas.js

@@ -1,13 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canvasApi = exports.canvasData = void 0;
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
-export const canvasData = () => ({
+const canvasData = () => ({
     controls: { isInteracting: false, enabled: true },
 });
+exports.canvasData = canvasData;
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const canvasApi = (set, get) => ({
+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

@@ -0,0 +1,44 @@
+"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/{store → cjs/store}/states/geometry.js

@@ -1,9 +1,31 @@
-import * as THREE from 'three';
-import { ThreeGeometryCreator } from '../../geometry/ThreeGeometryCreator';
+"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
 ////////////////////////////////////////////////////
-export const geometryData = () => ({
+const geometryData = () => ({
     cache: {},
     stamp: -1,
     bounds: {
@@ -14,10 +36,11 @@ export const geometryData = () => ({
     },
     config: { product: {} },
 });
+exports.geometryData = geometryData;
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const geometryApi = (set, get) => ({
+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.
@@ -35,7 +58,7 @@ export const geometryApi = (set, get) => ({
         if (!geom) {
             const container = graphic.containers[containerId];
             if (container) {
-                geom = new ThreeGeometryCreator().createGeometry(container, color);
+                geom = new ThreeGeometryCreator_1.ThreeGeometryCreator().createGeometry(container, color);
                 set(state => {
                     const geometryCache = Object.assign(Object.assign({}, state.geometry.cache), { [containerId]: geom });
                     return {
@@ -84,3 +107,4 @@ export const geometryApi = (set, get) => ({
         });
     },
 });
+exports.geometryApi = geometryApi;

package/build/{store → cjs/store}/states/graphic.js

@@ -1,13 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphicApi = exports.graphicData = void 0;
 ////////////////////////////////////////////////////
 // DATA
 ////////////////////////////////////////////////////
-export const graphicData = () => ({
+const graphicData = () => ({
     containers: {},
 });
+exports.graphicData = graphicData;
 ////////////////////////////////////////////////////
 // API
 ////////////////////////////////////////////////////
-export const graphicApi = (set, get) => ({
+const graphicApi = (set, get) => ({
     addPackages: (packages) => {
         // Timing.dump('load', `add graphic packages ${graphic.length} ${graphic[0].containers.length}`)
         let cacheChanged = false;
@@ -80,3 +84,4 @@ export const graphicApi = (set, get) => ({
         }
     },
 });
+exports.graphicApi = graphicApi;

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

@@ -0,0 +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 = 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/{store → cjs/store}/states/plugin.js

@@ -1,5 +1,8 @@
-import { v4 as uuidv4 } from 'uuid';
-export const pluginData = () => ({
+"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: {},
@@ -9,13 +12,10 @@ export const pluginData = () => ({
     },
     visible: [],
 });
-export const pluginApi = (set, get) => ({
+exports.pluginData = pluginData;
+const pluginApi = (set, get) => ({
     setActiveFeature: (id) => {
         set(state => {
-            if (id !== null && state.plugin.feature.indexOf(id) === -1) {
-                console.warn('Given pluginId does not exist.');
-                return 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) {
@@ -31,10 +31,6 @@ export const pluginApi = (set, get) => ({
     },
     setVisiblePlugin: (id, visible) => {
         set(currentState => {
-            if (currentState.plugin.global.indexOf(id) === -1 && currentState.plugin.feature.indexOf(id) === -1) {
-                console.warn('Given plugin id does not exist.');
-                return currentState;
-            }
             const filtered = currentState.plugin.visible.filter(p => p !== id);
             if (visible)
                 filtered.push(id);
@@ -57,8 +53,9 @@ export const pluginApi = (set, get) => ({
             };
         });
     },
+    // TODO remove defaultId and useEmbeddedPlugin ?
     createPlugin: (def, defaultId, drawingId, objectId) => {
-        const id = defaultId !== void 0 ? defaultId : uuidv4();
+        const id = defaultId !== void 0 ? defaultId : uuid_1.v4();
         function init(definition) {
             const { description, Root = null, View = null } = definition;
             const initialState = description.initialState || {};
@@ -109,6 +106,8 @@ export const pluginApi = (set, get) => ({
         };
     },
 });
-export function isPromisePlugin(def) {
+exports.pluginApi = pluginApi;
+function isPromisePlugin(def) {
     return def.then !== undefined;
 }
+exports.isPromisePlugin = isPromisePlugin;