js-draw 0.25.1 → 1.0.1

package/dist/mjs/rendering/renderers/TextOnlyRenderer.mjs

@@ -1,87 +1,58 @@
-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 __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  { Vec2 }  from '../../math/Vec2.mjs';
+import { Vec2 } from '@js-draw/math';
 import  AbstractRenderer  from './AbstractRenderer.mjs';
 // Outputs a description of what was rendered.
-var TextOnlyRenderer = /** @class */ (function (_super) {
-    __extends(TextOnlyRenderer, _super);
-    function TextOnlyRenderer(viewport, localizationTable) {
-        var _this = _super.call(this, viewport) || this;
-        _this.localizationTable = localizationTable;
-        _this.descriptionBuilder = [];
-        _this.pathCount = 0;
-        _this.textNodeCount = 0;
-        _this.imageNodeCount = 0;
-        return _this;
+export default class TextOnlyRenderer extends AbstractRenderer {
+    constructor(viewport, localizationTable) {
+        super(viewport);
+        this.localizationTable = localizationTable;
+        this.descriptionBuilder = [];
+        this.pathCount = 0;
+        this.textNodeCount = 0;
+        this.imageNodeCount = 0;
     }
-    TextOnlyRenderer.prototype.displaySize = function () {
+    displaySize() {
         // We don't have a graphical display, export a reasonable size.
         return Vec2.of(500, 500);
-    };
-    TextOnlyRenderer.prototype.clear = function () {
+    }
+    clear() {
         this.descriptionBuilder = [];
         this.pathCount = 0;
         this.textNodeCount = 0;
         this.imageNodeCount = 0;
-    };
-    TextOnlyRenderer.prototype.getDescription = function () {
-        return __spreadArray(__spreadArray(__spreadArray([
-            this.localizationTable.pathNodeCount(this.pathCount)
-        ], (this.textNodeCount > 0 ? [this.localizationTable.textNodeCount(this.textNodeCount)] : []), true), (this.imageNodeCount > 0 ? [this.localizationTable.imageNodeCount(this.imageNodeCount)] : []), true), this.descriptionBuilder, true).join('\n');
-    };
-    TextOnlyRenderer.prototype.beginPath = function (_startPoint) {
-    };
-    TextOnlyRenderer.prototype.endPath = function (_style) {
+    }
+    getDescription() {
+        return [
+            this.localizationTable.pathNodeCount(this.pathCount),
+            ...(this.textNodeCount > 0 ? [this.localizationTable.textNodeCount(this.textNodeCount)] : []),
+            ...(this.imageNodeCount > 0 ? [this.localizationTable.imageNodeCount(this.imageNodeCount)] : []),
+            ...this.descriptionBuilder
+        ].join('\n');
+    }
+    beginPath(_startPoint) {
+    }
+    endPath(_style) {
         this.pathCount++;
-    };
-    TextOnlyRenderer.prototype.lineTo = function (_point) {
-    };
-    TextOnlyRenderer.prototype.moveTo = function (_point) {
-    };
-    TextOnlyRenderer.prototype.traceCubicBezierCurve = function (_p1, _p2, _p3) {
-    };
-    TextOnlyRenderer.prototype.traceQuadraticBezierCurve = function (_controlPoint, _endPoint) {
-    };
-    TextOnlyRenderer.prototype.drawText = function (text, _transform, _style) {
+    }
+    lineTo(_point) {
+    }
+    moveTo(_point) {
+    }
+    traceCubicBezierCurve(_p1, _p2, _p3) {
+    }
+    traceQuadraticBezierCurve(_controlPoint, _endPoint) {
+    }
+    drawText(text, _transform, _style) {
         this.descriptionBuilder.push(this.localizationTable.textNode(text));
         this.textNodeCount++;
-    };
-    TextOnlyRenderer.prototype.drawImage = function (image) {
-        var label = image.label ? this.localizationTable.imageNode(image.label) : this.localizationTable.unlabeledImageNode;
+    }
+    drawImage(image) {
+        const label = image.label ? this.localizationTable.imageNode(image.label) : this.localizationTable.unlabeledImageNode;
         this.descriptionBuilder.push(label);
         this.imageNodeCount++;
-    };
-    TextOnlyRenderer.prototype.isTooSmallToRender = function (rect) {
+    }
+    isTooSmallToRender(rect) {
         return rect.maxDimension < 15 / this.getSizeOfCanvasPixelOnScreen();
-    };
-    TextOnlyRenderer.prototype.drawPoints = function () {
-        var _points = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            _points[_i] = arguments[_i];
-        }
-    };
-    return TextOnlyRenderer;
-}(AbstractRenderer));
-export default TextOnlyRenderer;
+    }
+    drawPoints(..._points) {
+    }
+}

package/dist/mjs/shortcuts/KeyBinding.d.ts

@@ -1,6 +1,11 @@
 export interface KeyCombination {
     /** A key (e.g. `a`, `b`, `control`). */
     readonly key: string;
+    /**
+     * The layout-independent name of the key being pressed. For example,
+     * KeyA for the `a` key.
+     */
+    readonly code?: string;
     /**
      * Whether the shift key must be pressed to trigger the shortcut.
      */

package/dist/mjs/shortcuts/KeyBinding.mjs

@@ -1,6 +1,16 @@
+const isUppercaseLetter = (text) => {
+    return text.toUpperCase() === text
+        && text.toLowerCase() !== text
+        && text.length === 1;
+};
+const isLowercaseLetter = (text) => {
+    return text.toLowerCase() === text
+        && text.toUpperCase() !== text
+        && text.length === 1;
+};
 /** Represents a key combination that can trigger a keyboard shortcut. */
-var KeyBinding = /** @class */ (function () {
-    function KeyBinding(trigger) {
+export default class KeyBinding {
+    constructor(trigger) {
         this.key = trigger.key;
         this.shiftKey = trigger.shiftKey;
         this.ctrlKey = trigger.ctrlKey;
@@ -9,52 +19,50 @@ var KeyBinding = /** @class */ (function () {
         this.controlOrMeta = trigger.controlOrMeta;
     }
     /** Returns true if and only if `keyEvent` should trigger this shortcut. */
-    KeyBinding.prototype.matchesEvent = function (keyEvent) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        var lowercaseKey = (_a = keyEvent.key) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    matchesEvent(keyEvent) {
+        const lowercaseKey = keyEvent.key?.toLowerCase();
         // Determine whether the input is an upper case letter or not.
-        var isUpperCaseKey = ((_b = keyEvent.key) === null || _b === void 0 ? void 0 : _b.toUpperCase()) === keyEvent.key
-            && ((_c = keyEvent.key) === null || _c === void 0 ? void 0 : _c.toLowerCase()) !== keyEvent.key
-            && ((_d = keyEvent.key) === null || _d === void 0 ? void 0 : _d.length) === 1;
-        var isLowercaseKey = ((_e = keyEvent.key) === null || _e === void 0 ? void 0 : _e.toLowerCase()) === keyEvent.key
-            && !isUpperCaseKey
-            && ((_f = keyEvent.key) === null || _f === void 0 ? void 0 : _f.length) === 1;
-        var ctrlKey = ((_g = keyEvent.ctrlKey) !== null && _g !== void 0 ? _g : false) || lowercaseKey === 'control';
-        var altKey = ((_h = keyEvent.altKey) !== null && _h !== void 0 ? _h : false) || lowercaseKey === 'alt';
-        var metaKey = ((_j = keyEvent.metaKey) !== null && _j !== void 0 ? _j : false) || lowercaseKey === 'meta';
-        var shiftKey = ((_k = keyEvent.shiftKey) !== null && _k !== void 0 ? _k : isUpperCaseKey) || lowercaseKey === 'shift';
-        var keyEventHasCtrlOrMeta = keyEvent.controlOrMeta || keyEvent.ctrlKey || keyEvent.metaKey || false;
-        // Different keys entirely? They don't match.
-        if (this.key.toLowerCase() !== lowercaseKey) {
-            return false;
-        }
-        // If a case where the ASCII case of the given key might matter,
-        // compare.
-        if ((isUpperCaseKey || isLowercaseKey) && this.key !== keyEvent.key) {
-            // this.shiftKey may be interpreted as allowing this shortcut to be uppercased.
-            // If so, try making this.key uppercase and matching the shortcut.
-            var uppercaseKeyMatches = this.shiftKey === true && this.key.toUpperCase() === keyEvent.key;
-            if (!uppercaseKeyMatches) {
+        const isUpperCaseKey = isUppercaseLetter(keyEvent.key ?? '');
+        const isLowercaseKey = isLowercaseLetter(keyEvent.key ?? '');
+        const ctrlKey = (keyEvent.ctrlKey ?? false) || lowercaseKey === 'control';
+        const altKey = (keyEvent.altKey ?? false) || lowercaseKey === 'alt';
+        const metaKey = (keyEvent.metaKey ?? false) || lowercaseKey === 'meta';
+        const shiftKey = (keyEvent.shiftKey ?? isUpperCaseKey) || lowercaseKey === 'shift';
+        const keyEventHasCtrlOrMeta = keyEvent.controlOrMeta || keyEvent.ctrlKey || keyEvent.metaKey || false;
+        // If we're not working with key codes,
+        if (this.key !== keyEvent.code) {
+            // Different keys entirely? They don't match.
+            if (this.key.toLowerCase() !== lowercaseKey) {
                 return false;
             }
+            // If a case where the ASCII case of the given key might matter,
+            // compare.
+            if ((isUpperCaseKey || isLowercaseKey) && this.key !== keyEvent.key) {
+                // this.shiftKey may be interpreted as allowing this shortcut to be uppercased.
+                // If so, try making this.key uppercase and matching the shortcut.
+                const uppercaseKeyMatches = this.shiftKey === true && this.key.toUpperCase() === keyEvent.key;
+                if (!uppercaseKeyMatches) {
+                    return false;
+                }
+            }
         }
-        var shortcutControlOrMeta = this.controlOrMeta;
+        const shortcutControlOrMeta = this.controlOrMeta;
         // Match ctrl/meta if the shortcut doesn't have controlOrMeta specified
         // (controlOrMeta should match either).
-        var ctrlAndMetaMatches = ctrlKey === this.ctrlKey
+        const ctrlAndMetaMatches = ctrlKey === this.ctrlKey
             && metaKey === this.metaKey
             && !shortcutControlOrMeta;
-        var matches = (ctrlAndMetaMatches || (shortcutControlOrMeta && keyEventHasCtrlOrMeta))
+        const matches = (ctrlAndMetaMatches || (shortcutControlOrMeta && keyEventHasCtrlOrMeta))
             && altKey === this.altKey
             && (shiftKey === this.shiftKey || this.shiftKey === undefined);
         return matches;
-    };
+    }
     /**
      * Returns a string representation of this shortcut in the same format accepted by
      * {@link fromString}.
      */
-    KeyBinding.prototype.toString = function () {
-        var result = [];
+    toString() {
+        const result = [];
         if (this.ctrlKey && this.key !== 'control') {
             result.push('Ctrl');
         }
@@ -72,45 +80,62 @@ var KeyBinding = /** @class */ (function () {
         }
         result.push(this.key);
         return result.join('+');
-    };
+    }
     /**
      * Accepts a string in the form `modifier1+modifier2+...+key` (e.g. `Ctrl+Shift+a`)
      * and returns the corresponding `KeyboardShortcut`.
      */
-    KeyBinding.fromString = function (shortcutStr) {
-        var _a;
-        var hasNoModifiers = shortcutStr.search(/[-+]/) === -1 || shortcutStr.length === 1;
-        if (hasNoModifiers) {
-            var lowercaseKey = shortcutStr.toLowerCase();
-            // undefined: don't require or not require shift.
-            var shiftKey_1 = undefined;
+    static fromString(shortcutStr) {
+        const getDefaultModifiers = (key) => {
+            // Unless a letter, as long as the given key matches, it shouldn't matter whether
+            // the shift key is pressed.
+            let shiftKey = undefined;
+            if (isUppercaseLetter(key)) {
+                shiftKey = true;
+            }
+            else if (isLowercaseLetter(key)) {
+                shiftKey = false;
+            }
+            // If not just a single character (e.g. a key code like KeyA), shift must
+            // be specified manually.
+            else if (key.length > 1) {
+                shiftKey = false;
+            }
+            const lowercaseKey = key.toLowerCase();
             // shiftKey should always be true if the key is 'shift'
             if (lowercaseKey === 'shift') {
-                shiftKey_1 = true;
+                shiftKey = true;
             }
-            return new KeyBinding({
-                key: shortcutStr,
-                shiftKey: shiftKey_1,
+            return {
+                shiftKey,
                 ctrlKey: lowercaseKey === 'control' || lowercaseKey === 'ctrl',
                 altKey: lowercaseKey === 'alt',
                 metaKey: lowercaseKey === 'meta',
                 controlOrMeta: lowercaseKey === 'control or meta' || lowercaseKey === 'ctrlormeta',
+            };
+        };
+        const hasNoModifiers = shortcutStr.search(/[-+]/) === -1 || shortcutStr.length === 1;
+        if (hasNoModifiers) {
+            const modifiers = getDefaultModifiers(shortcutStr);
+            return new KeyBinding({
+                key: shortcutStr,
+                ...modifiers,
             });
         }
-        var keyModifiersExp = /^(.*[-+])?(.+)$/g;
-        var match = keyModifiersExp.exec(shortcutStr);
+        const keyModifiersExp = /^(.*[-+])?(.+)$/g;
+        const match = keyModifiersExp.exec(shortcutStr);
         if (!match) {
-            throw new Error("Invalid shortcut expression, ".concat(shortcutStr, "!"));
+            throw new Error(`Invalid shortcut expression, ${shortcutStr}!`);
         }
-        var key = match[2];
-        var modifiers = ((_a = match[1]) !== null && _a !== void 0 ? _a : '').split(/[-+]/);
-        var shiftKey = undefined;
-        var ctrlKey = false;
-        var altKey = false;
-        var metaKey = false;
-        var controlOrMeta = false;
-        for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
-            var modifier = modifiers_1[_i];
+        const key = match[2];
+        const defaultModifiers = getDefaultModifiers(key);
+        const modifierStrings = (match[1] ?? '').split(/[-+]/);
+        let shiftKey = defaultModifiers.shiftKey;
+        let ctrlKey = defaultModifiers.ctrlKey;
+        let altKey = defaultModifiers.altKey;
+        let metaKey = defaultModifiers.metaKey;
+        let controlOrMeta = defaultModifiers.controlOrMeta;
+        for (const modifier of modifierStrings) {
             if (modifier === '') {
                 continue;
             }
@@ -118,8 +143,8 @@ var KeyBinding = /** @class */ (function () {
                 case 'shift':
                     shiftKey = true;
                     break;
-                case 'noshift':
-                    shiftKey = false;
+                case 'anyshift':
+                    shiftKey = undefined;
                     break;
                 case 'ctrl':
                 case 'control':
@@ -137,19 +162,17 @@ var KeyBinding = /** @class */ (function () {
                     altKey = true;
                     break;
                 default:
-                    throw new Error("Unknown modifier: \"".concat(modifier, "\" in shortcut ").concat(shortcutStr, "."));
+                    throw new Error(`Unknown modifier: "${modifier}" in shortcut ${shortcutStr}.`);
             }
         }
-        var shortcut = new KeyBinding({
-            key: key,
-            shiftKey: shiftKey,
-            ctrlKey: ctrlKey,
-            altKey: altKey,
-            metaKey: metaKey,
-            controlOrMeta: controlOrMeta,
+        const shortcut = new KeyBinding({
+            key,
+            shiftKey,
+            ctrlKey,
+            altKey,
+            metaKey,
+            controlOrMeta,
         });
         return shortcut;
-    };
-    return KeyBinding;
-}());
-export default KeyBinding;
+    }
+}

package/dist/mjs/shortcuts/KeyboardShortcutManager.d.ts

@@ -59,7 +59,7 @@ export default class KeyboardShortcutManager {
      *
      * @see {@link getShortcutDescription}
      */
-    static getAllShortcutIds(): any[];
+    static getAllShortcutIds(): string[];
     /**
      * Get the default keybindings associated with a keyboard shortcut.
      *

package/dist/mjs/shortcuts/KeyboardShortcutManager.mjs

@@ -1,27 +1,18 @@
-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  { matchingLocalizationTable }  from '../localizations/getLocalizationTable.mjs';
 import  KeyBinding  from './KeyBinding.mjs';
 /**
  * Allows adding/changing keyboard shortcuts. This class provides static methods for registering
  * default shortcuts. An instance of this class must be used to access or change keyboard shortcuts.
  */
-var KeyboardShortcutManager = /** @class */ (function () {
+class KeyboardShortcutManager {
     /**
      * Creates a new `ShortcutManager` with an initial set of shortcut overrides.
      *
      * @internal
      */
-    function KeyboardShortcutManager(initialOverrides) {
+    constructor(initialOverrides) {
         this.shortcutOverrides = Object.create(null);
-        for (var id in initialOverrides) {
+        for (const id in initialOverrides) {
             this.overrideShortcut(id, initialOverrides[id]);
         }
     }
@@ -29,30 +20,29 @@ var KeyboardShortcutManager = /** @class */ (function () {
      * Override an existing shortcut with a custom set of triggers.
      * @internal
      */
-    KeyboardShortcutManager.prototype.overrideShortcut = function (shortcutId, overrideWith) {
-        this.shortcutOverrides[shortcutId] = __spreadArray([], overrideWith, true);
-    };
+    overrideShortcut(shortcutId, overrideWith) {
+        this.shortcutOverrides[shortcutId] = [...overrideWith];
+    }
     /** Returns true if `keyEvent` matches the shortcut with `shortcutId`. @internal */
-    KeyboardShortcutManager.prototype.matchesShortcut = function (shortcutId, keyEvent) {
+    matchesShortcut(shortcutId, keyEvent) {
         // Get all shortcucts associated with `shortcutId`.
-        var shortcutList = this.shortcutOverrides[shortcutId];
+        let shortcutList = this.shortcutOverrides[shortcutId];
         if (!shortcutList) {
             if (shortcutId in KeyboardShortcutManager.shortcuts) {
                 shortcutList = KeyboardShortcutManager.shortcuts[shortcutId];
             }
             else {
-                throw new Error("No shortcut with ID ".concat(shortcutId, " exists!"));
+                throw new Error(`No shortcut with ID ${shortcutId} exists!`);
             }
         }
         // return true if keyEvent matches *any* shortcuts in shortcutList
-        for (var _i = 0, shortcutList_1 = shortcutList; _i < shortcutList_1.length; _i++) {
-            var shortcut = shortcutList_1[_i];
+        for (const shortcut of shortcutList) {
             if (shortcut.matchesEvent(keyEvent)) {
                 return true;
             }
         }
         return false;
-    };
+    }
     /**
      * Registers a default keyboard shortcut that can be overridden by individual instances
      * of `ShortcutManager`. Note that `id` should be a globally unique identifier.
@@ -82,65 +72,63 @@ var KeyboardShortcutManager = /** @class */ (function () {
      *
      * @internal
      */
-    KeyboardShortcutManager.registerDefaultKeyboardShortcut = function (id, shortcuts, defaultDescription) {
+    static registerDefaultKeyboardShortcut(id, shortcuts, defaultDescription) {
         if (id in KeyboardShortcutManager.shortcuts) {
             return false;
         }
         // Convert the strings to shortcut maps.
-        var shortcutsAsShortcuts = shortcuts.map(function (shortcut) {
+        const shortcutsAsShortcuts = shortcuts.map(shortcut => {
             if (typeof (shortcut) === 'string') {
                 return KeyBinding.fromString(shortcut);
             }
             return shortcut;
         });
-        KeyboardShortcutManager.shortcuts[id] = __spreadArray([], shortcutsAsShortcuts, true);
+        KeyboardShortcutManager.shortcuts[id] = [...shortcutsAsShortcuts];
         KeyboardShortcutManager.shortcutDefaultDescriptions[id] = defaultDescription;
         return true;
-    };
+    }
     /** Provides a localized description of a keyboard shortcut. @internal */
-    KeyboardShortcutManager.provideShortcutDescription = function (id, locale, description) {
+    static provideShortcutDescription(id, locale, description) {
         if (!(locale in KeyboardShortcutManager.shortcutLocalizedDescriptions)) {
             KeyboardShortcutManager.shortcutLocalizedDescriptions[locale] = Object.create(null);
         }
         KeyboardShortcutManager.shortcutLocalizedDescriptions[locale][id] = description;
-    };
+    }
     /**
      * Gets all registered keyboard shortcut IDs.
      *
      * @see {@link getShortcutDescription}
      */
-    KeyboardShortcutManager.getAllShortcutIds = function () {
-        var ids = [];
-        for (var id in this.shortcuts) {
+    static getAllShortcutIds() {
+        const ids = [];
+        for (const id in this.shortcuts) {
             ids.push(id);
         }
         return ids;
-    };
+    }
     /**
      * Get the default keybindings associated with a keyboard shortcut.
      *
      * Any keybinding in the resultant list, by default, can trigger the function associated
      * with the shortcut.
      */
-    KeyboardShortcutManager.getShortcutDefaultKeybindings = function (shortcutId) {
+    static getShortcutDefaultKeybindings(shortcutId) {
         if (!(shortcutId in KeyboardShortcutManager.shortcuts)) {
-            throw new Error("No shortcut with ID ".concat(shortcutId, " exists!"));
+            throw new Error(`No shortcut with ID ${shortcutId} exists!`);
         }
         return KeyboardShortcutManager.shortcuts[shortcutId];
-    };
+    }
     /**
      * Get a description of a keyboard shortcut.
      *
      * `localeList`, if given, attempts to
      */
-    KeyboardShortcutManager.getShortcutDescription = function (id, localeList) {
-        var _a, _b;
-        var localizationTable = matchingLocalizationTable(localeList !== null && localeList !== void 0 ? localeList : [], this.shortcutLocalizedDescriptions, this.shortcutDefaultDescriptions);
-        return (_b = (_a = localizationTable[id]) !== null && _a !== void 0 ? _a : this.shortcutDefaultDescriptions[id]) !== null && _b !== void 0 ? _b : null;
-    };
-    KeyboardShortcutManager.shortcuts = Object.create(null);
-    KeyboardShortcutManager.shortcutDefaultDescriptions = Object.create(null);
-    KeyboardShortcutManager.shortcutLocalizedDescriptions = Object.create(null);
-    return KeyboardShortcutManager;
-}());
+    static getShortcutDescription(id, localeList) {
+        const localizationTable = matchingLocalizationTable(localeList ?? [], this.shortcutLocalizedDescriptions, this.shortcutDefaultDescriptions);
+        return localizationTable[id] ?? this.shortcutDefaultDescriptions[id] ?? null;
+    }
+}
+KeyboardShortcutManager.shortcuts = Object.create(null);
+KeyboardShortcutManager.shortcutDefaultDescriptions = Object.create(null);
+KeyboardShortcutManager.shortcutLocalizedDescriptions = Object.create(null);
 export default KeyboardShortcutManager;

package/dist/mjs/testing/createEditor.mjs

@@ -1,9 +1,9 @@
 import  { RenderingMode }  from '../rendering/Display.mjs';
 import  Editor  from '../Editor.mjs';
 /** Creates an editor. Should only be used in test files. */
-export default (function () {
+export default () => {
     if (jest === undefined) {
         throw new Error('Files in the testing/ folder should only be used in tests!');
     }
     return new Editor(document.body, { renderingMode: RenderingMode.DummyRenderer });
-});
+};

package/dist/mjs/testing/getUniquePointerId.mjs

@@ -1,10 +1,9 @@
 /** Returns the smallest ID not used by the pointers in the given list. */
-var getUniquePointerId = function (pointers) {
-    var ptrId = 0;
-    var pointerIds = pointers.map(function (ptr) { return ptr.id; });
+const getUniquePointerId = (pointers) => {
+    let ptrId = 0;
+    const pointerIds = pointers.map(ptr => ptr.id);
     pointerIds.sort();
-    for (var _i = 0, pointerIds_1 = pointerIds; _i < pointerIds_1.length; _i++) {
-        var pointerId = pointerIds_1[_i];
+    for (const pointerId of pointerIds) {
         if (ptrId === pointerId) {
             ptrId = pointerId + 1;
         }

package/dist/mjs/testing/sendPenEvent.d.ts

@@ -1,7 +1,7 @@
 import Editor from '../Editor';
-import { Point2 } from '../math/Vec2';
+import { Point2 } from '@js-draw/math';
 import Pointer from '../Pointer';
-import { InputEvtType } from '../types';
+import { InputEvtType } from '../inputEvents';
 /**
  * Dispatch a pen event to the currently selected tool.
  * Intended for unit tests.

package/dist/mjs/testing/sendPenEvent.mjs

@@ -1,5 +1,5 @@
 import  Pointer  from '../Pointer.mjs';
-import  { InputEvtType }  from '../types.mjs';
+import  { InputEvtType }  from '../inputEvents.mjs';
 import  getUniquePointerId  from './getUniquePointerId.mjs';
 /**
  * Dispatch a pen event to the currently selected tool.
@@ -7,12 +7,12 @@ import  getUniquePointerId  from './getUniquePointerId.mjs';
  *
  * @see {@link sendTouchEvent}
  */
-var sendPenEvent = function (editor, eventType, point, allPointers) {
-    var id = getUniquePointerId(allPointers !== null && allPointers !== void 0 ? allPointers : []);
-    var mainPointer = Pointer.ofCanvasPoint(point, eventType !== InputEvtType.PointerUpEvt, editor.viewport, id);
+const sendPenEvent = (editor, eventType, point, allPointers) => {
+    const id = getUniquePointerId(allPointers ?? []);
+    const mainPointer = Pointer.ofCanvasPoint(point, eventType !== InputEvtType.PointerUpEvt, editor.viewport, id);
     editor.toolController.dispatchInputEvent({
         kind: eventType,
-        allPointers: allPointers !== null && allPointers !== void 0 ? allPointers : [
+        allPointers: allPointers ?? [
             mainPointer,
         ],
         current: mainPointer,

package/dist/mjs/testing/sendTouchEvent.d.ts

@@ -1,7 +1,7 @@
 import Editor from '../Editor';
-import { Vec2 } from '../math/Vec2';
+import { Vec2 } from '@js-draw/math';
 import Pointer from '../Pointer';
-import { InputEvtType } from '../types';
+import { InputEvtType } from '../inputEvents';
 /**
  * Dispatch a touch event to the currently selected tool. Intended for unit tests.
  *