@buerli.io/core 0.5.0-beta.1 → 0.5.0-beta.2

package/build/cjs/geometry/ThreeGeometryCreator.js

@@ -0,0 +1,321 @@
+"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.isEqualGeometry = exports.EMPTY_CONTAINER_GEOMETRY = exports.ThreeGeometryCreator = void 0;
+const THREE = __importStar(require("three"));
+const types_1 = require("./../types");
+const convertType = (contType) => {
+    let type = types_1.GraphicType.NONE;
+    switch (contType) {
+        case types_1.ContainerType.BREP:
+            type = types_1.GraphicType.BREP;
+            break;
+        case types_1.ContainerType.CURVEARRAY:
+            type = types_1.GraphicType.CURVEARRAY;
+            break;
+        case types_1.ContainerType.POLYBREP:
+            type = types_1.GraphicType.POLYBREP;
+            break;
+    }
+    return type;
+};
+/**
+ * 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) {
+        var _a;
+        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, type: convertType(container.type) },
+            operationId: (_a = geometry === null || geometry === void 0 ? void 0 : geometry.properties) === null || _a === void 0 ? void 0 : _a.operationId,
+            rawGraphic: geometry,
+        };
+    }
+    createGeometry(container, color = [0, 0, 0]) {
+        const { id: graphicId, properties, type: contType } = container;
+        const type = convertType(contType);
+        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,
+            type,
+            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;
+        let type = types_1.GraphicType.LINE;
+        if (container.type === types_1.ContainerType.CURVEARRAY) {
+            type = types_1.GraphicType.CURVELINE;
+        }
+        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: 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;
+        let type = types_1.GraphicType.EDGE;
+        if (container.type === types_1.ContainerType.CURVEARRAY) {
+            type = types_1.GraphicType.CURVESPLINE;
+        }
+        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: type }, this.getMetadata(edge, container, color)), { start: start.clone(), end: end.clone() });
+    }
+    createArc(arc, container, points, color = [0, 0, 0]) {
+        const graphicId = arc.id;
+        let type = arc.isCircle ? types_1.GraphicType.CIRCLE : types_1.GraphicType.ARC;
+        if (container.type === types_1.ContainerType.CURVEARRAY) {
+            type = arc.isCircle ? types_1.GraphicType.CURVECIRCLE : types_1.GraphicType.CURVEARC;
+        }
+        // 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: 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: (container.type === types_1.ContainerType.CURVEARRAY ? types_1.GraphicType.CURVEPOINT : 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,
+        type: types_1.GraphicType.NONE,
+        map: {},
+        meshes: [],
+        lines: [],
+        edges: [],
+        arcs: [],
+        points: [],
+        box: { min: new THREE.Vector3(), max: new THREE.Vector3() },
+        container: { id: Number.NaN, ownerId: Number.NaN, type: types_1.GraphicType.NONE },
+        color: new THREE.Color(),
+        opacity: 1.0,
+        layer: null,
+        operationId: Number.NaN,
+        rawGraphic: 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,17 @@
+"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 __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/graphic/filters.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solidFilter = exports.loopFilter = exports.planeFilter = exports.meshFilter = exports.pointFilter = exports.arcCircleFilter = exports.circleFilter = exports.arcFilter = exports.lineSegmentsFilter = exports.lineFilter = void 0;
+const IGraphicPackage_1 = require("../types/IGraphicPackage");
+const selection_1 = require("../store/states/selection");
+const lineFilter = (scope, data) => scope === selection_1.BuerliScope && (data === IGraphicPackage_1.GraphicType.LINE || data === IGraphicPackage_1.GraphicType.EDGE);
+exports.lineFilter = lineFilter;
+const lineSegmentsFilter = (scope, data) => scope === selection_1.BuerliScope && IGraphicPackage_1.LineSegments.includes(data);
+exports.lineSegmentsFilter = lineSegmentsFilter;
+const arcFilter = (scope, data) => scope === selection_1.BuerliScope && data === IGraphicPackage_1.GraphicType.ARC;
+exports.arcFilter = arcFilter;
+const circleFilter = (scope, data) => scope === selection_1.BuerliScope && data === IGraphicPackage_1.GraphicType.CIRCLE;
+exports.circleFilter = circleFilter;
+const arcCircleFilter = (scope, data) => scope === selection_1.BuerliScope && (data === IGraphicPackage_1.GraphicType.ARC || data === IGraphicPackage_1.GraphicType.CIRCLE);
+exports.arcCircleFilter = arcCircleFilter;
+const pointFilter = (scope, data) => scope === selection_1.BuerliScope && data === IGraphicPackage_1.GraphicType.POINT;
+exports.pointFilter = pointFilter;
+const meshFilter = (scope, data) => scope === selection_1.BuerliScope && IGraphicPackage_1.Surfaces.includes(data);
+exports.meshFilter = meshFilter;
+const planeFilter = (scope, data) => scope === selection_1.BuerliScope && data === IGraphicPackage_1.GraphicType.PLANE;
+exports.planeFilter = planeFilter;
+const loopFilter = (scope, data) => scope === selection_1.BuerliScope && data === IGraphicPackage_1.GraphicType.LOOP;
+exports.loopFilter = loopFilter;
+const solidFilter = (scope, data) => scope === selection_1.BuerliScope && data === IGraphicPackage_1.GraphicType.BREP;
+exports.solidFilter = solidFilter;

package/build/cjs/index.js

@@ -0,0 +1,25 @@
+"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 __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);
+__exportStar(require("./graphic/filters"), exports);
+//#endregion Re-export type definitions

package/build/cjs/store/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateMessage = exports.showMessage = exports.init = exports.getPlugin = exports.getDrawing = exports.api = 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(options) {
+    store_1.api.getState().api.init(options);
+}
+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; } });
+var store_2 = require("./store");
+Object.defineProperty(exports, "api", { enumerable: true, get: function () { return store_2.api; } });

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawingManagementApi = exports.generalApi = 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, buerliApi) => (Object.assign({ initDone: false, options: {
+        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({}, (0, exports.generalApi)(set, get, buerliApi)), (0, exports.drawingManagementApi)(set, get, buerliApi)) }, (0, message_1.getInitialMessageState)(set, get, buerliApi)));
+exports.createState = createState;
+const generalApi = set => ({
+    // 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 }));
+    },
+});
+exports.generalApi = generalApi;
+const drawingManagementApi = (set, get, buerliApi) => ({
+    async createDrawing(name) {
+        const { initDone, drawing } = get();
+        if (!initDone)
+            throw new Error(initError);
+        const drawingState = (0, 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], buerliApi, 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 }) });
+    },
+});
+exports.drawingManagementApi = drawingManagementApi;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cadApi = exports.cadData = void 0;
+const uuid_1 = require("uuid");
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+const cadData = () => ({
+    connected: false,
+    states: { current: 0, stack: [], captionMap: {} },
+    pending: [],
+});
+exports.cadData = cadData;
+////////////////////////////////////////////////////
+// API
+////////////////////////////////////////////////////
+const cadApi = (set, get, buerliApi) => ({
+    setStates: (current, stack, captionMap) => set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { states: Object.assign(Object.assign({}, state.cad.states), { current, stack, captionMap }) }) })),
+    setCaptionMap: (captionMap) => set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { states: Object.assign(Object.assign({}, state.cad.states), { captionMap }) }) })),
+    addPending: (name, options) => {
+        const id = (0, uuid_1.v4)();
+        set(state => ({
+            cad: Object.assign(Object.assign({}, state.cad), { pending: [...state.cad.pending, Object.assign(Object.assign({}, options), { id, name, stamp: Date.now() })] }),
+        }));
+        return id;
+    },
+    removePending: (id) => {
+        const newPending = get().cad.pending.filter(p => p.id !== id);
+        set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { pending: newPending }) }));
+    },
+    setConnected: (connected) => {
+        return set(state => ({ cad: Object.assign(Object.assign({}, state.cad), { connected }) }));
+    },
+});
+exports.cadApi = cadApi;

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

@@ -0,0 +1,47 @@
+"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 cad_1 = require("./cad");
+const geometry_1 = require("./geometry");
+const graphic_1 = require("./graphic");
+const interaction_1 = require("./interaction");
+const plugin_1 = require("./plugin");
+const selection_1 = require("./selection");
+const structure_1 = require("./structure");
+////////////////////////////////////////////////////
+// DATA
+////////////////////////////////////////////////////
+const createDrawingState = (set, get, buerliApi, drawingNumber, name) => {
+    const drawingId = (0, uuid_1.v4)();
+    return {
+        structure: (0, structure_1.structureData)(),
+        selection: (0, selection_1.selectionData)(),
+        interaction: (0, interaction_1.interactionData)(),
+        plugin: (0, plugin_1.pluginData)(),
+        geometry: (0, geometry_1.geometryData)(),
+        graphic: (0, graphic_1.graphicData)(),
+        cad: (0, cad_1.cadData)(),
+        api: {
+            structure: (0, structure_1.structureApi)(set, get, buerliApi),
+            selection: (0, selection_1.selectionApi)(set, get, buerliApi),
+            plugin: (0, plugin_1.pluginApi)(set, get, buerliApi),
+            geometry: (0, geometry_1.geometryApi)(set, get, buerliApi),
+            graphic: (0, graphic_1.graphicApi)(set, get, buerliApi),
+            cad: (0, cad_1.cadApi)(set, get, buerliApi),
+            interaction: (0, interaction_1.interactionApi)(set, get, buerliApi),
+        },
+        id: drawingId,
+        name: name || `Drawing #${drawingNumber}`,
+    };
+};
+exports.createDrawingState = createDrawingState;