js-draw 0.25.1 → 1.0.0

package/dist/mjs/components/Stroke.mjs

@@ -1,34 +1,8 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import  Path  from '../math/shapes/Path.mjs';
-import  Rect2  from '../math/shapes/Rect2.mjs';
+import { Path, Rect2 } from '@js-draw/math';
 import  { styleFromJSON, styleToJSON }  from '../rendering/RenderingStyle.mjs';
 import  AbstractComponent  from './AbstractComponent.mjs';
 import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
+import  { pathFromRenderable, pathToRenderable }  from '../rendering/RenderablePathSpec.mjs';
 /**
  * Represents an {@link AbstractComponent} made up of one or more {@link Path}s.
  *
@@ -45,8 +19,7 @@ import  { createRestyleComponentCommand }  from './RestylableComponent.mjs';
  * editor.dispatch(stroke.transformBy(Mat33.translation(Vec2.of(10, 0))));
  * ```
  */
-var Stroke = /** @class */ (function (_super) {
-    __extends(Stroke, _super);
+export default class Stroke extends AbstractComponent {
     /**
      * Creates a `Stroke` from the given `parts`. All parts should have the
      * same color.
@@ -63,42 +36,38 @@ var Stroke = /** @class */ (function (_super) {
      * ]);
      * ```
      */
-    function Stroke(parts) {
-        var _this = this;
-        var _a;
-        _this = _super.call(this, 'stroke') || this;
+    constructor(parts) {
+        super('stroke');
         // @internal
         // eslint-disable-next-line @typescript-eslint/prefer-as-const
-        _this.isRestylableComponent = true;
-        _this.approximateRenderingTime = 0;
-        _this.parts = [];
-        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
-            var section = parts_1[_i];
-            var path = Path.fromRenderable(section);
-            var pathBBox = _this.bboxForPart(path.bbox, section.style);
-            if (!_this.contentBBox) {
-                _this.contentBBox = pathBBox;
+        this.isRestylableComponent = true;
+        this.approximateRenderingTime = 0;
+        this.parts = [];
+        for (const section of parts) {
+            const path = pathFromRenderable(section);
+            const pathBBox = this.bboxForPart(path.bbox, section.style);
+            if (!this.contentBBox) {
+                this.contentBBox = pathBBox;
             }
             else {
-                _this.contentBBox = _this.contentBBox.union(pathBBox);
+                this.contentBBox = this.contentBBox.union(pathBBox);
             }
-            _this.parts.push({
-                path: path,
+            this.parts.push({
+                path,
                 // To implement RenderablePathSpec
                 startPoint: path.startPoint,
                 style: section.style,
                 commands: path.parts,
             });
-            _this.approximateRenderingTime += path.parts.length;
+            this.approximateRenderingTime += path.parts.length;
         }
-        (_a = _this.contentBBox) !== null && _a !== void 0 ? _a : (_this.contentBBox = Rect2.empty);
-        return _this;
+        this.contentBBox ??= Rect2.empty;
     }
-    Stroke.prototype.getStyle = function () {
+    getStyle() {
         if (this.parts.length === 0) {
             return {};
         }
-        var firstPart = this.parts[0];
+        const firstPart = this.parts[0];
         if (firstPart.style.stroke === undefined
             || firstPart.style.stroke.width === 0) {
             return {
@@ -108,16 +77,21 @@ var Stroke = /** @class */ (function (_super) {
         return {
             color: firstPart.style.stroke.color,
         };
-    };
-    Stroke.prototype.updateStyle = function (style) {
+    }
+    updateStyle(style) {
         return createRestyleComponentCommand(this.getStyle(), style, this);
-    };
-    Stroke.prototype.forceStyle = function (style, editor) {
+    }
+    forceStyle(style, editor) {
         if (!style.color) {
             return;
         }
-        this.parts = this.parts.map(function (part) {
-            var newStyle = __assign(__assign({}, part.style), { stroke: part.style.stroke ? __assign({}, part.style.stroke) : undefined });
+        this.parts = this.parts.map((part) => {
+            const newStyle = {
+                ...part.style,
+                stroke: part.style.stroke ? {
+                    ...part.style.stroke,
+                } : undefined,
+            };
             // Change the stroke color if a stroked shape. Else,
             // change the fill.
             if (newStyle.stroke && newStyle.stroke.width > 0) {
@@ -137,79 +111,78 @@ var Stroke = /** @class */ (function (_super) {
             editor.image.queueRerenderOf(this);
             editor.queueRerender();
         }
-    };
-    Stroke.prototype.intersects = function (line) {
-        var _a;
-        for (var _i = 0, _b = this.parts; _i < _b.length; _i++) {
-            var part = _b[_i];
-            var strokeWidth = (_a = part.style.stroke) === null || _a === void 0 ? void 0 : _a.width;
-            var strokeRadius = strokeWidth ? strokeWidth / 2 : undefined;
+    }
+    intersects(line) {
+        for (const part of this.parts) {
+            const strokeWidth = part.style.stroke?.width;
+            const strokeRadius = strokeWidth ? strokeWidth / 2 : undefined;
             if (part.path.intersection(line, strokeRadius).length > 0) {
                 return true;
             }
         }
         return false;
-    };
-    Stroke.prototype.render = function (canvas, visibleRect) {
-        var _a, _b;
+    }
+    render(canvas, visibleRect) {
         canvas.startObject(this.getBBox());
-        for (var _i = 0, _c = this.parts; _i < _c.length; _i++) {
-            var part = _c[_i];
-            var bbox = this.bboxForPart(part.path.bbox, part.style);
+        for (const part of this.parts) {
+            const bbox = this.bboxForPart(part.path.bbox, part.style);
             if (visibleRect) {
                 if (!bbox.intersects(visibleRect)) {
                     continue;
                 }
-                var muchBiggerThanVisible = bbox.size.x > visibleRect.size.x * 3 || bbox.size.y > visibleRect.size.y * 3;
-                if (muchBiggerThanVisible && !part.path.roughlyIntersects(visibleRect, (_b = (_a = part.style.stroke) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0)) {
+                const muchBiggerThanVisible = bbox.size.x > visibleRect.size.x * 3 || bbox.size.y > visibleRect.size.y * 3;
+                if (muchBiggerThanVisible && !part.path.roughlyIntersects(visibleRect, part.style.stroke?.width ?? 0)) {
                     continue;
                 }
             }
             canvas.drawPath(part);
         }
         canvas.endObject(this.getLoadSaveData());
-    };
-    Stroke.prototype.getProportionalRenderingTime = function () {
+    }
+    getProportionalRenderingTime() {
         return this.approximateRenderingTime;
-    };
+    }
     // Grows the bounding box for a given stroke part based on that part's style.
-    Stroke.prototype.bboxForPart = function (origBBox, style) {
+    bboxForPart(origBBox, style) {
         if (!style.stroke) {
             return origBBox;
         }
         return origBBox.grownBy(style.stroke.width / 2);
-    };
-    Stroke.prototype.getExactBBox = function () {
-        var bbox = null;
-        for (var _i = 0, _a = this.parts; _i < _a.length; _i++) {
-            var _b = _a[_i], path = _b.path, style = _b.style;
+    }
+    getExactBBox() {
+        let bbox = null;
+        for (const { path, style } of this.parts) {
             // Paths' default .bbox can be
-            var partBBox = this.bboxForPart(path.getExactBBox(), style);
-            bbox !== null && bbox !== void 0 ? bbox : (bbox = partBBox);
+            const partBBox = this.bboxForPart(path.getExactBBox(), style);
+            bbox ??= partBBox;
             bbox = bbox.union(partBBox);
         }
-        return bbox !== null && bbox !== void 0 ? bbox : Rect2.empty;
-    };
-    Stroke.prototype.applyTransformation = function (affineTransfm) {
-        var _this = this;
+        return bbox ?? Rect2.empty;
+    }
+    applyTransformation(affineTransfm) {
         this.contentBBox = Rect2.empty;
-        var isFirstPart = true;
+        let isFirstPart = true;
         // Update each part
-        this.parts = this.parts.map(function (part) {
-            var newPath = part.path.transformedBy(affineTransfm);
-            var newStyle = __assign(__assign({}, part.style), { stroke: part.style.stroke ? __assign({}, part.style.stroke) : undefined });
+        this.parts = this.parts.map((part) => {
+            const newPath = part.path.transformedBy(affineTransfm);
+            const newStyle = {
+                ...part.style,
+                stroke: part.style.stroke ? {
+                    ...part.style.stroke,
+                } : undefined,
+            };
             // Approximate the scale factor.
             if (newStyle.stroke) {
-                var scaleFactor = affineTransfm.getScaleFactor();
+                const scaleFactor = affineTransfm.getScaleFactor();
                 newStyle.stroke.width *= scaleFactor;
             }
-            var newBBox = _this.bboxForPart(newPath.bbox, newStyle);
+            const newBBox = this.bboxForPart(newPath.bbox, newStyle);
             if (isFirstPart) {
-                _this.contentBBox = newBBox;
+                this.contentBBox = newBBox;
                 isFirstPart = false;
             }
             else {
-                _this.contentBBox = _this.contentBBox.union(newBBox);
+                this.contentBBox = this.contentBBox.union(newBBox);
             }
             return {
                 path: newPath,
@@ -218,52 +191,49 @@ var Stroke = /** @class */ (function (_super) {
                 style: newStyle,
             };
         });
-    };
+    }
     /**
      * @returns the {@link Path.union} of all paths that make up this stroke.
      */
-    Stroke.prototype.getPath = function () {
-        var result = null;
-        for (var _i = 0, _a = this.parts; _i < _a.length; _i++) {
-            var part = _a[_i];
+    getPath() {
+        let result = null;
+        for (const part of this.parts) {
             if (result) {
                 result = result.union(part.path);
             }
             else {
-                result !== null && result !== void 0 ? result : (result = part.path);
+                result ??= part.path;
             }
         }
-        return result !== null && result !== void 0 ? result : Path.empty;
-    };
-    Stroke.prototype.description = function (localization) {
+        return result ?? Path.empty;
+    }
+    description(localization) {
         return localization.stroke;
-    };
-    Stroke.prototype.createClone = function () {
+    }
+    createClone() {
         return new Stroke(this.parts);
-    };
-    Stroke.prototype.serializeToJSON = function () {
-        return this.parts.map(function (part) {
+    }
+    serializeToJSON() {
+        return this.parts.map(part => {
             return {
                 style: styleToJSON(part.style),
                 path: part.path.serialize(),
             };
         });
-    };
+    }
     /** @internal */
-    Stroke.deserializeFromJSON = function (json) {
+    static deserializeFromJSON(json) {
         if (typeof json === 'string') {
             json = JSON.parse(json);
         }
         if (typeof json !== 'object' || typeof json.length !== 'number') {
-            throw new Error("".concat(json, " is missing required field, parts, or parts is of the wrong type."));
+            throw new Error(`${json} is missing required field, parts, or parts is of the wrong type.`);
         }
-        var pathSpec = json.map(function (part) {
-            var style = styleFromJSON(part.style);
-            return Path.fromString(part.path).toRenderable(style);
+        const pathSpec = json.map((part) => {
+            const style = styleFromJSON(part.style);
+            return pathToRenderable(Path.fromString(part.path), style);
         });
         return new Stroke(pathSpec);
-    };
-    return Stroke;
-}(AbstractComponent));
-export default Stroke;
+    }
+}
 AbstractComponent.registerComponent('stroke', Stroke.deserializeFromJSON);

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

@@ -1,8 +1,6 @@
 import SerializableCommand from '../commands/SerializableCommand';
-import LineSegment2 from '../math/shapes/LineSegment2';
-import Mat33 from '../math/Mat33';
-import Rect2 from '../math/shapes/Rect2';
 import Editor from '../Editor';
+import { LineSegment2, Rect2, Mat33 } from '@js-draw/math';
 import AbstractRenderer from '../rendering/renderers/AbstractRenderer';
 import { TextRenderingStyle } from '../rendering/TextRenderingStyle';
 import AbstractComponent from './AbstractComponent';
@@ -51,7 +49,7 @@ export default class TextComponent extends AbstractComponent implements Restylea
     updateStyle(style: ComponentStyle): SerializableCommand;
     forceStyle(style: ComponentStyle, editor: Editor | null): void;
     getTextStyle(): TextRenderingStyle;
-    getBaselinePos(): import("../lib").Vec3;
+    getBaselinePos(): import("@js-draw/math").Vec3;
     getTransform(): Mat33;
     protected applyTransformation(affineTransfm: Mat33): void;
     protected createClone(): AbstractComponent;