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

package/build/cjs/utils/Measure.js

@@ -0,0 +1,576 @@
+"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.Measure = exports.MeasureResultType = void 0;
+/* eslint-disable max-lines */
+const THREE = __importStar(require("three"));
+const store_1 = require("./../store");
+const types_1 = require("./../types");
+var MeasureResultType;
+(function (MeasureResultType) {
+    MeasureResultType["NONE"] = "none";
+    MeasureResultType["DISTANCE"] = "linear";
+    MeasureResultType["ANGLE"] = "angular";
+    MeasureResultType["VECTOR"] = "vector";
+    MeasureResultType["POSITION"] = "position";
+})(MeasureResultType = exports.MeasureResultType || (exports.MeasureResultType = {}));
+const tolerance = 1e-3;
+exports.Measure = {
+    transform(items, drawingId) {
+        const drawing = store_1.getDrawing(drawingId);
+        const transformed = [];
+        for (const item of items) {
+            const matrix = drawing.api.structure.calculateGlobalTransformation(item.productId);
+            const matrix3 = new THREE.Matrix3().setFromMatrix4(matrix);
+            const newItem = Object.assign({}, item);
+            switch (newItem.type) {
+                case types_1.GraphicType.POINT:
+                    const point = newItem;
+                    point.position = point.position.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.LINE:
+                    const line = newItem;
+                    line.start = line.start.clone().applyMatrix4(matrix);
+                    line.end = line.end.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.PLANE:
+                    const plane = newItem;
+                    plane.normal = plane.normal.clone().applyMatrix3(matrix3);
+                    plane.normal.normalize();
+                    plane.pointOnPlane = plane.pointOnPlane.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.CYLINDER:
+                    const cylinder = newItem;
+                    cylinder.axis = cylinder.axis.clone().applyMatrix3(matrix3);
+                    cylinder.axis.normalize();
+                    cylinder.origin = cylinder.origin.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.CONE:
+                    const cone = newItem;
+                    cone.axis = cone.axis.clone().applyMatrix3(matrix3);
+                    cone.axis.normalize();
+                    cone.origin = cone.origin.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.ARC:
+                    const arc = newItem;
+                    arc.normal = arc.normal.clone().applyMatrix3(matrix3);
+                    arc.normal.normalize();
+                    arc.center = arc.center.clone().applyMatrix4(matrix);
+                    break;
+                case types_1.GraphicType.CIRCLE:
+                    const circle = newItem;
+                    circle.normal = circle.normal.clone().applyMatrix3(matrix3);
+                    circle.normal.normalize();
+                    circle.center = circle.center.clone().applyMatrix4(matrix);
+                    break;
+                default:
+                    break;
+            }
+            transformed.push(newItem);
+        }
+        return transformed;
+    },
+    getInfo(objects, drawingId) {
+        const transformed = exports.Measure.transform(objects, drawingId);
+        const results = [];
+        const vecToStr = (point) => `[ ${point
+            .toArray()
+            .map(n => Math.round(n * 100) / 100)
+            .join(', ')} ]`;
+        const dir = (start, end) => end
+            .clone()
+            .sub(start)
+            .normalize();
+        const getPointOnCircumference = (center, axis, radius) => {
+            const axisNormalized = axis.clone().normalize();
+            const helperVec = axisNormalized.x !== 1 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+            const tangent = axisNormalized
+                .clone()
+                .cross(helperVec)
+                .normalize();
+            return center.clone().addScaledVector(tangent, radius);
+        };
+        for (const element of transformed) {
+            switch (element.type) {
+                case types_1.GraphicType.POINT:
+                    const point = element;
+                    results.push({
+                        value: vecToStr(point.position),
+                        description: 'Position',
+                        type: MeasureResultType.POSITION,
+                    });
+                    break;
+                case types_1.GraphicType.LINE:
+                    const line = element;
+                    let absoluteDistance = line.start.distanceTo(line.end);
+                    absoluteDistance = exports.Measure.round(absoluteDistance, 3);
+                    results.push({
+                        value: absoluteDistance,
+                        description: 'Line length',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: line.start.clone(), end: line.end.clone() },
+                    });
+                    break;
+                case types_1.GraphicType.EDGE:
+                    const edge = element;
+                    results.push({
+                        value: vecToStr(edge.start),
+                        description: 'Edge start',
+                        type: MeasureResultType.POSITION,
+                    });
+                    results.push({ value: vecToStr(edge.end), description: 'Edge end', type: MeasureResultType.POSITION });
+                    break;
+                case types_1.GraphicType.ARC:
+                    const arc = element;
+                    const arcNEnd = arc.center.clone().addScaledVector(arc.normal.clone().normalize(), 40);
+                    const pointOnArc = getPointOnCircumference(arc.center, arc.normal, arc.radius);
+                    results.push({
+                        value: vecToStr(arc.center),
+                        description: 'Arc center',
+                        type: MeasureResultType.POSITION,
+                        measureData: { pos: arc.center.clone() },
+                    });
+                    results.push({
+                        value: vecToStr(arc.normal),
+                        description: 'Arc normal',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { start: arc.center.clone(), end: arcNEnd },
+                    });
+                    results.push({
+                        value: arc.radius,
+                        description: 'Arc radius',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: arc.center.clone(), end: pointOnArc },
+                    });
+                    break;
+                case types_1.GraphicType.CIRCLE:
+                    const circle = element;
+                    const circleNEnd = circle.center.clone().addScaledVector(circle.normal.clone().normalize(), 40);
+                    const pointOnCircle = getPointOnCircumference(circle.center, circle.normal, circle.radius);
+                    results.push({
+                        value: vecToStr(circle.center),
+                        description: 'Circle center',
+                        type: MeasureResultType.POSITION,
+                        measureData: { pos: circle.center.clone() },
+                    });
+                    results.push({
+                        value: vecToStr(circle.normal),
+                        description: 'Circle normal',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { start: circle.center.clone(), end: circleNEnd },
+                    });
+                    results.push({
+                        value: circle.radius,
+                        description: 'Circle radius',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: circle.center.clone(), end: pointOnCircle },
+                    });
+                    break;
+                case types_1.GraphicType.PLANE:
+                    const plane = element;
+                    const planeNEnd = plane.pointOnPlane.clone().addScaledVector(plane.normal.clone().normalize(), 40);
+                    results.push({
+                        value: vecToStr(plane.normal),
+                        description: 'Plane normal',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { start: plane.pointOnPlane.clone(), end: planeNEnd },
+                    });
+                    break;
+                case types_1.GraphicType.CYLINDER:
+                    const cylinder = element;
+                    const cylAxisNormalized = cylinder.axis.clone().normalize();
+                    const cylNEnd = cylinder.origin.clone().addScaledVector(cylAxisNormalized, cylinder.height + 40);
+                    const pointOnCyl = getPointOnCircumference(cylinder.origin, cylinder.axis, cylinder.radius);
+                    const cylHStart = cylinder.origin
+                        .clone()
+                        .addScaledVector(dir(cylinder.origin, pointOnCyl), cylinder.radius + 3);
+                    const cylHEnd = cylHStart.clone().addScaledVector(cylAxisNormalized, cylinder.height);
+                    results.push({
+                        value: vecToStr(cylinder.origin),
+                        description: 'Cylinder origin',
+                        type: MeasureResultType.POSITION,
+                        measureData: { pos: cylinder.origin.clone() },
+                    });
+                    results.push({
+                        value: vecToStr(cylinder.axis),
+                        description: 'Cylinder axis',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { start: cylinder.origin.clone(), end: cylNEnd },
+                    });
+                    results.push({
+                        value: cylinder.radius,
+                        description: 'Cylinder radius',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: cylinder.origin.clone(), end: pointOnCyl },
+                    });
+                    results.push({
+                        value: cylinder.height,
+                        description: 'Cylinder height',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: cylHStart, end: cylHEnd },
+                    });
+                    break;
+                case types_1.GraphicType.CONE:
+                    const cone = element;
+                    const isExpanding = cone.radiusBottom < cone.radiusTop;
+                    const R = Math.max(cone.radiusBottom, cone.radiusTop);
+                    const r = Math.min(cone.radiusBottom, cone.radiusTop);
+                    const coneAxisNormalized = cone.axis.clone().normalize();
+                    const coneCenterTop = cone.origin.clone().addScaledVector(coneAxisNormalized, cone.height);
+                    const coneEnd = coneCenterTop.clone().addScaledVector(coneAxisNormalized, 40);
+                    const coneCenterMinR = isExpanding ? cone.origin.clone() : coneCenterTop.clone();
+                    const coneCenterMaxR = isExpanding ? coneCenterTop.clone() : cone.origin.clone();
+                    const pointOnConeBottom = getPointOnCircumference(cone.origin, cone.axis, cone.radiusBottom);
+                    const pointOnConeTop = getPointOnCircumference(coneCenterTop, cone.axis, cone.radiusTop);
+                    const pointOnConeMinR = isExpanding ? pointOnConeBottom : pointOnConeTop;
+                    const pointOnConeMaxR = isExpanding ? pointOnConeTop : pointOnConeBottom;
+                    const coneHStart = coneCenterMaxR.clone().addScaledVector(dir(coneCenterMaxR, pointOnConeMaxR), R + 3);
+                    const coneHEnd = coneHStart
+                        .clone()
+                        .addScaledVector(coneAxisNormalized, isExpanding ? -cone.height : cone.height);
+                    results.push({
+                        value: vecToStr(cone.origin),
+                        description: 'Cone origin',
+                        type: MeasureResultType.POSITION,
+                        measureData: { pos: cone.origin.clone() },
+                    });
+                    results.push({
+                        value: vecToStr(cone.axis),
+                        description: 'Cone axis',
+                        type: MeasureResultType.VECTOR,
+                        measureData: { start: cone.origin.clone(), end: coneEnd },
+                    });
+                    results.push({
+                        value: r,
+                        description: 'Cone radius (min)',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: coneCenterMinR, end: pointOnConeMinR },
+                    });
+                    results.push({
+                        value: R,
+                        description: 'Cone radius (max)',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: coneCenterMaxR, end: pointOnConeMaxR },
+                    });
+                    results.push({
+                        value: cone.height,
+                        description: 'Cone height',
+                        type: MeasureResultType.DISTANCE,
+                        measureData: { start: coneHStart, end: coneHEnd },
+                    });
+                    break;
+                case types_1.GraphicType.SPHERE:
+                    const sphere = element;
+                    results.push({ value: sphere.radius, description: 'Sphere radius', type: MeasureResultType.DISTANCE });
+                    break;
+                case types_1.GraphicType.NURBS:
+                    results.push({ value: '', description: 'NURBS', type: MeasureResultType.NONE });
+                    break;
+                case types_1.GraphicType.NURBSSURFACE:
+                    results.push({ value: '', description: 'NURBS Surface', type: MeasureResultType.NONE });
+                    break;
+                default:
+                    results.push({ value: '', description: 'Undefined', type: MeasureResultType.NONE });
+                    break;
+            }
+        }
+        return results;
+    },
+    calculateMeasures(objects, drawingId) {
+        const transformed = exports.Measure.transform(objects, drawingId);
+        const first = transformed[0];
+        const second = transformed[1];
+        let results = [];
+        switch (first.type) {
+            case types_1.GraphicType.POINT:
+                switch (second.type) {
+                    case types_1.GraphicType.POINT:
+                        results = exports.Measure.calculatePointPoint(first, second);
+                        break;
+                    case types_1.GraphicType.LINE:
+                        results = exports.Measure.calculatePointLine(first, second);
+                        break;
+                    case types_1.GraphicType.PLANE:
+                        results = exports.Measure.calculatePointPlane(first, second);
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case types_1.GraphicType.LINE:
+                switch (second.type) {
+                    case types_1.GraphicType.POINT:
+                        results = exports.Measure.calculatePointLine(second, first);
+                        break;
+                    case types_1.GraphicType.LINE:
+                        results = exports.Measure.calculateLineLine(first, second);
+                        break;
+                    case types_1.GraphicType.PLANE:
+                        results = exports.Measure.calculateLinePlane(first, second);
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            case types_1.GraphicType.PLANE:
+                switch (second.type) {
+                    case types_1.GraphicType.POINT:
+                        results = exports.Measure.calculatePointPlane(second, first);
+                        break;
+                    case types_1.GraphicType.LINE:
+                        results = exports.Measure.calculateLinePlane(second, first);
+                        break;
+                    case types_1.GraphicType.ARC:
+                        results = exports.Measure.calculateArcPlane(second, first);
+                        break;
+                    case types_1.GraphicType.PLANE:
+                        results = exports.Measure.calculatePlanePlane(first, second);
+                        break;
+                    default:
+                        results = exports.Measure.getInfo(objects, drawingId);
+                        break;
+                }
+                break;
+            default:
+                results = exports.Measure.getInfo(objects, drawingId);
+                break;
+        }
+        return results;
+    },
+    calculatePointPoint(point1, point2) {
+        let distance = point1.position.distanceTo(point2.position);
+        distance = exports.Measure.round(distance, 3);
+        const dx = exports.Measure.round(Math.abs(point1.position.x - point2.position.x), 3);
+        const dy = exports.Measure.round(Math.abs(point1.position.y - point2.position.y), 3);
+        const dz = exports.Measure.round(Math.abs(point1.position.z - point2.position.z), 3);
+        const p1 = point1.position.clone();
+        const p2 = point2.position.clone();
+        const px = p1.clone().setX(p2.x);
+        const pxy = px.clone().setY(p2.y);
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: { start: p1, end: p2 },
+            },
+            { value: dx, description: 'dx', type: MeasureResultType.DISTANCE, measureData: { start: p1, end: px } },
+            { value: dy, description: 'dy', type: MeasureResultType.DISTANCE, measureData: { start: px, end: pxy } },
+            { value: dz, description: 'dz', type: MeasureResultType.DISTANCE, measureData: { start: pxy, end: p2 } },
+        ];
+    },
+    calculatePointLine(point, line) {
+        const [start, end] = exports.Measure.getPointLineMPoints(point.position, line.start, line.end);
+        const distance = exports.Measure.round(start.distanceTo(end), 3);
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: { start, end },
+            },
+        ];
+    },
+    calculatePointPlane(point, plane) {
+        const [start, end] = exports.Measure.getPointPlaneMPoints(point.position, plane.pointOnPlane, plane.normal);
+        const distance = exports.Measure.round(start.distanceTo(end), 3);
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: { start, end },
+            },
+        ];
+    },
+    calculateLineLine(first, second) {
+        const [start, end] = exports.Measure.getLineLineMPoints(first.start, first.end, second.start, second.end);
+        const distance = start && end ? exports.Measure.round(start.distanceTo(end), 3) : NaN;
+        const [dir1, dir2] = exports.Measure.getLineLineMDirs(first.start, first.end, second.start, second.end);
+        const angle = exports.Measure.round(exports.Measure.degrees(dir1.angleTo(dir2)), 3);
+        const angleS = 180 - angle;
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { start, end } : undefined,
+            },
+            {
+                value: angle,
+                description: 'Angle1',
+                type: MeasureResultType.ANGLE,
+                measureData: { center: first.start, dir1, dir2 },
+            },
+            {
+                value: angleS,
+                description: 'Angle2',
+                type: MeasureResultType.ANGLE,
+                measureData: { center: first.start, dir1, dir2: dir2.clone().negate() },
+            },
+        ];
+    },
+    calculateLinePlane(line, plane) {
+        const [start, end] = exports.Measure.getLinePlaneMPoints(line.start, line.end, plane.pointOnPlane, plane.normal);
+        const distance = start && end ? exports.Measure.round(start.distanceTo(end), 3) : NaN;
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { start, end } : undefined,
+            },
+        ];
+    },
+    calculateArcPlane(arc, plane) {
+        const [start, end] = exports.Measure.getArcPlaneMPoints(arc.center, arc.normal, plane.pointOnPlane, plane.normal);
+        const distance = start && end ? exports.Measure.round(start.distanceTo(end), 3) : NaN;
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { start, end } : undefined,
+            },
+        ];
+    },
+    calculatePlanePlane(plane1, plane2) {
+        const [start, end] = exports.Measure.getPlanePlaneMPoints(plane1.pointOnPlane, plane1.normal, plane2.pointOnPlane, plane2.normal);
+        const distance = start && end ? exports.Measure.round(start.distanceTo(end), 3) : NaN;
+        const [dir1, dir2] = exports.Measure.getPlanePlaneMDirs(plane1.normal, plane2.normal);
+        const angle = dir1 && dir2
+            ? exports.Measure.round(exports.Measure.degrees(dir1.angleTo(dir2)), 3)
+            : exports.Measure.round(exports.Measure.degrees(plane1.normal.angleTo(plane2.normal)), 3);
+        return [
+            {
+                value: distance,
+                description: 'Distance',
+                type: MeasureResultType.DISTANCE,
+                measureData: start && end ? { start, end } : undefined,
+            },
+            {
+                value: angle,
+                description: 'Angle',
+                type: MeasureResultType.ANGLE,
+                measureData: dir1 && dir2 ? { center: plane1.pointOnPlane.clone(), dir1, dir2 } : undefined,
+            },
+        ];
+    },
+    degrees(radians) {
+        return (radians / Math.PI) * 180;
+    },
+    round(value, digits) {
+        if (isNaN(value))
+            return NaN;
+        const factor = Math.pow(10, digits);
+        return Math.round(value * factor) / factor;
+    },
+    areParallel(vec1, vec2) {
+        const val = Math.abs(vec1
+            .clone()
+            .cross(vec2)
+            .length());
+        return val < tolerance;
+    },
+    arePerpendicular(vec1, vec2) {
+        const val = Math.abs(vec1
+            .clone()
+            .normalize()
+            .dot(vec2.clone().normalize()));
+        return val < tolerance;
+    },
+    getPointLineMPoints(pointsPos, startPos, endPos) {
+        const p1 = pointsPos.clone();
+        const lineDir = endPos.clone().sub(startPos);
+        const p2 = pointsPos
+            .clone()
+            .sub(startPos)
+            .projectOnVector(lineDir)
+            .add(startPos);
+        return [p1, p2];
+    },
+    getPointPlaneMPoints(pointPos, pointOnPlane, normal) {
+        const p1 = pointPos.clone();
+        const offsetV = pointPos
+            .clone()
+            .sub(pointOnPlane)
+            .projectOnVector(normal);
+        const p2 = pointPos.clone().sub(offsetV);
+        return [p1, p2];
+    },
+    getLineLineMPoints(start1Pos, end1Pos, start2Pos, end2Pos) {
+        const vec1 = start1Pos.clone().sub(end1Pos);
+        const vec2 = start2Pos.clone().sub(end2Pos);
+        if (exports.Measure.areParallel(vec1, vec2)) {
+            // lines are parallel
+            const vecAB = start1Pos.clone().sub(start2Pos);
+            if (!exports.Measure.areParallel(vecAB, vec1)) {
+                // lines are not conincident
+                return exports.Measure.getPointLineMPoints(start1Pos, start2Pos, end2Pos);
+            }
+        }
+        return [undefined, undefined];
+    },
+    getLinePlaneMPoints(startPos, endPos, pointOnPlane, normal) {
+        const vec = startPos.clone().sub(endPos);
+        if (exports.Measure.arePerpendicular(vec, normal)) {
+            // line is perpendicular to plane normal
+            return exports.Measure.getPointPlaneMPoints(startPos, pointOnPlane, normal);
+        }
+        return [undefined, undefined];
+    },
+    getArcPlaneMPoints(arcCenter, arcNormal, pointOnPlane, planeNormal) {
+        if (exports.Measure.areParallel(arcNormal, planeNormal)) {
+            // parallel
+            return exports.Measure.getPointPlaneMPoints(arcCenter, pointOnPlane, planeNormal);
+        }
+        return [undefined, undefined];
+    },
+    getPlanePlaneMPoints(pointOnPlane1, normal1, pointOnPlane2, normal2) {
+        if (exports.Measure.areParallel(normal1, normal2)) {
+            // parallel
+            return exports.Measure.getPointPlaneMPoints(pointOnPlane1, pointOnPlane2, normal2);
+        }
+        return [undefined, undefined];
+    },
+    getLineLineMDirs(start1Pos, end1Pos, start2Pos, end2Pos) {
+        const vec1 = end1Pos.clone().sub(start1Pos);
+        const vec2 = end2Pos.clone().sub(start2Pos);
+        return [vec1, vec2];
+    },
+    getPlanePlaneMDirs(normal1, normal2) {
+        if (!exports.Measure.areParallel(normal1, normal2)) {
+            const tangent1 = normal1
+                .clone()
+                .projectOnPlane(normal2)
+                .normalize();
+            const tangent2 = normal2
+                .clone()
+                .projectOnPlane(normal1)
+                .normalize();
+            const angle = tangent1.angleTo(tangent2);
+            return angle <= Math.PI / 2 ? [tangent1, tangent2] : [tangent1, tangent2.negate()];
+        }
+        return [undefined, undefined];
+    },
+};

package/build/cjs/utils/Timing.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timing = void 0;
+const uuid_1 = require("uuid");
+const cache = {};
+const start = (key = uuid_1.v4()) => {
+    cache[key] = { startTime: performance.now(), previousTime: performance.now() };
+    return key;
+};
+const measure = (key, mode = 'fromStart') => {
+    if (!cache[key])
+        return Number.NaN;
+    const curr = performance.now();
+    const prev = mode === 'fromPrevious' ? cache[key].previousTime : cache[key].startTime;
+    cache[key] = Object.assign(Object.assign({}, cache[key]), { previousTime: curr });
+    return curr - prev;
+};
+const stop = (key) => {
+    if (!cache[key])
+        return Number.NaN;
+    const curr = performance.now();
+    const prev = cache[key].startTime;
+    delete cache[key];
+    return curr - prev;
+};
+const dump = (key, message = '', mode = 'fromStart') => {
+    console.info(`${message ? message : key + ':'} ${measure(key, mode).toFixed(2)}ms`);
+};
+exports.Timing = {
+    start,
+    stop,
+    measure,
+    dump,
+};

package/build/{index.js → esm/index.js}

@@ -4,4 +4,5 @@ export * from './types';
 export * from './utils/Math';
 export * from './utils/Measure';
 export * from './utils/Timing';
+export * from './store/subscribtion/subscribeToDrawing';
 //#endregion Re-export type definitions

package/build/{store → esm/store}/index.js

@@ -3,9 +3,13 @@ function getDrawing(id) {
     const { drawing } = api.getState();
     return drawing.refs[id];
 }
+/**
+ * @returns PluginState or undefined if either drawing or plugin don't exist
+ */
 function getPlugin(drawingId, pluginId) {
+    var _a;
     const { drawing } = api.getState();
-    return drawing.refs[drawingId].plugin.refs[pluginId];
+    return (_a = drawing.refs[drawingId]) === null || _a === void 0 ? void 0 : _a.plugin.refs[pluginId];
 }
 function init(sel) {
     api.getState().api.init(typeof sel === 'function' ? sel(api.getState()) || {} : sel);

package/build/{store → esm/store}/states/plugin.js

@@ -12,10 +12,6 @@ export const pluginData = () => ({
 export 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 +27,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,6 +49,7 @@ export const pluginApi = (set, get) => ({
             };
         });
     },
+    // TODO remove defaultId and useEmbeddedPlugin ?
     createPlugin: (def, defaultId, drawingId, objectId) => {
         const id = defaultId !== void 0 ? defaultId : uuidv4();
         function init(definition) {