js-draw 0.23.1 → 0.24.0

package/dist/cjs/tools/ToolController.js

@@ -0,0 +1,179 @@
+"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 types_1 = require("../types");
+var PanZoom_1 = require("./PanZoom");
+var Pen_1 = require("./Pen");
+var ToolEnabledGroup_1 = require("./ToolEnabledGroup");
+var Eraser_1 = require("./Eraser");
+var SelectionTool_1 = require("./SelectionTool/SelectionTool");
+var Color4_1 = require("../Color4");
+var UndoRedoShortcut_1 = require("./UndoRedoShortcut");
+var TextTool_1 = require("./TextTool");
+var PipetteTool_1 = require("./PipetteTool");
+var ToolSwitcherShortcut_1 = require("./ToolSwitcherShortcut");
+var PasteHandler_1 = require("./PasteHandler");
+var ToolbarShortcutHandler_1 = require("./ToolbarShortcutHandler");
+var PressureSensitiveFreehandLineBuilder_1 = require("../components/builders/PressureSensitiveFreehandLineBuilder");
+var FindTool_1 = require("./FindTool");
+var SelectAllShortcutHandler_1 = require("./SelectionTool/SelectAllShortcutHandler");
+var SoundUITool_1 = require("./SoundUITool");
+var ToolController = /** @class */ (function () {
+    /** @internal */
+    function ToolController(editor, localization) {
+        this.activeTool = null;
+        var primaryToolGroup = new ToolEnabledGroup_1.default();
+        this.primaryToolGroup = primaryToolGroup;
+        var panZoomTool = new PanZoom_1.default(editor, PanZoom_1.PanZoomMode.TwoFingerTouchGestures | PanZoom_1.PanZoomMode.RightClickDrags, localization.touchPanTool);
+        var keyboardPanZoomTool = new PanZoom_1.default(editor, PanZoom_1.PanZoomMode.Keyboard, localization.keyboardPanZoom);
+        var primaryPenTool = new Pen_1.default(editor, localization.penTool(1), { color: Color4_1.default.purple, thickness: 8 });
+        var primaryTools = [
+            // Three pens
+            primaryPenTool,
+            new Pen_1.default(editor, localization.penTool(2), { color: Color4_1.default.clay, thickness: 4 }),
+            // Highlighter-like pen with width=40
+            new Pen_1.default(editor, localization.penTool(3), { color: Color4_1.default.ofRGBA(1, 1, 0, 0.5), thickness: 40 }, PressureSensitiveFreehandLineBuilder_1.makePressureSensitiveFreehandLineBuilder),
+            new Eraser_1.default(editor, localization.eraserTool),
+            new SelectionTool_1.default(editor, localization.selectionTool),
+            new TextTool_1.default(editor, localization.textTool, localization),
+            new PanZoom_1.default(editor, PanZoom_1.PanZoomMode.SinglePointerGestures, localization.anyDevicePanning),
+        ];
+        // Accessibility tools
+        var soundExplorer = new SoundUITool_1.default(editor, localization.soundExplorer);
+        soundExplorer.setEnabled(false);
+        this.tools = __spreadArray(__spreadArray([
+            new PipetteTool_1.default(editor, localization.pipetteTool),
+            soundExplorer,
+            panZoomTool
+        ], primaryTools, true), [
+            keyboardPanZoomTool,
+            new UndoRedoShortcut_1.default(editor),
+            new ToolbarShortcutHandler_1.default(editor),
+            new ToolSwitcherShortcut_1.default(editor),
+            new FindTool_1.default(editor),
+            new PasteHandler_1.default(editor),
+            new SelectAllShortcutHandler_1.default(editor),
+        ], false);
+        primaryTools.forEach(function (tool) { return tool.setToolGroup(primaryToolGroup); });
+        panZoomTool.setEnabled(true);
+        primaryPenTool.setEnabled(true);
+        editor.notifier.on(types_1.EditorEventType.ToolEnabled, function (event) {
+            if (event.kind === types_1.EditorEventType.ToolEnabled) {
+                editor.announceForAccessibility(localization.toolEnabledAnnouncement(event.tool.description));
+            }
+        });
+        editor.notifier.on(types_1.EditorEventType.ToolDisabled, function (event) {
+            if (event.kind === types_1.EditorEventType.ToolDisabled) {
+                editor.announceForAccessibility(localization.toolDisabledAnnouncement(event.tool.description));
+            }
+        });
+        this.activeTool = null;
+    }
+    // Replaces the current set of tools with `tools`. This should only be done before
+    // the creation of the app's toolbar (if using `HTMLToolbar`).
+    ToolController.prototype.setTools = function (tools, primaryToolGroup) {
+        this.tools = tools;
+        this.primaryToolGroup = primaryToolGroup !== null && primaryToolGroup !== void 0 ? primaryToolGroup : new ToolEnabledGroup_1.default();
+    };
+    // Add a tool that acts like one of the primary tools (only one primary tool can be enabled at a time).
+    // This should be called before creating the app's toolbar.
+    ToolController.prototype.addPrimaryTool = function (tool) {
+        tool.setToolGroup(this.primaryToolGroup);
+        if (tool.isEnabled()) {
+            this.primaryToolGroup.notifyEnabled(tool);
+        }
+        this.addTool(tool);
+    };
+    ToolController.prototype.getPrimaryTools = function () {
+        var _this = this;
+        return this.tools.filter(function (tool) {
+            return tool.getToolGroup() === _this.primaryToolGroup;
+        });
+    };
+    // Add a tool to the end of this' tool list (the added tool receives events after tools already added to this).
+    // This should be called before creating the app's toolbar.
+    ToolController.prototype.addTool = function (tool) {
+        this.tools.push(tool);
+    };
+    // Returns true if the event was handled
+    ToolController.prototype.dispatchInputEvent = function (event) {
+        var _a, _b;
+        var handled = false;
+        if (event.kind === types_1.InputEvtType.PointerDownEvt) {
+            for (var _i = 0, _c = this.tools; _i < _c.length; _i++) {
+                var tool = _c[_i];
+                if (tool.isEnabled() && tool.onPointerDown(event)) {
+                    if (this.activeTool !== tool) {
+                        (_a = this.activeTool) === null || _a === void 0 ? void 0 : _a.onGestureCancel();
+                    }
+                    this.activeTool = tool;
+                    handled = true;
+                    break;
+                }
+            }
+        }
+        else if (event.kind === types_1.InputEvtType.PointerUpEvt) {
+            (_b = this.activeTool) === null || _b === void 0 ? void 0 : _b.onPointerUp(event);
+            this.activeTool = null;
+            handled = true;
+        }
+        else if (event.kind === types_1.InputEvtType.PointerMoveEvt) {
+            if (this.activeTool !== null) {
+                this.activeTool.onPointerMove(event);
+                handled = true;
+            }
+        }
+        else if (event.kind === types_1.InputEvtType.GestureCancelEvt) {
+            if (this.activeTool !== null) {
+                this.activeTool.onGestureCancel();
+                this.activeTool = null;
+            }
+        }
+        else {
+            var allCasesHandledGuard = void 0;
+            for (var _d = 0, _e = this.tools; _d < _e.length; _d++) {
+                var tool = _e[_d];
+                if (!tool.isEnabled()) {
+                    continue;
+                }
+                switch (event.kind) {
+                    case types_1.InputEvtType.KeyPressEvent:
+                        handled = tool.onKeyPress(event);
+                        break;
+                    case types_1.InputEvtType.KeyUpEvent:
+                        handled = tool.onKeyUp(event);
+                        break;
+                    case types_1.InputEvtType.WheelEvt:
+                        handled = tool.onWheel(event);
+                        break;
+                    case types_1.InputEvtType.CopyEvent:
+                        handled = tool.onCopy(event);
+                        break;
+                    case types_1.InputEvtType.PasteEvent:
+                        handled = tool.onPaste(event);
+                        break;
+                    default:
+                        allCasesHandledGuard = event;
+                        return allCasesHandledGuard;
+                }
+                if (handled) {
+                    break;
+                }
+            }
+        }
+        return handled;
+    };
+    ToolController.prototype.getMatchingTools = function (type) {
+        return this.tools.filter(function (tool) { return tool instanceof type; });
+    };
+    return ToolController;
+}());
+exports.default = ToolController;

package/dist/cjs/tools/ToolEnabledGroup.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Connects a group of tools -- at most one tool in the group can be enabled.
+var ToolEnabledGroup = /** @class */ (function () {
+    function ToolEnabledGroup() {
+    }
+    ToolEnabledGroup.prototype.notifyEnabled = function (tool) {
+        var _a;
+        if (tool !== this.activeTool) {
+            (_a = this.activeTool) === null || _a === void 0 ? void 0 : _a.setEnabled(false);
+            this.activeTool = tool;
+        }
+    };
+    return ToolEnabledGroup;
+}());
+exports.default = ToolEnabledGroup;

package/dist/cjs/tools/ToolSwitcherShortcut.js

@@ -0,0 +1,54 @@
+"use strict";
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var BaseTool_1 = require("./BaseTool");
+/**
+ * Handles keyboard events used, by default, to select tools. By default,
+ * 1 maps to the first primary tool, 2 to the second primary tool, ... .
+ *
+ * This is in the default set of {@link ToolController} tools.
+ *
+ * @deprecated This may be replaced in the future.
+ */
+var ToolSwitcherShortcut = /** @class */ (function (_super) {
+    __extends(ToolSwitcherShortcut, _super);
+    function ToolSwitcherShortcut(editor) {
+        var _this = _super.call(this, editor.notifier, editor.localization.changeTool) || this;
+        _this.editor = editor;
+        return _this;
+    }
+    // @internal
+    ToolSwitcherShortcut.prototype.onKeyPress = function (_a) {
+        var key = _a.key;
+        var toolController = this.editor.toolController;
+        var primaryTools = toolController.getPrimaryTools();
+        // Map keys 0-9 to primary tools.
+        var keyMatch = /^[0-9]$/.exec(key);
+        var targetTool;
+        if (keyMatch) {
+            var targetIdx = parseInt(keyMatch[0], 10) - 1;
+            targetTool = primaryTools[targetIdx];
+        }
+        if (targetTool) {
+            targetTool.setEnabled(true);
+            return true;
+        }
+        return false;
+    };
+    return ToolSwitcherShortcut;
+}(BaseTool_1.default));
+exports.default = ToolSwitcherShortcut;

package/dist/cjs/tools/ToolbarShortcutHandler.js

@@ -0,0 +1,50 @@
+"use strict";
+// Allows the toolbar to register keyboard events.
+// @packageDocumentation
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var BaseTool_1 = require("./BaseTool");
+var ToolbarShortcutHandler = /** @class */ (function (_super) {
+    __extends(ToolbarShortcutHandler, _super);
+    function ToolbarShortcutHandler(editor) {
+        var _this = _super.call(this, editor.notifier, editor.localization.changeTool) || this;
+        _this.listeners = new Set([]);
+        return _this;
+    }
+    ToolbarShortcutHandler.prototype.registerListener = function (listener) {
+        this.listeners.add(listener);
+    };
+    ToolbarShortcutHandler.prototype.removeListener = function (listener) {
+        this.listeners.delete(listener);
+    };
+    ToolbarShortcutHandler.prototype.onKeyPress = function (event) {
+        // TypeScript seems to automatically convert for of loops into for(init;check;update)
+        // loops (even with target set to es6). Thus, we cannot iterate directly through the
+        // set here.
+        // See https://stackoverflow.com/q/48886500
+        var listeners = Array.from(this.listeners.values());
+        for (var _i = 0, listeners_1 = listeners; _i < listeners_1.length; _i++) {
+            var listener = listeners_1[_i];
+            if (listener(event)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    return ToolbarShortcutHandler;
+}(BaseTool_1.default));
+exports.default = ToolbarShortcutHandler;

package/dist/cjs/tools/UndoRedoShortcut.d.ts

@@ -0,0 +1,8 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../types';
+import BaseTool from './BaseTool';
+export default class UndoRedoShortcut extends BaseTool {
+    private editor;
+    constructor(editor: Editor);
+    onKeyPress(event: KeyPressEvent): boolean;
+}

package/dist/cjs/tools/UndoRedoShortcut.js

@@ -0,0 +1,42 @@
+"use strict";
+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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var BaseTool_1 = require("./BaseTool");
+var keybindings_1 = require("./keybindings");
+// Handles ctrl+Z, ctrl+Shift+Z keyboard shortcuts.
+var UndoRedoShortcut = /** @class */ (function (_super) {
+    __extends(UndoRedoShortcut, _super);
+    function UndoRedoShortcut(editor) {
+        var _this = _super.call(this, editor.notifier, editor.localization.undoRedoTool) || this;
+        _this.editor = editor;
+        return _this;
+    }
+    // @internal
+    UndoRedoShortcut.prototype.onKeyPress = function (event) {
+        if (this.editor.shortcuts.matchesShortcut(keybindings_1.undoKeyboardShortcutId, event)) {
+            this.editor.history.undo();
+            return true;
+        }
+        else if (this.editor.shortcuts.matchesShortcut(keybindings_1.redoKeyboardShortcutId, event)) {
+            this.editor.history.redo();
+            return true;
+        }
+        return false;
+    };
+    return UndoRedoShortcut;
+}(BaseTool_1.default));
+exports.default = UndoRedoShortcut;

package/dist/cjs/tools/UndoRedoShortcut.test.d.ts

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

package/dist/cjs/tools/keybindings.d.ts

@@ -0,0 +1,17 @@
+export declare const undoKeyboardShortcutId = "jsdraw.tools.undo";
+export declare const redoKeyboardShortcutId = "jsdaw.tools.redo";
+export declare const increaseSizeKeyboardShortcutId = "jsdraw.tools.increaseSize";
+export declare const decreaseSizeKeyboardShortcutId = "jsdraw.tools.decreaseSize";
+export declare const snapToGridKeyboardShortcutId = "jsdraw.tools.snapToGrid";
+export declare const lineLockKeyboardShortcutId = "jsdraw.tools.lockToLine";
+export declare const toggleFindVisibleShortcutId = "js-draw.tools.FindTool.toggleVisible";
+export declare const moveLeftKeyboardShortcutId = "jsdraw.tools.PanZoom.moveLeft";
+export declare const moveRightKeyboardShortcutId = "jsdraw.tools.PanZoom.moveRight";
+export declare const moveUpKeyboardShortcutId = "jsdraw.tools.PanZoom.moveUp";
+export declare const moveDownKeyboardShortcutId = "jsdraw.tools.PanZoom.moveDown";
+export declare const rotateClockwiseKeyboardShortcutId = "jsdraw.tools.PanZoom.rotateViewClockwise";
+export declare const rotateCounterClockwiseKeyboardShortcutId = "jsdraw.tools.PanZoom.rotateViewCounterClockwise";
+export declare const zoomInKeyboardShortcutId = "jsdraw.tools.PanZoom.zoomIn";
+export declare const zoomOutKeyboardShortcutId = "jsdraw.tools.PanZoom.zoomOut";
+export declare const selectAllKeyboardShortcut = "jsdraw.tools.SelectionTool.selectAll";
+export declare const duplicateSelectionShortcut = "jsdraw.tools.SelectionTool.duplicateSelection";

package/dist/cjs/tools/keybindings.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duplicateSelectionShortcut = exports.selectAllKeyboardShortcut = exports.zoomOutKeyboardShortcutId = exports.zoomInKeyboardShortcutId = exports.rotateCounterClockwiseKeyboardShortcutId = exports.rotateClockwiseKeyboardShortcutId = exports.moveDownKeyboardShortcutId = exports.moveUpKeyboardShortcutId = exports.moveRightKeyboardShortcutId = exports.moveLeftKeyboardShortcutId = exports.toggleFindVisibleShortcutId = exports.lineLockKeyboardShortcutId = exports.snapToGridKeyboardShortcutId = exports.decreaseSizeKeyboardShortcutId = exports.increaseSizeKeyboardShortcutId = exports.redoKeyboardShortcutId = exports.undoKeyboardShortcutId = void 0;
+var KeyboardShortcutManager_1 = require("../shortcuts/KeyboardShortcutManager");
+// This file contains user-overridable tool-realted keybindings.
+// Undo/redo
+exports.undoKeyboardShortcutId = 'jsdraw.tools.undo';
+exports.redoKeyboardShortcutId = 'jsdaw.tools.redo';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.undoKeyboardShortcutId, ['ctrlOrMeta+z'], 'Undo');
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.redoKeyboardShortcutId, ['ctrlOrMeta+Z', 'ctrlOrMeta+Shift+z'], 'Redo');
+// Pen/eraser/selection keybindings
+exports.increaseSizeKeyboardShortcutId = 'jsdraw.tools.increaseSize';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.increaseSizeKeyboardShortcutId, ['+', '='], 'Increase pen/eraser size');
+exports.decreaseSizeKeyboardShortcutId = 'jsdraw.tools.decreaseSize';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.decreaseSizeKeyboardShortcutId, ['-', '_'], 'Decrease pen/eraser size');
+exports.snapToGridKeyboardShortcutId = 'jsdraw.tools.snapToGrid';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.snapToGridKeyboardShortcutId, ['control', 'meta'], 'Snap to grid (press and hold)');
+exports.lineLockKeyboardShortcutId = 'jsdraw.tools.lockToLine';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.lineLockKeyboardShortcutId, ['shift'], 'Snap to XY axes (press and hold)');
+// Find tool
+exports.toggleFindVisibleShortcutId = 'js-draw.tools.FindTool.toggleVisible';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.toggleFindVisibleShortcutId, ['ctrlOrMeta+f'], 'Shows/hides the find tool');
+// Pan/zoom
+exports.moveLeftKeyboardShortcutId = 'jsdraw.tools.PanZoom.moveLeft';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.moveLeftKeyboardShortcutId, ['ArrowLeft', 'h', 'a'], 'Pan left');
+exports.moveRightKeyboardShortcutId = 'jsdraw.tools.PanZoom.moveRight';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.moveRightKeyboardShortcutId, ['ArrowRight', 'l', 'd'], 'Pan right');
+exports.moveUpKeyboardShortcutId = 'jsdraw.tools.PanZoom.moveUp';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.moveUpKeyboardShortcutId, ['ArrowUp', 'k', 'q'], 'Pan up');
+exports.moveDownKeyboardShortcutId = 'jsdraw.tools.PanZoom.moveDown';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.moveDownKeyboardShortcutId, ['ArrowDown', 'j', 'e'], 'Pan down');
+exports.rotateClockwiseKeyboardShortcutId = 'jsdraw.tools.PanZoom.rotateViewClockwise';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.rotateClockwiseKeyboardShortcutId, ['R'], 'Rotate viewport clockwise');
+exports.rotateCounterClockwiseKeyboardShortcutId = 'jsdraw.tools.PanZoom.rotateViewCounterClockwise';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.rotateCounterClockwiseKeyboardShortcutId, ['r'], 'Rotate viewport counter-clockwise');
+exports.zoomInKeyboardShortcutId = 'jsdraw.tools.PanZoom.zoomIn';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.zoomInKeyboardShortcutId, ['w'], 'Zoom in');
+exports.zoomOutKeyboardShortcutId = 'jsdraw.tools.PanZoom.zoomOut';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.zoomOutKeyboardShortcutId, ['s'], 'Zoom out');
+// Selection
+exports.selectAllKeyboardShortcut = 'jsdraw.tools.SelectionTool.selectAll';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.selectAllKeyboardShortcut, ['ctrlOrMeta+a'], 'Select all');
+exports.duplicateSelectionShortcut = 'jsdraw.tools.SelectionTool.duplicateSelection';
+KeyboardShortcutManager_1.default.registerDefaultKeyboardShortcut(exports.duplicateSelectionShortcut, ['ctrlOrMeta+d'], 'Duplicate selection');

package/dist/cjs/tools/lib.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolbarShortcutHandler = exports.SoundUITool = exports.PasteHandler = exports.EraserTool = exports.SelectAllShortcutHandler = exports.SelectionTool = exports.TextTool = exports.PenTool = exports.PanZoomMode = exports.PanZoomTool = exports.ToolSwitcherShortcut = exports.UndoRedoShortcut = exports.ToolEnabledGroup = exports.ToolController = exports.BaseTool = void 0;
+var BaseTool_1 = require("./BaseTool");
+Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return BaseTool_1.default; } });
+var ToolController_1 = require("./ToolController");
+Object.defineProperty(exports, "ToolController", { enumerable: true, get: function () { return ToolController_1.default; } });
+var ToolEnabledGroup_1 = require("./ToolEnabledGroup");
+Object.defineProperty(exports, "ToolEnabledGroup", { enumerable: true, get: function () { return ToolEnabledGroup_1.default; } });
+var UndoRedoShortcut_1 = require("./UndoRedoShortcut");
+Object.defineProperty(exports, "UndoRedoShortcut", { enumerable: true, get: function () { return UndoRedoShortcut_1.default; } });
+var ToolSwitcherShortcut_1 = require("./ToolSwitcherShortcut");
+Object.defineProperty(exports, "ToolSwitcherShortcut", { enumerable: true, get: function () { return ToolSwitcherShortcut_1.default; } });
+var PanZoom_1 = require("./PanZoom");
+Object.defineProperty(exports, "PanZoomTool", { enumerable: true, get: function () { return PanZoom_1.default; } });
+Object.defineProperty(exports, "PanZoomMode", { enumerable: true, get: function () { return PanZoom_1.PanZoomMode; } });
+var Pen_1 = require("./Pen");
+Object.defineProperty(exports, "PenTool", { enumerable: true, get: function () { return Pen_1.default; } });
+var TextTool_1 = require("./TextTool");
+Object.defineProperty(exports, "TextTool", { enumerable: true, get: function () { return TextTool_1.default; } });
+var SelectionTool_1 = require("./SelectionTool/SelectionTool");
+Object.defineProperty(exports, "SelectionTool", { enumerable: true, get: function () { return SelectionTool_1.default; } });
+var SelectAllShortcutHandler_1 = require("./SelectionTool/SelectAllShortcutHandler");
+Object.defineProperty(exports, "SelectAllShortcutHandler", { enumerable: true, get: function () { return SelectAllShortcutHandler_1.default; } });
+var Eraser_1 = require("./Eraser");
+Object.defineProperty(exports, "EraserTool", { enumerable: true, get: function () { return Eraser_1.default; } });
+var PasteHandler_1 = require("./PasteHandler");
+Object.defineProperty(exports, "PasteHandler", { enumerable: true, get: function () { return PasteHandler_1.default; } });
+var SoundUITool_1 = require("./SoundUITool");
+Object.defineProperty(exports, "SoundUITool", { enumerable: true, get: function () { return SoundUITool_1.default; } });
+var ToolbarShortcutHandler_1 = require("./ToolbarShortcutHandler");
+Object.defineProperty(exports, "ToolbarShortcutHandler", { enumerable: true, get: function () { return ToolbarShortcutHandler_1.default; } });

package/dist/cjs/tools/localization.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultToolLocalization = void 0;
+exports.defaultToolLocalization = {
+    penTool: function (penId) { return "Pen ".concat(penId); },
+    selectionTool: 'Selection',
+    selectAllTool: 'Select all shortcut',
+    eraserTool: 'Eraser',
+    touchPanTool: 'Touch panning',
+    twoFingerPanZoomTool: 'Panning and zooming',
+    undoRedoTool: 'Undo/Redo',
+    rightClickDragPanTool: 'Right-click drag',
+    pipetteTool: 'Pick color from screen',
+    keyboardPanZoom: 'Keyboard pan/zoom shortcuts',
+    textTool: 'Text',
+    enterTextToInsert: 'Text to insert',
+    changeTool: 'Change tool',
+    pasteHandler: 'Copy paste handler',
+    soundExplorer: 'Sound-based image exploration',
+    disableAccessibilityExploreTool: 'Disable sound-based exploration',
+    enableAccessibilityExploreTool: 'Enable sound-based exploration',
+    findLabel: 'Find',
+    toNextMatch: 'Next',
+    closeFindDialog: 'Close',
+    findDialogShown: 'Find dialog shown',
+    findDialogHidden: 'Find dialog hidden',
+    focusedFoundText: function (matchIdx, totalMatches) { return "Viewing match ".concat(matchIdx, " of ").concat(totalMatches); },
+    anyDevicePanning: 'Any device panning',
+    copied: function (count, description) { return "Copied ".concat(count, " ").concat(description); },
+    pasted: function (count, description) { return "Pasted ".concat(count, " ").concat(description); },
+    toolEnabledAnnouncement: function (toolName) { return "".concat(toolName, " enabled"); },
+    toolDisabledAnnouncement: function (toolName) { return "".concat(toolName, " disabled"); },
+};

package/dist/cjs/types.d.ts

@@ -0,0 +1,154 @@
+import EventDispatcher from './EventDispatcher';
+import Mat33 from './math/Mat33';
+import { Point2, Vec2 } from './math/Vec2';
+import Vec3 from './math/Vec3';
+import BaseTool from './tools/BaseTool';
+import AbstractComponent from './components/AbstractComponent';
+import Rect2 from './math/shapes/Rect2';
+import Pointer from './Pointer';
+import Color4 from './Color4';
+import Command from './commands/Command';
+import BaseWidget from './toolbar/widgets/BaseWidget';
+export type HTMLPointerEventName = 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel';
+export type HTMLPointerEventFilter = (eventName: HTMLPointerEventName, event: PointerEvent) => boolean;
+export interface PointerEvtListener {
+    onPointerDown(event: PointerEvt): boolean;
+    onPointerMove(event: PointerEvt): void;
+    onPointerUp(event: PointerEvt): void;
+    onGestureCancel(): void;
+}
+export declare enum InputEvtType {
+    PointerDownEvt = 0,
+    PointerMoveEvt = 1,
+    PointerUpEvt = 2,
+    GestureCancelEvt = 3,
+    WheelEvt = 4,
+    KeyPressEvent = 5,
+    KeyUpEvent = 6,
+    CopyEvent = 7,
+    PasteEvent = 8
+}
+export interface WheelEvt {
+    readonly kind: InputEvtType.WheelEvt;
+    readonly delta: Vec3;
+    readonly screenPos: Point2;
+}
+export interface KeyPressEvent {
+    readonly kind: InputEvtType.KeyPressEvent;
+    readonly key: string;
+    readonly ctrlKey: boolean | undefined;
+    readonly altKey: boolean | undefined;
+}
+export interface KeyUpEvent {
+    readonly kind: InputEvtType.KeyUpEvent;
+    readonly key: string;
+    readonly ctrlKey: boolean | undefined;
+    readonly altKey: boolean | undefined;
+}
+export interface CopyEvent {
+    readonly kind: InputEvtType.CopyEvent;
+    setData(mime: string, data: string): void;
+}
+export interface PasteEvent {
+    readonly kind: InputEvtType.PasteEvent;
+    readonly data: string;
+    readonly mime: string;
+}
+export interface GestureCancelEvt {
+    readonly kind: InputEvtType.GestureCancelEvt;
+}
+interface PointerEvtBase {
+    readonly current: Pointer;
+    readonly allPointers: Pointer[];
+}
+export interface PointerDownEvt extends PointerEvtBase {
+    readonly kind: InputEvtType.PointerDownEvt;
+}
+export interface PointerMoveEvt extends PointerEvtBase {
+    readonly kind: InputEvtType.PointerMoveEvt;
+}
+export interface PointerUpEvt extends PointerEvtBase {
+    readonly kind: InputEvtType.PointerUpEvt;
+}
+export type PointerEvt = PointerDownEvt | PointerMoveEvt | PointerUpEvt;
+export type InputEvt = KeyPressEvent | KeyUpEvent | WheelEvt | GestureCancelEvt | PointerEvt | CopyEvent | PasteEvent;
+export type EditorNotifier = EventDispatcher<EditorEventType, EditorEventDataType>;
+export declare enum EditorEventType {
+    ToolEnabled = 0,
+    ToolDisabled = 1,
+    ToolUpdated = 2,
+    UndoRedoStackUpdated = 3,
+    CommandDone = 4,
+    CommandUndone = 5,
+    ObjectAdded = 6,
+    ViewportChanged = 7,
+    DisplayResized = 8,
+    ColorPickerToggled = 9,
+    ColorPickerColorSelected = 10,
+    ToolbarDropdownShown = 11
+}
+export declare enum UndoEventType {
+    CommandDone = 0,
+    CommandUndone = 1,
+    CommandRedone = 2
+}
+type EditorToolEventType = EditorEventType.ToolEnabled | EditorEventType.ToolDisabled | EditorEventType.ToolUpdated;
+export interface EditorToolEvent {
+    readonly kind: EditorToolEventType;
+    readonly tool: BaseTool;
+}
+export interface EditorObjectEvent {
+    readonly kind: EditorEventType.ObjectAdded;
+    readonly object: AbstractComponent;
+}
+export interface EditorViewportChangedEvent {
+    readonly kind: EditorEventType.ViewportChanged;
+    readonly newTransform: Mat33;
+    readonly oldTransform: Mat33;
+}
+export interface DisplayResizedEvent {
+    readonly kind: EditorEventType.DisplayResized;
+    readonly newSize: Vec2;
+}
+export interface EditorUndoStackUpdated {
+    readonly kind: EditorEventType.UndoRedoStackUpdated;
+    readonly undoStackSize: number;
+    readonly redoStackSize: number;
+    readonly command?: Command;
+    readonly stackUpdateType: UndoEventType;
+}
+export interface CommandDoneEvent {
+    readonly kind: EditorEventType.CommandDone;
+    readonly command: Command;
+}
+export interface CommandUndoneEvent {
+    readonly kind: EditorEventType.CommandUndone;
+    readonly command: Command;
+}
+export interface ColorPickerToggled {
+    readonly kind: EditorEventType.ColorPickerToggled;
+    readonly open: boolean;
+}
+export interface ColorPickerColorSelected {
+    readonly kind: EditorEventType.ColorPickerColorSelected;
+    readonly color: Color4;
+}
+export interface ToolbarDropdownShownEvent {
+    readonly kind: EditorEventType.ToolbarDropdownShown;
+    readonly parentWidget: BaseWidget;
+}
+export type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | CommandDoneEvent | CommandUndoneEvent | ColorPickerToggled | ColorPickerColorSelected | ToolbarDropdownShownEvent;
+export type OnProgressListener = (amountProcessed: number, totalToProcess: number) => Promise<void> | null | void;
+export type ComponentAddedListener = (component: AbstractComponent) => Promise<void> | void;
+export type OnDetermineExportRectListener = (exportRect: Rect2) => void;
+export interface ImageLoader {
+    start(onAddComponent: ComponentAddedListener, onProgressListener: OnProgressListener, onDetermineExportRect?: OnDetermineExportRectListener): Promise<void>;
+}
+export interface StrokeDataPoint {
+    pos: Point2;
+    width: number;
+    /** Time in milliseconds (e.g. as returned by `new Date().getTime()`). */
+    time: number;
+    color: Color4;
+}
+export {};