js-draw 0.25.1 → 1.0.1

package/dist/mjs/UndoRedoHistory.mjs

@@ -11,9 +11,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _UndoRedoHistory_undoStack, _UndoRedoHistory_redoStack;
 import  { EditorEventType, UndoEventType }  from './types.mjs';
-var UndoRedoHistory = /** @class */ (function () {
+class UndoRedoHistory {
     // @internal
-    function UndoRedoHistory(editor, announceRedoCallback, announceUndoCallback) {
+    constructor(editor, announceRedoCallback, announceUndoCallback) {
         this.editor = editor;
         this.announceRedoCallback = announceRedoCallback;
         this.announceUndoCallback = announceUndoCallback;
@@ -23,42 +23,39 @@ var UndoRedoHistory = /** @class */ (function () {
         __classPrivateFieldSet(this, _UndoRedoHistory_undoStack, [], "f");
         __classPrivateFieldSet(this, _UndoRedoHistory_redoStack, [], "f");
     }
-    UndoRedoHistory.prototype.fireUpdateEvent = function (stackUpdateType, triggeringCommand) {
+    fireUpdateEvent(stackUpdateType, triggeringCommand) {
         this.editor.notifier.dispatch(EditorEventType.UndoRedoStackUpdated, {
             kind: EditorEventType.UndoRedoStackUpdated,
             undoStackSize: __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").length,
             redoStackSize: __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f").length,
             command: triggeringCommand,
-            stackUpdateType: stackUpdateType,
+            stackUpdateType,
         });
-    };
+    }
     // Adds the given command to this and applies it to the editor.
-    UndoRedoHistory.prototype.push = function (command, apply) {
-        var _this = this;
-        if (apply === void 0) { apply = true; }
+    push(command, apply = true) {
         if (apply) {
             command.apply(this.editor);
         }
         __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").push(command);
-        for (var _i = 0, _a = __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f"); _i < _a.length; _i++) {
-            var elem = _a[_i];
+        for (const elem of __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f")) {
             elem.onDrop(this.editor);
         }
         __classPrivateFieldSet(this, _UndoRedoHistory_redoStack, [], "f");
         if (__classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").length > this.maxUndoRedoStackSize) {
-            var removeAtOnceCount = Math.ceil(this.maxUndoRedoStackSize / 100);
-            var removedElements = __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").splice(0, removeAtOnceCount);
-            removedElements.forEach(function (elem) { return elem.onDrop(_this.editor); });
+            const removeAtOnceCount = Math.ceil(this.maxUndoRedoStackSize / 100);
+            const removedElements = __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").splice(0, removeAtOnceCount);
+            removedElements.forEach(elem => elem.onDrop(this.editor));
         }
         this.fireUpdateEvent(UndoEventType.CommandDone, command);
         this.editor.notifier.dispatch(EditorEventType.CommandDone, {
             kind: EditorEventType.CommandDone,
-            command: command,
+            command,
         });
-    };
+    }
     // Remove the last command from this' undo stack and apply it.
-    UndoRedoHistory.prototype.undo = function () {
-        var command = __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").pop();
+    undo() {
+        const command = __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").pop();
         if (command) {
             __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f").push(command);
             command.unapply(this.editor);
@@ -66,12 +63,12 @@ var UndoRedoHistory = /** @class */ (function () {
             this.fireUpdateEvent(UndoEventType.CommandUndone, command);
             this.editor.notifier.dispatch(EditorEventType.CommandUndone, {
                 kind: EditorEventType.CommandUndone,
-                command: command,
+                command,
             });
         }
-    };
-    UndoRedoHistory.prototype.redo = function () {
-        var command = __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f").pop();
+    }
+    redo() {
+        const command = __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f").pop();
         if (command) {
             __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").push(command);
             command.apply(this.editor);
@@ -79,25 +76,16 @@ var UndoRedoHistory = /** @class */ (function () {
             this.fireUpdateEvent(UndoEventType.CommandRedone, command);
             this.editor.notifier.dispatch(EditorEventType.CommandDone, {
                 kind: EditorEventType.CommandDone,
-                command: command,
+                command,
             });
         }
-    };
-    Object.defineProperty(UndoRedoHistory.prototype, "undoStackSize", {
-        get: function () {
-            return __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(UndoRedoHistory.prototype, "redoStackSize", {
-        get: function () {
-            return __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f").length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return UndoRedoHistory;
-}());
+    }
+    get undoStackSize() {
+        return __classPrivateFieldGet(this, _UndoRedoHistory_undoStack, "f").length;
+    }
+    get redoStackSize() {
+        return __classPrivateFieldGet(this, _UndoRedoHistory_redoStack, "f").length;
+    }
+}
 _UndoRedoHistory_undoStack = new WeakMap(), _UndoRedoHistory_redoStack = new WeakMap();
 export default UndoRedoHistory;

package/dist/mjs/Viewport.d.ts

@@ -1,8 +1,5 @@
 import Command from './commands/Command';
-import Mat33 from './math/Mat33';
-import Rect2 from './math/shapes/Rect2';
-import { Point2, Vec2 } from './math/Vec2';
-import Vec3 from './math/Vec3';
+import { Mat33, Rect2, Point2, Vec2, Vec3 } from '@js-draw/math';
 import { StrokeDataPoint } from './types';
 type PointDataType<T extends Point2 | StrokeDataPoint | number> = T extends Point2 ? Point2 : number;
 export declare abstract class ViewportTransform extends Command {

package/dist/mjs/Viewport.mjs

@@ -1,18 +1,3 @@
-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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -24,22 +9,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
+var _inverseTransform, _a;
 import  Command  from './commands/Command.mjs';
-import  Mat33  from './math/Mat33.mjs';
-import  Rect2  from './math/shapes/Rect2.mjs';
-import  { Vec2 }  from './math/Vec2.mjs';
-import  Vec3  from './math/Vec3.mjs';
-var ViewportTransform = /** @class */ (function (_super) {
-    __extends(ViewportTransform, _super);
-    function ViewportTransform() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return ViewportTransform;
-}(Command));
-export { ViewportTransform };
-export var Viewport = /** @class */ (function () {
+import { Mat33, Rect2, Vec2, Vec3 } from '@js-draw/math';
+export class ViewportTransform extends Command {
+}
+export class Viewport {
     // @internal
-    function Viewport(onTransformChangeCallback) {
+    constructor(onTransformChangeCallback) {
         this.onTransformChangeCallback = onTransformChangeCallback;
         this.resetTransform(Mat33.identity);
         this.screenRect = Rect2.empty;
@@ -48,179 +25,161 @@ export var Viewport = /** @class */ (function () {
      * @returns a temporary copy of `this` that does not notify when modified. This is
      * useful when rendering with a temporarily different viewport.
      */
-    Viewport.prototype.getTemporaryClone = function () {
-        var result = new Viewport(function () { });
+    getTemporaryClone() {
+        const result = new Viewport(() => { });
         result.transform = this.transform;
         result.inverseTransform = this.inverseTransform;
         result.screenRect = this.screenRect;
         return result;
-    };
+    }
     // @internal
-    Viewport.prototype.updateScreenSize = function (screenSize) {
+    updateScreenSize(screenSize) {
         this.screenRect = this.screenRect.resizedTo(screenSize);
-    };
-    Object.defineProperty(Viewport.prototype, "visibleRect", {
-        /** Get the screen's visible region transformed into canvas space. */
-        get: function () {
-            return this.screenRect.transformedBoundingBox(this.inverseTransform);
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /** Get the screen's visible region transformed into canvas space. */
+    get visibleRect() {
+        return this.screenRect.transformedBoundingBox(this.inverseTransform);
+    }
     /** @returns the given point, but in canvas coordinates */
-    Viewport.prototype.screenToCanvas = function (screenPoint) {
+    screenToCanvas(screenPoint) {
         return this.inverseTransform.transformVec2(screenPoint);
-    };
+    }
     /** @returns the given point transformed into screen coordinates. */
-    Viewport.prototype.canvasToScreen = function (canvasPoint) {
+    canvasToScreen(canvasPoint) {
         return this.transform.transformVec2(canvasPoint);
-    };
+    }
     /** @returns a command that transforms the canvas by `transform`. */
-    Viewport.transformBy = function (transform) {
+    static transformBy(transform) {
         return new Viewport.ViewportTransform(transform);
-    };
+    }
     /**
      * Updates the transformation directly. Using `transformBy` is preferred.
      * @param newTransform - should map from canvas coordinates to screen coordinates.
      */
-    Viewport.prototype.resetTransform = function (newTransform) {
-        var _a;
-        if (newTransform === void 0) { newTransform = Mat33.identity; }
-        var oldTransform = this.transform;
+    resetTransform(newTransform = Mat33.identity) {
+        const oldTransform = this.transform;
         this.transform = newTransform;
         this.inverseTransform = newTransform.inverse();
-        (_a = this.onTransformChangeCallback) === null || _a === void 0 ? void 0 : _a.call(this, oldTransform, newTransform);
-    };
-    Object.defineProperty(Viewport.prototype, "screenToCanvasTransform", {
-        get: function () {
-            return this.inverseTransform;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Viewport.prototype, "canvasToScreenTransform", {
-        get: function () {
-            return this.transform;
-        },
-        enumerable: false,
-        configurable: true
-    });
+        this.onTransformChangeCallback?.(oldTransform, newTransform);
+    }
+    get screenToCanvasTransform() {
+        return this.inverseTransform;
+    }
+    get canvasToScreenTransform() {
+        return this.transform;
+    }
     /** @returns the size of the visible region in pixels. */
-    Viewport.prototype.getScreenRectSize = function () {
+    getScreenRectSize() {
         return this.screenRect.size;
-    };
+    }
     /** Alias for `getScreenRectSize`. @deprecated */
-    Viewport.prototype.getResolution = function () {
+    getResolution() {
         return this.getScreenRectSize();
-    };
+    }
     /** @returns the amount a vector on the canvas is scaled to become a vector on the screen. */
-    Viewport.prototype.getScaleFactor = function () {
+    getScaleFactor() {
         // Use transformVec3 to avoid translating the vector
         return this.transform.transformVec3(Vec3.unitX).magnitude();
-    };
+    }
     /**
      * @returns `getScaleFactor()` rounded to the nearest power of 10.
      * For example, if `getScaleFactor()` returns 101, `getScaleFactorToNearestPowerOfTen()`
      * should return `100` because `100` is the nearest power of 10 to 101.
      */
-    Viewport.prototype.getScaleFactorToNearestPowerOfTen = function () {
+    getScaleFactorToNearestPowerOfTen() {
         return this.getScaleFactorToNearestPowerOf(10);
-    };
-    Viewport.prototype.getScaleFactorToNearestPowerOf = function (powerOf) {
-        var scaleFactor = this.getScaleFactor();
+    }
+    getScaleFactorToNearestPowerOf(powerOf) {
+        const scaleFactor = this.getScaleFactor();
         return Math.pow(powerOf, Math.round(Math.log(scaleFactor) / Math.log(powerOf)));
-    };
+    }
     /** Returns the size of a grid cell (in canvas units) as used by {@link snapToGrid}. */
-    Viewport.getGridSize = function (scaleFactor) {
+    static getGridSize(scaleFactor) {
         return 50 / scaleFactor;
-    };
-    Viewport.prototype.snapToGrid = function (canvasPos) {
-        var scaleFactor = this.getScaleFactorToNearestPowerOf(2);
-        var snapCoordinate = function (coordinate) {
-            var roundFactor = 1 / Viewport.getGridSize(scaleFactor);
-            var snapped = Math.round(coordinate * roundFactor) / roundFactor;
+    }
+    snapToGrid(canvasPos) {
+        const scaleFactor = this.getScaleFactorToNearestPowerOf(2);
+        const snapCoordinate = (coordinate) => {
+            const roundFactor = 1 / Viewport.getGridSize(scaleFactor);
+            const snapped = Math.round(coordinate * roundFactor) / roundFactor;
             return snapped;
         };
-        var snappedCanvasPos = Vec2.of(snapCoordinate(canvasPos.x), snapCoordinate(canvasPos.y));
+        const snappedCanvasPos = Vec2.of(snapCoordinate(canvasPos.x), snapCoordinate(canvasPos.y));
         return snappedCanvasPos;
-    };
+    }
     /** Returns the size of one screen pixel in canvas units. */
-    Viewport.prototype.getSizeOfPixelOnCanvas = function () {
+    getSizeOfPixelOnCanvas() {
         return 1 / this.getScaleFactor();
-    };
+    }
     /**
      * @returns the angle of the canvas in radians.
      * This is the angle by which the canvas is rotated relative to the screen.
      */
-    Viewport.prototype.getRotationAngle = function () {
+    getRotationAngle() {
         return this.transform.transformVec3(Vec3.unitX).angle();
-    };
+    }
     // The separate function type definition seems necessary here.
     // See https://stackoverflow.com/a/58163623/17055750.
     // eslint-disable-next-line no-dupe-class-members
-    Viewport.roundPoint = function (point, tolerance) {
-        var scaleFactor = Math.pow(10, Math.floor(Math.log10(tolerance)));
-        var roundComponent = function (component) {
+    static roundPoint(point, tolerance) {
+        const scaleFactor = 10 ** Math.floor(Math.log10(tolerance));
+        const roundComponent = (component) => {
             return Math.round(component / scaleFactor) * scaleFactor;
         };
         if (typeof point === 'number') {
             return roundComponent(point);
         }
         return point.map(roundComponent);
-    };
+    }
     // Round a point with a tolerance of ±1 screen unit.
-    Viewport.prototype.roundPoint = function (point) {
+    roundPoint(point) {
         return Viewport.roundPoint(point, 1 / this.getScaleFactor());
-    };
+    }
     // `roundAmount`: An integer >= 0, larger numbers cause less rounding. Smaller numbers cause more
     // (as such `roundAmount = 0` does the most rounding).
-    Viewport.roundScaleRatio = function (scaleRatio, roundAmount) {
-        if (roundAmount === void 0) { roundAmount = 1; }
+    static roundScaleRatio(scaleRatio, roundAmount = 1) {
         if (Math.abs(scaleRatio) <= 1e-12) {
             return 0;
         }
         // Represent as k 10ⁿ for some n, k ∈ ℤ.
-        var decimalComponent = Math.pow(10, Math.floor(Math.log10(Math.abs(scaleRatio))));
-        var roundAmountFactor = Math.pow(2, roundAmount);
+        const decimalComponent = 10 ** Math.floor(Math.log10(Math.abs(scaleRatio)));
+        const roundAmountFactor = 2 ** roundAmount;
         scaleRatio = Math.round(scaleRatio / decimalComponent * roundAmountFactor) / roundAmountFactor * decimalComponent;
         return scaleRatio;
-    };
+    }
     // Computes and returns an affine transformation that makes `toMakeVisible` visible and roughly centered on the screen.
-    Viewport.prototype.computeZoomToTransform = function (toMakeVisible, allowZoomIn, allowZoomOut) {
-        var _this = this;
-        if (allowZoomIn === void 0) { allowZoomIn = true; }
-        if (allowZoomOut === void 0) { allowZoomOut = true; }
-        var transform = Mat33.identity;
+    computeZoomToTransform(toMakeVisible, allowZoomIn = true, allowZoomOut = true) {
+        let transform = Mat33.identity;
         if (toMakeVisible.w === 0 || toMakeVisible.h === 0) {
-            throw new Error("".concat(toMakeVisible.toString(), " rectangle is empty! Cannot zoom to!"));
+            throw new Error(`${toMakeVisible.toString()} rectangle is empty! Cannot zoom to!`);
         }
         if (isNaN(toMakeVisible.size.magnitude())) {
-            throw new Error("".concat(toMakeVisible.toString(), " rectangle has NaN size! Cannot zoom to!"));
+            throw new Error(`${toMakeVisible.toString()} rectangle has NaN size! Cannot zoom to!`);
         }
         // Try to move the selection within the center 4/5ths of the viewport.
-        var recomputeTargetRect = function () {
+        const recomputeTargetRect = () => {
             // transform transforms objects on the canvas. As such, we need to invert it
             // to transform the viewport.
-            var visibleRect = _this.visibleRect.transformedBoundingBox(transform.inverse());
+            const visibleRect = this.visibleRect.transformedBoundingBox(transform.inverse());
             return visibleRect.transformedBoundingBox(Mat33.scaling2D(4 / 5, visibleRect.center));
         };
-        var targetRect = recomputeTargetRect();
-        var largerThanTarget = targetRect.w < toMakeVisible.w || targetRect.h < toMakeVisible.h;
+        let targetRect = recomputeTargetRect();
+        const largerThanTarget = targetRect.w < toMakeVisible.w || targetRect.h < toMakeVisible.h;
         // Ensure that toMakeVisible is at least 1/3rd of the visible region.
-        var muchSmallerThanTarget = toMakeVisible.maxDimension / targetRect.maxDimension < 1 / 3;
+        const muchSmallerThanTarget = toMakeVisible.maxDimension / targetRect.maxDimension < 1 / 3;
         if ((largerThanTarget && allowZoomOut) || (muchSmallerThanTarget && allowZoomIn)) {
-            var multiplier = Math.max(toMakeVisible.w / targetRect.w, toMakeVisible.h / targetRect.h);
-            var visibleRectTransform = Mat33.scaling2D(multiplier, targetRect.topLeft);
-            var viewportContentTransform = visibleRectTransform.inverse();
+            const multiplier = Math.max(toMakeVisible.w / targetRect.w, toMakeVisible.h / targetRect.h);
+            const visibleRectTransform = Mat33.scaling2D(multiplier, targetRect.topLeft);
+            const viewportContentTransform = visibleRectTransform.inverse();
             transform = transform.rightMul(viewportContentTransform);
         }
         targetRect = recomputeTargetRect();
         // Ensure that the center of the region is visible
         if (!targetRect.containsRect(toMakeVisible)) {
             // target position - current position
-            var translation = toMakeVisible.center.minus(targetRect.center);
-            var visibleRectTransform = Mat33.translation(translation);
-            var viewportContentTransform = visibleRectTransform.inverse();
+            const translation = toMakeVisible.center.minus(targetRect.center);
+            const visibleRectTransform = Mat33.translation(translation);
+            const viewportContentTransform = visibleRectTransform.inverse();
             transform = transform.rightMul(viewportContentTransform);
         }
         if (!transform.invertable()) {
@@ -228,77 +187,70 @@ export var Viewport = /** @class */ (function () {
             transform = Mat33.identity;
         }
         return transform;
-    };
+    }
     // Returns a Command that transforms the view such that [rect] is visible, and perhaps
     // centered in the viewport.
     // Returns null if no transformation is necessary
     //
     // @see {@link computeZoomToTransform}
-    Viewport.prototype.zoomTo = function (toMakeVisible, allowZoomIn, allowZoomOut) {
-        if (allowZoomIn === void 0) { allowZoomIn = true; }
-        if (allowZoomOut === void 0) { allowZoomOut = true; }
-        var transform = this.computeZoomToTransform(toMakeVisible, allowZoomIn, allowZoomOut);
+    zoomTo(toMakeVisible, allowZoomIn = true, allowZoomOut = true) {
+        const transform = this.computeZoomToTransform(toMakeVisible, allowZoomIn, allowZoomOut);
         return new Viewport.ViewportTransform(transform);
-    };
-    var _inverseTransform, _a;
-    // Command that translates/scales the viewport.
-    Viewport.ViewportTransform = (_a = /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1(transform) {
-                var _this = _super.call(this) || this;
-                _this.transform = transform;
-                _inverseTransform.set(_this, void 0);
-                __classPrivateFieldSet(_this, _inverseTransform, transform.inverse(), "f");
-                return _this;
+    }
+}
+// Command that translates/scales the viewport.
+Viewport.ViewportTransform = (_a = class extends ViewportTransform {
+        constructor(transform) {
+            super();
+            this.transform = transform;
+            _inverseTransform.set(this, void 0);
+            __classPrivateFieldSet(this, _inverseTransform, transform.inverse(), "f");
+        }
+        apply(editor) {
+            const viewport = editor.viewport;
+            viewport.resetTransform(viewport.transform.rightMul(this.transform));
+            editor.queueRerender();
+        }
+        unapply(editor) {
+            const viewport = editor.viewport;
+            viewport.resetTransform(viewport.transform.rightMul(__classPrivateFieldGet(this, _inverseTransform, "f")));
+            editor.queueRerender();
+        }
+        description(editor, localizationTable) {
+            const result = [];
+            // Describe the transformation's affect on the viewport (note that transformation transforms
+            // the **elements** within the viewport). Assumes the transformation only does rotation/scale/translation.
+            const origVec = editor.viewport.visibleRect.center;
+            const linearTransformedVec = this.transform.transformVec3(Vec2.unitX);
+            const affineTransformedVec = this.transform.transformVec2(origVec);
+            const scale = linearTransformedVec.magnitude();
+            const rotation = 180 / Math.PI * linearTransformedVec.angle();
+            const translation = affineTransformedVec.minus(origVec);
+            if (scale > 1.2) {
+                result.push(localizationTable.zoomedIn);
+            }
+            else if (scale < 0.8) {
+                result.push(localizationTable.zoomedOut);
+            }
+            if (Math.floor(Math.abs(rotation)) > 0) {
+                result.push(localizationTable.rotatedBy(Math.round(rotation)));
+            }
+            const minTranslation = 1e-4;
+            if (translation.x > minTranslation) {
+                result.push(localizationTable.movedLeft);
             }
-            class_1.prototype.apply = function (editor) {
-                var viewport = editor.viewport;
-                viewport.resetTransform(viewport.transform.rightMul(this.transform));
-                editor.queueRerender();
-            };
-            class_1.prototype.unapply = function (editor) {
-                var viewport = editor.viewport;
-                viewport.resetTransform(viewport.transform.rightMul(__classPrivateFieldGet(this, _inverseTransform, "f")));
-                editor.queueRerender();
-            };
-            class_1.prototype.description = function (editor, localizationTable) {
-                var result = [];
-                // Describe the transformation's affect on the viewport (note that transformation transforms
-                // the **elements** within the viewport). Assumes the transformation only does rotation/scale/translation.
-                var origVec = editor.viewport.visibleRect.center;
-                var linearTransformedVec = this.transform.transformVec3(Vec2.unitX);
-                var affineTransformedVec = this.transform.transformVec2(origVec);
-                var scale = linearTransformedVec.magnitude();
-                var rotation = 180 / Math.PI * linearTransformedVec.angle();
-                var translation = affineTransformedVec.minus(origVec);
-                if (scale > 1.2) {
-                    result.push(localizationTable.zoomedIn);
-                }
-                else if (scale < 0.8) {
-                    result.push(localizationTable.zoomedOut);
-                }
-                if (Math.floor(Math.abs(rotation)) > 0) {
-                    result.push(localizationTable.rotatedBy(Math.round(rotation)));
-                }
-                var minTranslation = 1e-4;
-                if (translation.x > minTranslation) {
-                    result.push(localizationTable.movedLeft);
-                }
-                else if (translation.x < -minTranslation) {
-                    result.push(localizationTable.movedRight);
-                }
-                if (translation.y < -minTranslation) {
-                    result.push(localizationTable.movedDown);
-                }
-                else if (translation.y > minTranslation) {
-                    result.push(localizationTable.movedUp);
-                }
-                return result.join('; ');
-            };
-            return class_1;
-        }(ViewportTransform)),
-        _inverseTransform = new WeakMap(),
-        _a);
-    return Viewport;
-}());
+            else if (translation.x < -minTranslation) {
+                result.push(localizationTable.movedRight);
+            }
+            if (translation.y < -minTranslation) {
+                result.push(localizationTable.movedDown);
+            }
+            else if (translation.y > minTranslation) {
+                result.push(localizationTable.movedUp);
+            }
+            return result.join('; ');
+        }
+    },
+    _inverseTransform = new WeakMap(),
+    _a);
 export default Viewport;

package/dist/mjs/commands/Command.mjs

@@ -1,58 +1,30 @@
-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 __());
-    };
-})();
-export var Command = /** @class */ (function () {
-    function Command() {
-    }
+export class Command {
     // Called when the command is being deleted
-    Command.prototype.onDrop = function (_editor) { };
-    Command.union = function (a, b) {
-        return new /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_1.prototype.apply = function (editor) {
+    onDrop(_editor) { }
+    static union(a, b) {
+        return new class extends Command {
+            apply(editor) {
                 a.apply(editor);
                 b.apply(editor);
-            };
-            class_1.prototype.unapply = function (editor) {
+            }
+            unapply(editor) {
                 b.unapply(editor);
                 a.unapply(editor);
-            };
-            class_1.prototype.description = function (editor, localizationTable) {
-                var aDescription = a.description(editor, localizationTable);
-                var bDescription = b.description(editor, localizationTable);
+            }
+            description(editor, localizationTable) {
+                const aDescription = a.description(editor, localizationTable);
+                const bDescription = b.description(editor, localizationTable);
                 if (aDescription === bDescription) {
                     return aDescription;
                 }
-                return "".concat(aDescription, ", ").concat(bDescription);
-            };
-            return class_1;
-        }(Command));
-    };
-    Command.empty = new /** @class */ (function (_super) {
-        __extends(class_2, _super);
-        function class_2() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        class_2.prototype.description = function (_editor, _localizationTable) { return ''; };
-        class_2.prototype.apply = function (_editor) { };
-        class_2.prototype.unapply = function (_editor) { };
-        return class_2;
-    }(Command));
-    return Command;
-}());
+                return `${aDescription}, ${bDescription}`;
+            }
+        };
+    }
+}
+Command.empty = new class extends Command {
+    description(_editor, _localizationTable) { return ''; }
+    apply(_editor) { }
+    unapply(_editor) { }
+};
 export default Command;