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

package/build/cjs/utils/Measure.js

@@ -1,576 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.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

@@ -1,34 +0,0 @@
-"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/types/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from './ErrorTypes';
-export * from './IGraphicPackage';
-export * from './IStructurePatch';
-export * from './IStructureTree';