js-draw 0.25.0 → 1.0.0

package/dist/mjs/commands/Duplicate.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 __());
-    };
-})();
 import  describeComponentList  from '../components/util/describeComponentList.mjs';
 import  Erase  from './Erase.mjs';
 import  SerializableCommand  from './SerializableCommand.mjs';
@@ -39,39 +24,35 @@ import  SerializableCommand  from './SerializableCommand.mjs';
  *
  * @see {@link Editor.dispatch} {@link EditorImage.getElementsIntersectingRegion}
  */
-var Duplicate = /** @class */ (function (_super) {
-    __extends(Duplicate, _super);
-    function Duplicate(toDuplicate) {
-        var _this = _super.call(this, 'duplicate') || this;
-        _this.toDuplicate = toDuplicate;
-        _this.duplicates = toDuplicate.map(function (elem) { return elem.clone(); });
-        _this.reverse = new Erase(_this.duplicates);
-        return _this;
+class Duplicate extends SerializableCommand {
+    constructor(toDuplicate) {
+        super('duplicate');
+        this.toDuplicate = toDuplicate;
+        this.duplicates = toDuplicate.map(elem => elem.clone());
+        this.reverse = new Erase(this.duplicates);
     }
-    Duplicate.prototype.apply = function (editor) {
+    apply(editor) {
         this.reverse.unapply(editor);
-    };
-    Duplicate.prototype.unapply = function (editor) {
+    }
+    unapply(editor) {
         this.reverse.apply(editor);
-    };
-    Duplicate.prototype.onDrop = function (editor) {
+    }
+    onDrop(editor) {
         this.reverse.onDrop(editor);
-    };
-    Duplicate.prototype.description = function (_editor, localizationTable) {
-        var _a;
+    }
+    description(_editor, localizationTable) {
         if (this.duplicates.length === 0) {
             return localizationTable.duplicatedNoElements;
         }
-        return localizationTable.duplicateAction((_a = describeComponentList(localizationTable, this.duplicates)) !== null && _a !== void 0 ? _a : localizationTable.elements, this.duplicates.length);
-    };
-    Duplicate.prototype.serializeToJSON = function () {
-        return this.toDuplicate.map(function (elem) { return elem.getId(); });
-    };
-    return Duplicate;
-}(SerializableCommand));
-(function () {
-    SerializableCommand.register('duplicate', function (json, editor) {
-        var elems = json.map(function (id) { return editor.image.lookupElement(id); });
+        return localizationTable.duplicateAction(describeComponentList(localizationTable, this.duplicates) ?? localizationTable.elements, this.duplicates.length);
+    }
+    serializeToJSON() {
+        return this.toDuplicate.map(elem => elem.getId());
+    }
+}
+(() => {
+    SerializableCommand.register('duplicate', (json, editor) => {
+        const elems = json.map((id) => editor.image.lookupElement(id));
         return new Duplicate(elems);
     });
 })();

package/dist/mjs/commands/Erase.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 __());
-    };
-})();
 import  describeComponentList  from '../components/util/describeComponentList.mjs';
 import  EditorImage  from '../EditorImage.mjs';
 import  SerializableCommand  from './SerializableCommand.mjs';
@@ -36,63 +21,57 @@ import  SerializableCommand  from './SerializableCommand.mjs';
  * editor.dispatch(eraseElemsCmd);
  * ```
  */
-var Erase = /** @class */ (function (_super) {
-    __extends(Erase, _super);
-    function Erase(toRemove) {
-        var _this = _super.call(this, 'erase') || this;
+class Erase extends SerializableCommand {
+    constructor(toRemove) {
+        super('erase');
         // Clone the list
-        _this.toRemove = toRemove.map(function (elem) { return elem; });
-        _this.applied = false;
-        return _this;
+        this.toRemove = toRemove.map(elem => elem);
+        this.applied = false;
     }
-    Erase.prototype.apply = function (editor) {
-        for (var _i = 0, _a = this.toRemove; _i < _a.length; _i++) {
-            var part = _a[_i];
-            var parent_1 = editor.image.findParent(part);
-            if (parent_1) {
-                parent_1.remove();
+    apply(editor) {
+        for (const part of this.toRemove) {
+            const parent = editor.image.findParent(part);
+            if (parent) {
+                editor.image.onDestroyElement(part);
+                parent.remove();
             }
         }
         this.applied = true;
         editor.queueRerender();
-    };
-    Erase.prototype.unapply = function (editor) {
-        for (var _i = 0, _a = this.toRemove; _i < _a.length; _i++) {
-            var part = _a[_i];
+    }
+    unapply(editor) {
+        for (const part of this.toRemove) {
             if (!editor.image.findParent(part)) {
                 EditorImage.addElement(part).apply(editor);
             }
         }
         this.applied = false;
         editor.queueRerender();
-    };
-    Erase.prototype.onDrop = function (editor) {
+    }
+    onDrop(editor) {
         if (this.applied) {
-            for (var _i = 0, _a = this.toRemove; _i < _a.length; _i++) {
-                var part = _a[_i];
+            for (const part of this.toRemove) {
                 editor.image.onDestroyElement(part);
             }
         }
-    };
-    Erase.prototype.description = function (_editor, localizationTable) {
-        var _a;
+    }
+    description(_editor, localizationTable) {
         if (this.toRemove.length === 0) {
             return localizationTable.erasedNoElements;
         }
-        var description = (_a = describeComponentList(localizationTable, this.toRemove)) !== null && _a !== void 0 ? _a : localizationTable.elements;
+        const description = describeComponentList(localizationTable, this.toRemove) ?? localizationTable.elements;
         return localizationTable.eraseAction(description, this.toRemove.length);
-    };
-    Erase.prototype.serializeToJSON = function () {
-        var elemIds = this.toRemove.map(function (elem) { return elem.getId(); });
+    }
+    serializeToJSON() {
+        const elemIds = this.toRemove.map(elem => elem.getId());
         return elemIds;
-    };
-    return Erase;
-}(SerializableCommand));
-(function () {
-    SerializableCommand.register('erase', function (json, editor) {
-        var elems = json
-            .map(function (elemId) { return editor.image.lookupElement(elemId); })
-            .filter(function (elem) { return elem !== null; });
+    }
+}
+(() => {
+    SerializableCommand.register('erase', (json, editor) => {
+        const elems = json
+            .map((elemId) => editor.image.lookupElement(elemId))
+            .filter((elem) => elem !== null);
         return new Erase(elems);
     });
 })();

package/dist/mjs/commands/SerializableCommand.mjs

@@ -1,55 +1,37 @@
-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 __());
-    };
-})();
 import  Command  from './Command.mjs';
-var SerializableCommand = /** @class */ (function (_super) {
-    __extends(SerializableCommand, _super);
-    function SerializableCommand(commandTypeId) {
-        var _this = _super.call(this) || this;
-        _this.commandTypeId = commandTypeId;
+class SerializableCommand extends Command {
+    constructor(commandTypeId) {
+        super();
+        this.commandTypeId = commandTypeId;
         if (!(commandTypeId in SerializableCommand.deserializationCallbacks)) {
-            throw new Error("Command ".concat(commandTypeId, " must have a registered deserialization callback. To do this, call SerializableCommand.register."));
+            throw new Error(`Command ${commandTypeId} must have a registered deserialization callback. To do this, call SerializableCommand.register.`);
         }
-        return _this;
     }
     // Convert this command to an object that can be passed to `JSON.stringify`.
     //
     // Do not rely on the stability of the optupt of this function — it can change
     // form without a major version increase.
-    SerializableCommand.prototype.serialize = function () {
+    serialize() {
         return {
             data: this.serializeToJSON(),
             commandType: this.commandTypeId,
         };
-    };
+    }
     // Convert a `string` containing JSON data (or the output of `JSON.parse`) into a
     // `Command`.
-    SerializableCommand.deserialize = function (data, editor) {
-        var json = typeof data === 'string' ? JSON.parse(data) : data;
-        var commandType = json.commandType;
+    static deserialize(data, editor) {
+        const json = typeof data === 'string' ? JSON.parse(data) : data;
+        const commandType = json.commandType;
         if (!(commandType in SerializableCommand.deserializationCallbacks)) {
-            throw new Error("Unrecognised command type ".concat(commandType, "!"));
+            throw new Error(`Unrecognised command type ${commandType}!`);
         }
         return SerializableCommand.deserializationCallbacks[commandType](json.data, editor);
-    };
+    }
     // Register a deserialization callback. This must be called at least once for every subclass of
     // `SerializableCommand`.
-    SerializableCommand.register = function (commandTypeId, deserialize) {
+    static register(commandTypeId, deserialize) {
         SerializableCommand.deserializationCallbacks[commandTypeId] = deserialize;
-    };
-    SerializableCommand.deserializationCallbacks = {};
-    return SerializableCommand;
-}(Command));
+    }
+}
+SerializableCommand.deserializationCallbacks = {};
 export default SerializableCommand;

package/dist/mjs/commands/UnresolvedCommand.mjs

@@ -1,41 +1,22 @@
-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 __());
-    };
-})();
 import  SerializableCommand  from './SerializableCommand.mjs';
 /**
  * A command that requires a component that may or may not be present in the editor when
  * the command is created.
  */
-var UnresolvedSerializableCommand = /** @class */ (function (_super) {
-    __extends(UnresolvedSerializableCommand, _super);
-    function UnresolvedSerializableCommand(commandId, componentID, component) {
-        var _this = _super.call(this, commandId) || this;
-        _this.component = component !== null && component !== void 0 ? component : null;
-        _this.componentID = componentID;
-        return _this;
+export default class UnresolvedSerializableCommand extends SerializableCommand {
+    constructor(commandId, componentID, component) {
+        super(commandId);
+        this.component = component ?? null;
+        this.componentID = componentID;
     }
-    UnresolvedSerializableCommand.prototype.resolveComponent = function (image) {
+    resolveComponent(image) {
         if (this.component) {
             return;
         }
-        var component = image.lookupElement(this.componentID);
+        const component = image.lookupElement(this.componentID);
         if (!component) {
-            throw new Error("Unable to resolve component with ID ".concat(this.componentID));
+            throw new Error(`Unable to resolve component with ID ${this.componentID}`);
         }
         this.component = component;
-    };
-    return UnresolvedSerializableCommand;
-}(SerializableCommand));
-export default UnresolvedSerializableCommand;
+    }
+}

package/dist/mjs/commands/invertCommand.mjs

@@ -1,75 +1,50 @@
-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 __());
-    };
-})();
 import  Command  from './Command.mjs';
 import  SerializableCommand  from './SerializableCommand.mjs';
 // Returns a command that does the opposite of the given command --- `result.apply()` calls
 // `command.unapply()` and `result.unapply()` calls `command.apply()`.
-var invertCommand = function (command) {
+const invertCommand = (command) => {
     if (command instanceof SerializableCommand) {
         // SerializableCommand that does the inverse of [command]
-        return new /** @class */ (function (_super) {
-            __extends(class_1, _super);
-            function class_1() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_1.prototype.serializeToJSON = function () {
+        return new class extends SerializableCommand {
+            serializeToJSON() {
                 return command.serialize();
-            };
-            class_1.prototype.apply = function (editor) {
+            }
+            apply(editor) {
                 command.unapply(editor);
-            };
-            class_1.prototype.unapply = function (editor) {
+            }
+            unapply(editor) {
                 command.unapply(editor);
-            };
-            class_1.prototype.onDrop = function (editor) {
+            }
+            onDrop(editor) {
                 command.onDrop(editor);
-            };
-            class_1.prototype.description = function (editor, localizationTable) {
+            }
+            description(editor, localizationTable) {
                 return localizationTable.inverseOf(command.description(editor, localizationTable));
-            };
-            return class_1;
-        }(SerializableCommand))('inverse');
+            }
+        }('inverse');
     }
     else {
         // Command that does the inverse of [command].
-        var result = new /** @class */ (function (_super) {
-            __extends(class_2, _super);
-            function class_2() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            class_2.prototype.apply = function (editor) {
+        const result = new class extends Command {
+            apply(editor) {
                 command.unapply(editor);
-            };
-            class_2.prototype.unapply = function (editor) {
+            }
+            unapply(editor) {
                 command.apply(editor);
-            };
-            class_2.prototype.onDrop = function (editor) {
+            }
+            onDrop(editor) {
                 command.onDrop(editor);
-            };
-            class_2.prototype.description = function (editor, localizationTable) {
+            }
+            description(editor, localizationTable) {
                 return localizationTable.inverseOf(command.description(editor, localizationTable));
-            };
-            return class_2;
-        }(Command));
+            }
+        };
         // We know that T does not extend SerializableCommand, and thus returning a Command
         // is appropriate.
         return result;
     }
 };
-SerializableCommand.register('inverse', function (data, editor) {
+SerializableCommand.register('inverse', (data, editor) => {
     return invertCommand(SerializableCommand.deserialize(data, editor));
 });
 export default invertCommand;

package/dist/mjs/commands/localization.d.ts

@@ -1,4 +1,4 @@
-import Rect2 from '../math/shapes/Rect2';
+import { Rect2 } from '@js-draw/math';
 export interface CommandLocalization {
     movedLeft: string;
     movedUp: string;

package/dist/mjs/commands/localization.mjs

@@ -1,21 +1,21 @@
-export var defaultCommandLocalization = {
+export const defaultCommandLocalization = {
     updatedViewport: 'Transformed Viewport',
-    transformedElements: function (elemCount) { return "Transformed ".concat(elemCount, " element").concat(elemCount === 1 ? '' : 's'); },
-    resizeOutputCommand: function (newSize) { return "Resized image to ".concat(newSize.w, "x").concat(newSize.h); },
-    addElementAction: function (componentDescription) { return "Added ".concat(componentDescription); },
-    eraseAction: function (componentDescription, numElems) { return "Erased ".concat(numElems, " ").concat(componentDescription); },
-    duplicateAction: function (componentDescription, numElems) { return "Duplicated ".concat(numElems, " ").concat(componentDescription); },
-    unionOf: function (actionDescription, actionCount) { return "Union: ".concat(actionCount, " ").concat(actionDescription); },
-    inverseOf: function (actionDescription) { return "Inverse of ".concat(actionDescription); },
+    transformedElements: (elemCount) => `Transformed ${elemCount} element${elemCount === 1 ? '' : 's'}`,
+    resizeOutputCommand: (newSize) => `Resized image to ${newSize.w}x${newSize.h}`,
+    addElementAction: (componentDescription) => `Added ${componentDescription}`,
+    eraseAction: (componentDescription, numElems) => `Erased ${numElems} ${componentDescription}`,
+    duplicateAction: (componentDescription, numElems) => `Duplicated ${numElems} ${componentDescription}`,
+    unionOf: (actionDescription, actionCount) => `Union: ${actionCount} ${actionDescription}`,
+    inverseOf: (actionDescription) => `Inverse of ${actionDescription}`,
     elements: 'Elements',
     erasedNoElements: 'Erased nothing',
     duplicatedNoElements: 'Duplicated nothing',
-    rotatedBy: function (degrees) { return "Rotated by ".concat(Math.abs(degrees), " degrees ").concat(degrees < 0 ? 'clockwise' : 'counter-clockwise'); },
+    rotatedBy: (degrees) => `Rotated by ${Math.abs(degrees)} degrees ${degrees < 0 ? 'clockwise' : 'counter-clockwise'}`,
     movedLeft: 'Moved left',
     movedUp: 'Moved up',
     movedDown: 'Moved down',
     movedRight: 'Moved right',
     zoomedOut: 'Zoomed out',
     zoomedIn: 'Zoomed in',
-    selectedElements: function (count) { return "Selected ".concat(count, " element").concat(count === 1 ? '' : 's'); },
+    selectedElements: (count) => `Selected ${count} element${count === 1 ? '' : 's'}`,
 };