js-draw 0.25.0 → 1.0.0

package/dist/mjs/components/builders/PressureSensitiveFreehandLineBuilder.mjs

@@ -1,35 +1,23 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { Bezier } from 'bezier-js';
-import  { Vec2 }  from '../../math/Vec2.mjs';
-import  Rect2  from '../../math/shapes/Rect2.mjs';
-import  { PathCommandType }  from '../../math/shapes/Path.mjs';
+import { Vec2, Rect2, PathCommandType } from '@js-draw/math';
 import  Stroke  from '../Stroke.mjs';
 import  Viewport  from '../../Viewport.mjs';
 import  { StrokeSmoother }  from '../util/StrokeSmoother.mjs';
-export var makePressureSensitiveFreehandLineBuilder = function (initialPoint, viewport) {
+export const makePressureSensitiveFreehandLineBuilder = (initialPoint, viewport) => {
     // Don't smooth if input is more than ± 3 pixels from the true curve, do smooth if
     // less than ±1 px from the curve.
-    var maxSmoothingDist = viewport.getSizeOfPixelOnCanvas() * 3;
-    var minSmoothingDist = viewport.getSizeOfPixelOnCanvas();
+    const maxSmoothingDist = viewport.getSizeOfPixelOnCanvas() * 3;
+    const minSmoothingDist = viewport.getSizeOfPixelOnCanvas();
     return new PressureSensitiveFreehandLineBuilder(initialPoint, minSmoothingDist, maxSmoothingDist, viewport);
 };
 // Handles stroke smoothing and creates Strokes from user/stylus input.
-var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
-    function PressureSensitiveFreehandLineBuilder(startPoint, 
+export default class PressureSensitiveFreehandLineBuilder {
+    constructor(startPoint, 
     // Maximum distance from the actual curve (irrespective of stroke width)
     // for which a point is considered 'part of the curve'.
     // Note that the maximum will be smaller if the stroke width is less than
     // [maxFitAllowed].
     minFitAllowed, maxFitAllowed, viewport) {
-        var _this = this;
         this.startPoint = startPoint;
         this.minFitAllowed = minFitAllowed;
         this.viewport = viewport;
@@ -41,32 +29,30 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
         this.parts = [];
         this.upperSegments = [];
         this.lowerSegments = [];
-        this.curveFitter = new StrokeSmoother(startPoint, minFitAllowed, maxFitAllowed, function (curve) { return _this.addCurve(curve); });
+        this.curveFitter = new StrokeSmoother(startPoint, minFitAllowed, maxFitAllowed, curve => this.addCurve(curve));
         this.curveStartWidth = startPoint.width;
         this.bbox = new Rect2(this.startPoint.pos.x, this.startPoint.pos.y, 0, 0);
     }
-    PressureSensitiveFreehandLineBuilder.prototype.getBBox = function () {
+    getBBox() {
         return this.bbox;
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.getRenderingStyle = function () {
-        var _a;
+    }
+    getRenderingStyle() {
         return {
-            fill: (_a = this.startPoint.color) !== null && _a !== void 0 ? _a : null,
+            fill: this.startPoint.color ?? null,
         };
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.previewCurrentPath = function () {
-        var _a;
-        var upperPath = this.upperSegments.slice();
-        var lowerPath = this.lowerSegments.slice();
-        var lowerToUpperCap;
-        var pathStartConnector;
-        var currentCurve = this.curveFitter.preview();
+    }
+    previewCurrentPath() {
+        const upperPath = this.upperSegments.slice();
+        const lowerPath = this.lowerSegments.slice();
+        let lowerToUpperCap;
+        let pathStartConnector;
+        const currentCurve = this.curveFitter.preview();
         if (currentCurve) {
-            var _b = this.segmentToPath(currentCurve), upperCurveCommand = _b.upperCurveCommand, lowerToUpperConnector = _b.lowerToUpperConnector, upperToLowerConnector = _b.upperToLowerConnector, lowerCurveCommand = _b.lowerCurveCommand;
+            const { upperCurveCommand, lowerToUpperConnector, upperToLowerConnector, lowerCurveCommand } = this.segmentToPath(currentCurve);
             upperPath.push(upperCurveCommand);
             lowerPath.push(lowerCurveCommand);
             lowerToUpperCap = lowerToUpperConnector;
-            pathStartConnector = (_a = this.pathStartConnector) !== null && _a !== void 0 ? _a : upperToLowerConnector;
+            pathStartConnector = this.pathStartConnector ?? upperToLowerConnector;
         }
         else {
             if (this.mostRecentConnector === null || this.pathStartConnector === null) {
@@ -75,8 +61,8 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
             lowerToUpperCap = this.mostRecentConnector;
             pathStartConnector = this.pathStartConnector;
         }
-        var startPoint;
-        var lastLowerSegment = lowerPath[lowerPath.length - 1];
+        let startPoint;
+        const lastLowerSegment = lowerPath[lowerPath.length - 1];
         if (lastLowerSegment.kind === PathCommandType.LineTo || lastLowerSegment.kind === PathCommandType.MoveTo) {
             startPoint = lastLowerSegment.point;
         }
@@ -91,88 +77,96 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
             // /___ /
             //  ↑
             //  Oldest points
-            startPoint: startPoint,
-            commands: __spreadArray(__spreadArray(__spreadArray([
+            startPoint,
+            commands: [
                 // Move to the most recent point on the upperPath:
                 //     ----→•
                 //  __/  __/
                 // /___ /
-                lowerToUpperCap
-            ], upperPath.reverse(), true), [
+                lowerToUpperCap,
+                // Move to the beginning of the upperPath:
+                //  __/  __/
+                // /___ /
+                //     • ←-
+                ...upperPath.reverse(),
                 // Move to the beginning of the lowerPath:
                 //  __/  __/
                 // /___ /
                 // •
-                pathStartConnector
-            ], false), lowerPath, true),
+                pathStartConnector,
+                // Move back to the start point:
+                //     •
+                //  __/  __/
+                // /___ /
+                ...lowerPath,
+            ],
             style: this.getRenderingStyle(),
         };
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.previewFullPath = function () {
-        var preview = this.previewCurrentPath();
+    }
+    previewFullPath() {
+        const preview = this.previewCurrentPath();
         if (preview) {
-            return __spreadArray(__spreadArray([], this.parts, true), [preview], false);
+            return [...this.parts, preview];
         }
         return null;
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.previewStroke = function () {
-        var pathPreview = this.previewFullPath();
+    }
+    previewStroke() {
+        const pathPreview = this.previewFullPath();
         if (pathPreview) {
             return new Stroke(pathPreview);
         }
         return null;
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.preview = function (renderer) {
-        var paths = this.previewFullPath();
+    }
+    preview(renderer) {
+        const paths = this.previewFullPath();
         if (paths) {
-            var approxBBox = this.viewport.visibleRect;
+            const approxBBox = this.viewport.visibleRect;
             renderer.startObject(approxBBox);
-            for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
-                var path = paths_1[_i];
+            for (const path of paths) {
                 renderer.drawPath(path);
             }
             renderer.endObject();
         }
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.build = function () {
+    }
+    build() {
         this.curveFitter.finalizeCurrentCurve();
         if (this.isFirstSegment) {
             // Ensure we have something.
             this.addCurve(null);
         }
         return this.previewStroke();
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.roundPoint = function (point) {
-        var minFit = Math.min(this.minFitAllowed, this.curveStartWidth / 3);
+    }
+    roundPoint(point) {
+        let minFit = Math.min(this.minFitAllowed, this.curveStartWidth / 3);
         if (minFit < 1e-10) {
             minFit = this.minFitAllowed;
         }
         return Viewport.roundPoint(point, minFit);
-    };
+    }
     // Returns true if, due to overlap with previous segments, a new RenderablePathSpec should be created.
-    PressureSensitiveFreehandLineBuilder.prototype.shouldStartNewSegment = function (lowerCurve, upperCurve) {
+    shouldStartNewSegment(lowerCurve, upperCurve) {
         if (!this.lastLowerBezier || !this.lastUpperBezier) {
             return false;
         }
-        var getIntersection = function (curve1, curve2) {
-            var intersection = curve1.intersects(curve2);
+        const getIntersection = (curve1, curve2) => {
+            const intersection = curve1.intersects(curve2);
             if (!intersection || intersection.length === 0) {
                 return null;
             }
             // From http://pomax.github.io/bezierjs/#intersect-curve,
             // .intersects returns an array of 't1/t2' pairs, where curve1.at(t1) gives the point.
-            var firstTPair = intersection[0];
-            var match = /^([-0-9.eE]+)\/([-0-9.eE]+)$/.exec(firstTPair);
+            const firstTPair = intersection[0];
+            const match = /^([-0-9.eE]+)\/([-0-9.eE]+)$/.exec(firstTPair);
             if (!match) {
-                throw new Error("Incorrect format returned by .intersects: ".concat(intersection, " should be array of \"number/number\"!"));
+                throw new Error(`Incorrect format returned by .intersects: ${intersection} should be array of "number/number"!`);
             }
-            var t = parseFloat(match[1]);
+            const t = parseFloat(match[1]);
             return Vec2.ofXY(curve1.get(t));
         };
-        var getExitDirection = function (curve) {
+        const getExitDirection = (curve) => {
             return Vec2.ofXY(curve.points[2]).minus(Vec2.ofXY(curve.points[1])).normalized();
         };
-        var getEnterDirection = function (curve) {
+        const getEnterDirection = (curve) => {
             return Vec2.ofXY(curve.points[1]).minus(Vec2.ofXY(curve.points[0])).normalized();
         };
         // Prevent
@@ -197,27 +191,27 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
         // /   / /
         //   //
         // / /
-        var lowerIntersection = getIntersection(lowerCurve, this.lastUpperBezier);
-        var upperIntersection = getIntersection(upperCurve, this.lastLowerBezier);
+        const lowerIntersection = getIntersection(lowerCurve, this.lastUpperBezier);
+        const upperIntersection = getIntersection(upperCurve, this.lastLowerBezier);
         if (lowerIntersection || upperIntersection) {
             return true;
         }
         return false;
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.addCurve = function (curve) {
+    }
+    addCurve(curve) {
         // Case where no points have been added
         if (!curve) {
             // Don't create a circle around the initial point if the stroke has more than one point.
             if (!this.isFirstSegment) {
                 return;
             }
-            var width = Viewport.roundPoint(this.startPoint.width / 2.2, Math.min(this.minFitAllowed, this.startPoint.width / 4));
-            var center = this.roundPoint(this.startPoint.pos);
+            const width = Viewport.roundPoint(this.startPoint.width / 2.2, Math.min(this.minFitAllowed, this.startPoint.width / 4));
+            const center = this.roundPoint(this.startPoint.pos);
             // Start on the right, cycle clockwise:
             //    |
             //  ----- ←
             //    |
-            var startPoint = this.startPoint.pos.plus(Vec2.of(width, 0));
+            const startPoint = this.startPoint.pos.plus(Vec2.of(width, 0));
             // Draw a circle-ish shape around the start point
             this.lowerSegments.push({
                 kind: PathCommandType.QuadraticBezierTo,
@@ -248,10 +242,10 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
             this.mostRecentConnector = this.pathStartConnector;
             return;
         }
-        var _a = this.segmentToPath(curve), upperCurveCommand = _a.upperCurveCommand, lowerToUpperConnector = _a.lowerToUpperConnector, upperToLowerConnector = _a.upperToLowerConnector, lowerCurveCommand = _a.lowerCurveCommand, lowerCurve = _a.lowerCurve, upperCurve = _a.upperCurve;
-        var shouldStartNew = this.shouldStartNewSegment(lowerCurve, upperCurve);
+        const { upperCurveCommand, lowerToUpperConnector, upperToLowerConnector, lowerCurveCommand, lowerCurve, upperCurve, } = this.segmentToPath(curve);
+        const shouldStartNew = this.shouldStartNewSegment(lowerCurve, upperCurve);
         if (shouldStartNew) {
-            var part = this.previewCurrentPath();
+            const part = this.previewCurrentPath();
             if (part) {
                 this.parts.push(part);
                 this.upperSegments = [];
@@ -272,23 +266,23 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
         this.lastLowerBezier = lowerCurve;
         this.lastUpperBezier = upperCurve;
         this.curveStartWidth = curve.startWidth;
-    };
+    }
     // Returns [upper curve, connector, lower curve]
-    PressureSensitiveFreehandLineBuilder.prototype.segmentToPath = function (curve) {
-        var bezier = new Bezier(curve.startPoint.xy, curve.controlPoint.xy, curve.endPoint.xy);
-        var startVec = Vec2.ofXY(bezier.normal(0)).normalized();
-        var endVec = Vec2.ofXY(bezier.normal(1)).normalized();
+    segmentToPath(curve) {
+        const bezier = new Bezier(curve.startPoint.xy, curve.controlPoint.xy, curve.endPoint.xy);
+        let startVec = Vec2.ofXY(bezier.normal(0)).normalized();
+        let endVec = Vec2.ofXY(bezier.normal(1)).normalized();
         startVec = startVec.times(curve.startWidth / 2);
         endVec = endVec.times(curve.endWidth / 2);
         if (!isFinite(startVec.magnitude())) {
             console.error('Warning: startVec is NaN or ∞', startVec, endVec, curve);
             startVec = endVec;
         }
-        var startPt = curve.startPoint;
-        var endPt = curve.endPoint;
-        var controlPoint = curve.controlPoint;
+        const startPt = curve.startPoint;
+        const endPt = curve.endPoint;
+        const controlPoint = curve.controlPoint;
         // Approximate the normal at the location of the control point
-        var projectionT = bezier.project(controlPoint.xy).t;
+        let projectionT = bezier.project(controlPoint.xy).t;
         if (!projectionT) {
             if (startPt.minus(controlPoint).magnitudeSquared() < endPt.minus(controlPoint).magnitudeSquared()) {
                 projectionT = 0.1;
@@ -297,51 +291,45 @@ var PressureSensitiveFreehandLineBuilder = /** @class */ (function () {
                 projectionT = 0.9;
             }
         }
-        var halfVecT = projectionT;
-        var halfVec = Vec2.ofXY(bezier.normal(halfVecT))
+        const halfVecT = projectionT;
+        const halfVec = Vec2.ofXY(bezier.normal(halfVecT))
             .normalized().times(curve.startWidth / 2 * halfVecT
             + curve.endWidth / 2 * (1 - halfVecT));
         // Each starts at startPt ± startVec
-        var lowerCurveStartPoint = this.roundPoint(startPt.plus(startVec));
-        var lowerCurveControlPoint = this.roundPoint(controlPoint.plus(halfVec));
-        var lowerCurveEndPoint = this.roundPoint(endPt.plus(endVec));
-        var upperCurveControlPoint = this.roundPoint(controlPoint.minus(halfVec));
-        var upperCurveStartPoint = this.roundPoint(endPt.minus(endVec));
-        var upperCurveEndPoint = this.roundPoint(startPt.minus(startVec));
-        var lowerCurveCommand = {
+        const lowerCurveStartPoint = this.roundPoint(startPt.plus(startVec));
+        const lowerCurveControlPoint = this.roundPoint(controlPoint.plus(halfVec));
+        const lowerCurveEndPoint = this.roundPoint(endPt.plus(endVec));
+        const upperCurveControlPoint = this.roundPoint(controlPoint.minus(halfVec));
+        const upperCurveStartPoint = this.roundPoint(endPt.minus(endVec));
+        const upperCurveEndPoint = this.roundPoint(startPt.minus(startVec));
+        const lowerCurveCommand = {
             kind: PathCommandType.QuadraticBezierTo,
             controlPoint: lowerCurveControlPoint,
             endPoint: lowerCurveEndPoint,
         };
         // From the end of the upperCurve to the start of the lowerCurve:
-        var upperToLowerConnector = {
+        const upperToLowerConnector = {
             kind: PathCommandType.LineTo,
             point: lowerCurveStartPoint,
         };
         // From the end of lowerCurve to the start of upperCurve:
-        var lowerToUpperConnector = {
+        const lowerToUpperConnector = {
             kind: PathCommandType.LineTo,
             point: upperCurveStartPoint,
         };
-        var upperCurveCommand = {
+        const upperCurveCommand = {
             kind: PathCommandType.QuadraticBezierTo,
             controlPoint: upperCurveControlPoint,
             endPoint: upperCurveEndPoint,
         };
-        var upperCurve = new Bezier(upperCurveStartPoint, upperCurveControlPoint, upperCurveEndPoint);
-        var lowerCurve = new Bezier(lowerCurveStartPoint, lowerCurveControlPoint, lowerCurveEndPoint);
+        const upperCurve = new Bezier(upperCurveStartPoint, upperCurveControlPoint, upperCurveEndPoint);
+        const lowerCurve = new Bezier(lowerCurveStartPoint, lowerCurveControlPoint, lowerCurveEndPoint);
         return {
-            upperCurveCommand: upperCurveCommand,
-            upperToLowerConnector: upperToLowerConnector,
-            lowerToUpperConnector: lowerToUpperConnector,
-            lowerCurveCommand: lowerCurveCommand,
-            upperCurve: upperCurve,
-            lowerCurve: lowerCurve,
+            upperCurveCommand, upperToLowerConnector, lowerToUpperConnector, lowerCurveCommand,
+            upperCurve, lowerCurve,
         };
-    };
-    PressureSensitiveFreehandLineBuilder.prototype.addPoint = function (newPoint) {
+    }
+    addPoint(newPoint) {
         this.curveFitter.addPoint(newPoint);
-    };
-    return PressureSensitiveFreehandLineBuilder;
-}());
-export default PressureSensitiveFreehandLineBuilder;
+    }
+}

package/dist/mjs/components/builders/RectangleBuilder.d.ts

@@ -1,4 +1,4 @@
-import Rect2 from '../../math/shapes/Rect2';
+import { Rect2 } from '@js-draw/math';
 import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
 import { StrokeDataPoint } from '../../types';
 import Viewport from '../../Viewport';

package/dist/mjs/components/builders/RectangleBuilder.mjs

@@ -1,53 +1,49 @@
-import  Mat33  from '../../math/Mat33.mjs';
-import  Path  from '../../math/shapes/Path.mjs';
-import  Rect2  from '../../math/shapes/Rect2.mjs';
+import { Mat33, Rect2, Path } from '@js-draw/math';
+import  { pathToRenderable }  from '../../rendering/RenderablePathSpec.mjs';
 import  Stroke  from '../Stroke.mjs';
-export var makeFilledRectangleBuilder = function (initialPoint, viewport) {
+export const makeFilledRectangleBuilder = (initialPoint, viewport) => {
     return new RectangleBuilder(initialPoint, true, viewport);
 };
-export var makeOutlinedRectangleBuilder = function (initialPoint, viewport) {
+export const makeOutlinedRectangleBuilder = (initialPoint, viewport) => {
     return new RectangleBuilder(initialPoint, false, viewport);
 };
-var RectangleBuilder = /** @class */ (function () {
-    function RectangleBuilder(startPoint, filled, viewport) {
+export default class RectangleBuilder {
+    constructor(startPoint, filled, viewport) {
         this.startPoint = startPoint;
         this.filled = filled;
         this.viewport = viewport;
         // Initially, the start and end points are the same.
         this.endPoint = startPoint;
     }
-    RectangleBuilder.prototype.getBBox = function () {
-        var preview = this.buildPreview();
+    getBBox() {
+        const preview = this.buildPreview();
         return preview.getBBox();
-    };
-    RectangleBuilder.prototype.buildPreview = function () {
-        var _this = this;
-        var canvasAngle = this.viewport.getRotationAngle();
-        var rotationMat = Mat33.zRotation(-canvasAngle);
+    }
+    buildPreview() {
+        const canvasAngle = this.viewport.getRotationAngle();
+        const rotationMat = Mat33.zRotation(-canvasAngle);
         // Adjust startPoint and endPoint such that applying [rotationMat] to them
         // brings them to this.startPoint and this.endPoint.
-        var startPoint = rotationMat.inverse().transformVec2(this.startPoint.pos);
-        var endPoint = rotationMat.inverse().transformVec2(this.endPoint.pos);
-        var rect = Rect2.fromCorners(startPoint, endPoint);
-        var path = Path.fromRect(rect, this.filled ? null : this.endPoint.width).transformedBy(
+        const startPoint = rotationMat.inverse().transformVec2(this.startPoint.pos);
+        const endPoint = rotationMat.inverse().transformVec2(this.endPoint.pos);
+        const rect = Rect2.fromCorners(startPoint, endPoint);
+        const path = Path.fromRect(rect, this.filled ? null : this.endPoint.width).transformedBy(
         // Rotate the canvas rectangle so that its rotation matches the screen
-        rotationMat).mapPoints(function (point) { return _this.viewport.roundPoint(point); });
-        var preview = new Stroke([
-            path.toRenderable({
+        rotationMat).mapPoints(point => this.viewport.roundPoint(point));
+        const preview = new Stroke([
+            pathToRenderable(path, {
                 fill: this.endPoint.color
             }),
         ]);
         return preview;
-    };
-    RectangleBuilder.prototype.build = function () {
+    }
+    build() {
         return this.buildPreview();
-    };
-    RectangleBuilder.prototype.preview = function (renderer) {
+    }
+    preview(renderer) {
         this.buildPreview().render(renderer);
-    };
-    RectangleBuilder.prototype.addPoint = function (point) {
+    }
+    addPoint(point) {
         this.endPoint = point;
-    };
-    return RectangleBuilder;
-}());
-export default RectangleBuilder;
+    }
+}

package/dist/mjs/components/builders/types.d.ts

@@ -1,4 +1,4 @@
-import Rect2 from '../../math/shapes/Rect2';
+import { Rect2 } from '@js-draw/math';
 import AbstractRenderer from '../../rendering/renderers/AbstractRenderer';
 import { StrokeDataPoint } from '../../types';
 import Viewport from '../../Viewport';

package/dist/mjs/components/lib.d.ts

@@ -11,4 +11,6 @@ import ImageComponent from './ImageComponent';
 import RestyleableComponent from './RestylableComponent';
 import { createRestyleComponentCommand, isRestylableComponent, ComponentStyle as RestyleableComponentStyle } from './RestylableComponent';
 import BackgroundComponent from './BackgroundComponent';
-export { Stroke, RestyleableComponent, createRestyleComponentCommand, isRestylableComponent, RestyleableComponentStyle, TextComponent, TextComponent as Text, Stroke as StrokeComponent, BackgroundComponent, ImageComponent, };
+export { Stroke, RestyleableComponent, createRestyleComponentCommand, isRestylableComponent, RestyleableComponentStyle, TextComponent, 
+/** @deprecated use {@link TextComponent} */
+TextComponent as Text, Stroke as StrokeComponent, BackgroundComponent, ImageComponent, };

package/dist/mjs/components/lib.mjs

@@ -11,5 +11,5 @@ import  ImageComponent  from './ImageComponent.mjs';
 import  { createRestyleComponentCommand, isRestylableComponent }  from './RestylableComponent.mjs';
 import  BackgroundComponent  from './BackgroundComponent.mjs';
 export { Stroke, createRestyleComponentCommand, isRestylableComponent, TextComponent, 
-// @deprecated
+/** @deprecated use {@link TextComponent} */
 TextComponent as Text, Stroke as StrokeComponent, BackgroundComponent, ImageComponent, };

package/dist/mjs/components/localization.mjs

@@ -1,11 +1,11 @@
-export var defaultComponentLocalization = {
+export const defaultComponentLocalization = {
     unlabeledImageNode: 'Unlabeled image node',
     stroke: 'Stroke',
     svgObject: 'SVG Object',
     emptyBackground: 'Empty background',
     gridBackground: 'Grid background',
-    filledBackgroundWithColor: function (color) { return "Filled background (".concat(color, ")"); },
-    text: function (text) { return "Text object: ".concat(text); },
-    imageNode: function (description) { return "Image: ".concat(description); },
-    restyledElement: function (elementDescription) { return "Restyled ".concat(elementDescription); },
+    filledBackgroundWithColor: (color) => `Filled background (${color})`,
+    text: (text) => `Text object: ${text}`,
+    imageNode: (description) => `Image: ${description}`,
+    restyledElement: (elementDescription) => `Restyled ${elementDescription}`,
 };

package/dist/mjs/components/util/StrokeSmoother.d.ts

@@ -1,5 +1,4 @@
-import { Vec2 } from '../../math/Vec2';
-import Rect2 from '../../math/shapes/Rect2';
+import { Vec2, Rect2 } from '@js-draw/math';
 import { StrokeDataPoint } from '../../types';
 export interface Curve {
     startPoint: Vec2;