js-draw 0.25.1 → 1.0.1

package/dist/cjs/testing/sendPenEvent.js

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

package/dist/cjs/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.
  *

package/dist/cjs/testing/sendTouchEvent.js

@@ -1,17 +1,34 @@
 "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];
-        }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Pointer_1 = require("../Pointer");
-var types_1 = require("../types");
-var getUniquePointerId_1 = require("./getUniquePointerId");
+const Pointer_1 = __importStar(require("../Pointer"));
+const inputEvents_1 = require("../inputEvents");
+const getUniquePointerId_1 = __importDefault(require("./getUniquePointerId"));
 /**
  * Dispatch a touch event to the currently selected tool. Intended for unit tests.
  *
@@ -48,17 +65,18 @@ var getUniquePointerId_1 = require("./getUniquePointerId");
  * }
  * ```
  */
-var sendTouchEvent = function (editor, eventType, screenPos, allOtherPointers) {
-    var canvasPos = editor.viewport.screenToCanvas(screenPos);
+const sendTouchEvent = (editor, eventType, screenPos, allOtherPointers) => {
+    const canvasPos = editor.viewport.screenToCanvas(screenPos);
     // Get a unique ID for the main pointer
     // (try to use id=0, but don't use it if it's already in use).
-    var ptrId = (0, getUniquePointerId_1.default)(allOtherPointers !== null && allOtherPointers !== void 0 ? allOtherPointers : []);
-    var mainPointer = Pointer_1.default.ofCanvasPoint(canvasPos, eventType !== types_1.InputEvtType.PointerUpEvt, editor.viewport, ptrId, Pointer_1.PointerDevice.Touch);
+    const ptrId = (0, getUniquePointerId_1.default)(allOtherPointers ?? []);
+    const mainPointer = Pointer_1.default.ofCanvasPoint(canvasPos, eventType !== inputEvents_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), [
+        allPointers: [
+            ...(allOtherPointers ?? []),
             mainPointer,
-        ], false),
+        ],
         current: mainPointer,
     });
     return mainPointer;

package/dist/cjs/toolbar/AbstractToolbar.d.ts

@@ -0,0 +1,166 @@
+import Editor from '../Editor';
+import { ToolbarLocalization } from './localization';
+import { ActionButtonIcon } from './types';
+import BaseWidget, { ToolbarWidgetTag } from './widgets/BaseWidget';
+import { DispatcherEventListener } from '../EventDispatcher';
+export interface SpacerOptions {
+    grow: number;
+    minSize: string;
+    maxSize: string;
+}
+export default abstract class AbstractToolbar {
+    #private;
+    protected editor: Editor;
+    protected localizationTable: ToolbarLocalization;
+    private static colorisStarted;
+    /** @internal */
+    constructor(editor: Editor, localizationTable?: ToolbarLocalization);
+    private closeColorPickerOverlay;
+    private setupCloseColorPickerOverlay;
+    setupColorPickers(): void;
+    protected closeColorPickers(): void;
+    protected getWidgetUniqueId(widget: BaseWidget): string;
+    protected getWidgetFromId(id: string): BaseWidget | undefined;
+    /** Do **not** modify the return value. */
+    protected getAllWidgets(): Array<BaseWidget>;
+    /**
+     * Adds a spacer.
+     *
+     * **Toolbars can choose to ignore calls to `addSpacer`**.
+     *
+     * @example
+     * Adding a save button that moves to the very right edge of the toolbar
+     * while keeping the other buttons centered:
+     * ```ts
+     * const toolbar = editor.addToolbar(false);
+     *
+     * toolbar.addSpacer({ grow: 1 });
+     * toolbar.addDefaults();
+     * toolbar.addSpacer({ grow: 1 });
+     *
+     * toolbar.addActionButton({
+     * 	label: 'Save',
+     * 	icon: editor.icons.makeSaveIcon(),
+     * }, () => {
+     * 	  saveCallback();
+     * });
+     * ```
+     */
+    abstract addSpacer(options?: Partial<SpacerOptions>): void;
+    /**
+     * Adds an `ActionButtonWidget` or `BaseToolWidget`. The widget should not have already have a parent
+     * (i.e. its `addTo` method should not have been called).
+     *
+     * @example
+     * ```ts
+     * const toolbar = editor.addToolbar();
+     * const insertImageWidget = new InsertImageWidget(editor);
+     * toolbar.addWidget(insertImageWidget);
+     * ```
+     */
+    addWidget(widget: BaseWidget): void;
+    /** Called by `addWidget`. Implement this to add a new widget to the toolbar. */
+    protected abstract addWidgetInternal(widget: BaseWidget): void;
+    /** Removes the given `widget` from this toolbar. */
+    removeWidget(widget: BaseWidget): void;
+    /** Called by `removeWidget`. Implement this to remove a new widget from the toolbar. */
+    protected abstract removeWidgetInternal(widget: BaseWidget): void;
+    private static rootToolbarId;
+    /** Returns a snapshot of the state of widgets in the toolbar. */
+    serializeState(): string;
+    /**
+     * Deserialize toolbar widgets from the given state.
+     * Assumes that toolbar widgets are in the same order as when state was serialized.
+     */
+    deserializeState(state: string): void;
+    /**
+     * Called by `serializeState` to attach any additional JSONifyable data
+     * to the serialized result.
+     *
+     * @reutrns an object that can be converted to JSON with `JSON.stringify`.
+     */
+    protected serializeInternal(): any;
+    /**
+     * Called by `deserializeState` with a version of the JSON outputted
+     * previously by `serializeInternal`.
+     */
+    protected deserializeInternal(_json: any): void;
+    /**
+     * Creates, but does not add, an action button to this container.
+     *
+     * @see
+     * {@link addActionButton}
+     */
+    protected makeActionButton(title: string | ActionButtonIcon, command: () => void, mustBeToplevel?: boolean): BaseWidget;
+    /**
+     * Adds an action button with `title` to this toolbar (or to the given `parent` element).
+     *
+     * @return The added button.
+     */
+    addActionButton(title: string | ActionButtonIcon, command: () => void, mustBeToplevel?: boolean): BaseWidget;
+    /**
+     * Like {@link addActionButton}, except associates `tags` with the button that allow
+     * different toolbar styles to give the button tag-dependent styles.
+     */
+    addTaggedActionButton(tags: (ToolbarWidgetTag | string)[], title: string | ActionButtonIcon, command: () => void, mustBeToplevel?: boolean): BaseWidget;
+    /**
+     * Adds a save button that, when clicked, calls `saveCallback`.
+     *
+     * **Note**: This is equivalent to
+     * ```ts
+     * const tags = [
+     *   ToolbarWidgetTag.Save,
+     * ];
+     * toolbar.addTaggedActionButton(tags, {
+     *   label: editor.localization.save,
+     *   icon: editor.icons.makeSaveIcon(),
+     * }, () => {
+     *   saveCallback();
+     * });
+     * ```
+     *
+     * @final
+     */
+    addSaveButton(saveCallback: () => void): BaseWidget;
+    /**
+     * Adds an "Exit" button that, when clicked, calls `exitCallback`.
+     *
+     * **Note**: This is equivalent to
+     * ```ts
+     * toolbar.addTaggedActionButton([ ToolbarWidgetTag.Exit ], {
+     *   label: this.editor.localization.exit,
+     *   icon: this.editor.icons.makeCloseIcon(),
+     * }, () => {
+     *   exitCallback();
+     * });
+     * ```
+     *
+     * @final
+     */
+    addExitButton(exitCallback: () => void): BaseWidget;
+    /**
+     * Adds undo and redo buttons that trigger the editor's built-in undo and redo
+     * functionality.
+     */
+    addUndoRedoButtons(undoFirst?: boolean): void;
+    /**
+     * Adds toolbar widgets based on the enabled tools.
+     */
+    addDefaultToolWidgets(): void;
+    addDefaultActionButtons(): void;
+    /**
+     * Adds both the default tool widgets and action buttons.
+     */
+    abstract addDefaults(): void;
+    /** Remove this toolbar from its container and clean up listeners. */
+    remove(): void;
+    /**
+     * Removes `listener` when {@link remove} is called.
+     */
+    protected manageListener(listener: DispatcherEventListener): void;
+    /**
+     * Internal logic for {@link remove}. Implementers should remove the toolbar
+     * from its container.
+     */
+    protected abstract onRemove(): void;
+}