js-draw 0.23.0 → 0.24.0

package/dist/cjs/shortcuts/KeyBinding.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Represents a key combination that can trigger a keyboard shortcut. */
+var KeyBinding = /** @class */ (function () {
+    function KeyBinding(trigger) {
+        this.key = trigger.key;
+        this.shiftKey = trigger.shiftKey;
+        this.ctrlKey = trigger.ctrlKey;
+        this.altKey = trigger.altKey;
+        this.metaKey = trigger.metaKey;
+        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();
+        // 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) {
+                return false;
+            }
+        }
+        var shortcutControlOrMeta = this.controlOrMeta;
+        // Match ctrl/meta if the shortcut doesn't have controlOrMeta specified
+        // (controlOrMeta should match either).
+        var ctrlAndMetaMatches = ctrlKey === this.ctrlKey
+            && metaKey === this.metaKey
+            && !shortcutControlOrMeta;
+        var 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 = [];
+        if (this.ctrlKey && this.key !== 'control') {
+            result.push('Ctrl');
+        }
+        if (this.controlOrMeta) {
+            result.push('CtrlOrMeta');
+        }
+        if (this.altKey && this.key !== 'alt') {
+            result.push('Alt');
+        }
+        if (this.metaKey && this.key !== 'meta') {
+            result.push('Meta');
+        }
+        if (this.shiftKey && this.key !== 'shift') {
+            result.push('Shift');
+        }
+        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;
+            // shiftKey should always be true if the key is 'shift'
+            if (lowercaseKey === 'shift') {
+                shiftKey_1 = true;
+            }
+            return new KeyBinding({
+                key: shortcutStr,
+                shiftKey: shiftKey_1,
+                ctrlKey: lowercaseKey === 'control' || lowercaseKey === 'ctrl',
+                altKey: lowercaseKey === 'alt',
+                metaKey: lowercaseKey === 'meta',
+                controlOrMeta: lowercaseKey === 'control or meta' || lowercaseKey === 'ctrlormeta',
+            });
+        }
+        var keyModifiersExp = /^(.*[-+])?(.+)$/g;
+        var match = keyModifiersExp.exec(shortcutStr);
+        if (!match) {
+            throw new Error("Invalid shortcut expression, ".concat(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];
+            if (modifier === '') {
+                continue;
+            }
+            switch (modifier.toLowerCase()) {
+                case 'shift':
+                    shiftKey = true;
+                    break;
+                case 'noshift':
+                    shiftKey = false;
+                    break;
+                case 'ctrl':
+                case 'control':
+                    ctrlKey = true;
+                    break;
+                case 'meta':
+                    metaKey = true;
+                    break;
+                case 'ctrlormeta':
+                case 'ctrl or meta':
+                case 'controlormeta':
+                    controlOrMeta = true;
+                    break;
+                case 'alt':
+                    altKey = true;
+                    break;
+                default:
+                    throw new Error("Unknown modifier: \"".concat(modifier, "\" in shortcut ").concat(shortcutStr, "."));
+            }
+        }
+        var shortcut = new KeyBinding({
+            key: key,
+            shiftKey: shiftKey,
+            ctrlKey: ctrlKey,
+            altKey: altKey,
+            metaKey: metaKey,
+            controlOrMeta: controlOrMeta,
+        });
+        return shortcut;
+    };
+    return KeyBinding;
+}());
+exports.default = KeyBinding;

package/dist/cjs/shortcuts/KeyBinding.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,77 @@
+import KeyBinding, { KeyCombination } from './KeyBinding';
+type ShortcutDictionary = Record<string, KeyBinding[]>;
+/**
+ * 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.
+ */
+export default class KeyboardShortcutManager {
+    private static shortcuts;
+    private static shortcutDefaultDescriptions;
+    private static shortcutLocalizedDescriptions;
+    private shortcutOverrides;
+    /**
+     * Creates a new `ShortcutManager` with an initial set of shortcut overrides.
+     *
+     * @internal
+     */
+    constructor(initialOverrides: ShortcutDictionary);
+    /**
+     * Override an existing shortcut with a custom set of triggers.
+     * @internal
+     */
+    overrideShortcut(shortcutId: string, overrideWith: KeyBinding[]): void;
+    /** Returns true if `keyEvent` matches the shortcut with `shortcutId`. @internal */
+    matchesShortcut(shortcutId: string, keyEvent: Partial<KeyCombination>): boolean;
+    /**
+     * Registers a default keyboard shortcut that can be overridden by individual instances
+     * of `ShortcutManager`. Note that `id` should be a globally unique identifier.
+     *
+     * Only the first call to this method for a given `id` has an effect.
+     *
+     * @example
+     * ```ts
+     * const shortcutId = 'io.github.personalizedrefrigerator.js-draw.select-all';
+     *
+     * // Associate two shortcuts with the same ID
+     * const shortcut1 = KeyboardShortcutManager.keyboardShortcutFromString('ctrlOrMeta+a');
+     * const shortcut2 = KeyboardShortcutManager.keyboardShortcutFromString('ctrlOrMeta+shift+a');
+     * KeyboardShortcutManager.registerDefaultKeyboardShortcut(
+     * 	shortcutId,
+     * 	[ shortcut1, shortcut2 ],
+     * 	"Select All",
+     * );
+     *
+     * // Provide a localized description
+     * KeyboardShortcutManager.provideShortcutDescription(
+     * 	shotcutId,
+     * 	'es',
+     * 	'Seleccionar todo',
+     * );
+     * ```
+     *
+     * @internal
+     */
+    static registerDefaultKeyboardShortcut(id: string, shortcuts: (KeyBinding | string)[], defaultDescription: string): boolean;
+    /** Provides a localized description of a keyboard shortcut. @internal */
+    static provideShortcutDescription(id: string, locale: string, description: string): void;
+    /**
+     * Gets all registered keyboard shortcut IDs.
+     *
+     * @see {@link getShortcutDescription}
+     */
+    static getAllShortcutIds(): any[];
+    /**
+     * 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.
+     */
+    static getShortcutDefaultKeybindings(shortcutId: string): KeyBinding[];
+    /**
+     * Get a description of a keyboard shortcut.
+     *
+     * `localeList`, if given, attempts to
+     */
+    static getShortcutDescription(id: string, localeList?: readonly string[]): string | null;
+}
+export {};

package/dist/cjs/shortcuts/KeyboardShortcutManager.js

@@ -0,0 +1,148 @@
+"use strict";
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var getLocalizationTable_1 = require("../localizations/getLocalizationTable");
+var KeyBinding_1 = require("./KeyBinding");
+/**
+ * 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 () {
+    /**
+     * Creates a new `ShortcutManager` with an initial set of shortcut overrides.
+     *
+     * @internal
+     */
+    function KeyboardShortcutManager(initialOverrides) {
+        this.shortcutOverrides = Object.create(null);
+        for (var id in initialOverrides) {
+            this.overrideShortcut(id, initialOverrides[id]);
+        }
+    }
+    /**
+     * Override an existing shortcut with a custom set of triggers.
+     * @internal
+     */
+    KeyboardShortcutManager.prototype.overrideShortcut = function (shortcutId, overrideWith) {
+        this.shortcutOverrides[shortcutId] = __spreadArray([], overrideWith, true);
+    };
+    /** Returns true if `keyEvent` matches the shortcut with `shortcutId`. @internal */
+    KeyboardShortcutManager.prototype.matchesShortcut = function (shortcutId, keyEvent) {
+        // Get all shortcucts associated with `shortcutId`.
+        var 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!"));
+            }
+        }
+        // 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];
+            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.
+     *
+     * Only the first call to this method for a given `id` has an effect.
+     *
+     * @example
+     * ```ts
+     * const shortcutId = 'io.github.personalizedrefrigerator.js-draw.select-all';
+     *
+     * // Associate two shortcuts with the same ID
+     * const shortcut1 = KeyboardShortcutManager.keyboardShortcutFromString('ctrlOrMeta+a');
+     * const shortcut2 = KeyboardShortcutManager.keyboardShortcutFromString('ctrlOrMeta+shift+a');
+     * KeyboardShortcutManager.registerDefaultKeyboardShortcut(
+     * 	shortcutId,
+     * 	[ shortcut1, shortcut2 ],
+     * 	"Select All",
+     * );
+     *
+     * // Provide a localized description
+     * KeyboardShortcutManager.provideShortcutDescription(
+     * 	shotcutId,
+     * 	'es',
+     * 	'Seleccionar todo',
+     * );
+     * ```
+     *
+     * @internal
+     */
+    KeyboardShortcutManager.registerDefaultKeyboardShortcut = function (id, shortcuts, defaultDescription) {
+        if (id in KeyboardShortcutManager.shortcuts) {
+            return false;
+        }
+        // Convert the strings to shortcut maps.
+        var shortcutsAsShortcuts = shortcuts.map(function (shortcut) {
+            if (typeof (shortcut) === 'string') {
+                return KeyBinding_1.default.fromString(shortcut);
+            }
+            return shortcut;
+        });
+        KeyboardShortcutManager.shortcuts[id] = __spreadArray([], shortcutsAsShortcuts, true);
+        KeyboardShortcutManager.shortcutDefaultDescriptions[id] = defaultDescription;
+        return true;
+    };
+    /** Provides a localized description of a keyboard shortcut. @internal */
+    KeyboardShortcutManager.provideShortcutDescription = function (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) {
+            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) {
+        if (!(shortcutId in KeyboardShortcutManager.shortcuts)) {
+            throw new Error("No shortcut with ID ".concat(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 = (0, getLocalizationTable_1.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;
+}());
+exports.default = KeyboardShortcutManager;

package/dist/cjs/shortcuts/KeyboardShortcutManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/shortcuts/lib.d.ts

@@ -0,0 +1,2 @@
+export { default as KeyboardShortcutManager } from './KeyboardShortcutManager';
+export { default as KeyBinding } from './KeyBinding';

package/dist/cjs/shortcuts/lib.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyBinding = exports.KeyboardShortcutManager = void 0;
+var KeyboardShortcutManager_1 = require("./KeyboardShortcutManager");
+Object.defineProperty(exports, "KeyboardShortcutManager", { enumerable: true, get: function () { return KeyboardShortcutManager_1.default; } });
+var KeyBinding_1 = require("./KeyBinding");
+Object.defineProperty(exports, "KeyBinding", { enumerable: true, get: function () { return KeyBinding_1.default; } });

package/dist/cjs/testing/createEditor.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Display_1 = require("../rendering/Display");
+var Editor_1 = require("../Editor");
+/** Creates an editor. Should only be used in test files. */
+exports.default = (function () {
+    if (jest === undefined) {
+        throw new Error('Files in the testing/ folder should only be used in tests!');
+    }
+    return new Editor_1.default(document.body, { renderingMode: Display_1.RenderingMode.DummyRenderer });
+});

package/dist/cjs/testing/lib.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTouchEvent = exports.sendPenEvent = void 0;
+var sendPenEvent_1 = require("./sendPenEvent");
+Object.defineProperty(exports, "sendPenEvent", { enumerable: true, get: function () { return sendPenEvent_1.default; } });
+var sendTouchEvent_1 = require("./sendTouchEvent");
+Object.defineProperty(exports, "sendTouchEvent", { enumerable: true, get: function () { return sendTouchEvent_1.default; } });

package/dist/cjs/testing/sendPenEvent.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Pointer_1 = require("../Pointer");
+var types_1 = require("../types");
+/**
+ * Dispatch a pen event to the currently selected tool.
+ * Intended for unit tests.
+ *
+ * @see {@link sendTouchEvent}
+ */
+var sendPenEvent = function (editor, eventType, point, allPointers) {
+    var mainPointer = Pointer_1.default.ofCanvasPoint(point, eventType !== types_1.InputEvtType.PointerUpEvt, editor.viewport);
+    editor.toolController.dispatchInputEvent({
+        kind: eventType,
+        allPointers: allPointers !== null && allPointers !== void 0 ? allPointers : [
+            mainPointer,
+        ],
+        current: mainPointer,
+    });
+};
+exports.default = sendPenEvent;

package/dist/cjs/testing/sendTouchEvent.js

@@ -0,0 +1,73 @@
+"use strict";
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Pointer_1 = require("../Pointer");
+var types_1 = require("../types");
+/**
+ * Dispatch a touch event to the currently selected tool. Intended for unit tests.
+ *
+ * @see {@link sendPenEvent}
+ *
+ * @example
+ * **Simulating a horizontal swipe gesture:**
+ * ```ts
+ * sendTouchEvent(editor, InputEvtType.PointerDownEvt, Vec2.of(0, 0));
+ * for (let i = 1; i <= 10; i++) {
+ *   jest.advanceTimersByTime(10);
+ *   sendTouchEvent(editor, InputEvtType.PointerMoveEvt, Vec2.of(i * 10, 0));
+ * }
+ * ```
+ *
+ * @example
+ * **Simulating a pinch gesture.** This example assumes that you're using [Jest with timer mocks enabled](https://jestjs.io/docs/timer-mocks).
+ * ```ts
+ * let firstPointer = sendTouchEvent(editor, InputEvtType.PointerDownEvt, Vec2.of(0, 0));
+ * let secondPointer = sendTouchEvent(editor, InputEvtType.PointerDownEvt, Vec2.of(100, 0), [ firstPointer ]);
+ *
+ * // Simulate a pinch
+ * const maxIterations = 10;
+ * for (let i = 0; i < maxIterations; i++) {
+ *   // Use the unit testing framework's tool for increasing the current time
+ *   // returned by (new Date()).getTime(), etc.
+ *   jest.advanceTimersByTime(100);
+ *
+ *   const point1 = Vec2.of(-i * 5, 0);
+ *   const point2 = Vec2.of(i * 5 + 100, 0);
+ *
+ *   firstPointer = sendTouchEvent(editor, InputEvtType.PointerMoveEvt, point1, [ secondPointer ]);
+ *   secondPointer = sendTouchEvent(editor, InputEvtType.PointerMoveEvt, point2, [ firstPointer ]);
+ * }
+ * ```
+ */
+var sendTouchEvent = function (editor, eventType, screenPos, allOtherPointers) {
+    var canvasPos = editor.viewport.screenToCanvas(screenPos);
+    var ptrId = 0;
+    var maxPtrId = 0;
+    // Get a unique ID for the main pointer
+    // (try to use id=0, but don't use it if it's already in use).
+    for (var _i = 0, _a = allOtherPointers !== null && allOtherPointers !== void 0 ? allOtherPointers : []; _i < _a.length; _i++) {
+        var pointer = _a[_i];
+        maxPtrId = Math.max(pointer.id, maxPtrId);
+        if (pointer.id === ptrId) {
+            ptrId = maxPtrId + 1;
+        }
+    }
+    var mainPointer = Pointer_1.default.ofCanvasPoint(canvasPos, eventType !== types_1.InputEvtType.PointerUpEvt, editor.viewport, ptrId, Pointer_1.PointerDevice.Touch);
+    editor.toolController.dispatchInputEvent({
+        kind: eventType,
+        allPointers: __spreadArray(__spreadArray([], (allOtherPointers !== null && allOtherPointers !== void 0 ? allOtherPointers : []), true), [
+            mainPointer,
+        ], false),
+        current: mainPointer,
+    });
+    return mainPointer;
+};
+exports.default = sendTouchEvent;