js-draw 1.18.0 → 1.19.1

package/dist/cjs/toolbar/widgets/components/makeFileInput.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ReactiveValue_1 = __importDefault(require("../../../util/ReactiveValue"));
 let idCounter = 0;
 /**
- * Creates a stylized file input.
+ * Creates a stylized file input. This file input can either use the system file picker, or a custom
+ * one specified by `customPickerAction`.
  */
-const makeFileInput = (labelText, context, accepts = '*') => {
+const makeFileInput = (labelText, context, { accepts = '*', allowMultiSelect = false, customPickerAction } = {}) => {
     const container = document.createElement('div');
     const label = document.createElement('label');
     const input = document.createElement('input');
@@ -18,7 +19,9 @@ const makeFileInput = (labelText, context, accepts = '*') => {
     container.classList.add('toolbar--file-input-container');
     label.appendChild(document.createTextNode(labelText));
     input.accept = accepts;
-    input.type = 'file';
+    input.type = customPickerAction ? 'button' : 'file';
+    input.classList.add('file-input');
+    input.multiple = allowMultiSelect;
     // Associate the label with the input
     const inputId = `js-draw-file-input-${idCounter++}`;
     input.setAttribute('id', inputId);
@@ -29,48 +32,22 @@ const makeFileInput = (labelText, context, accepts = '*') => {
     label.appendChild(descriptionBox);
     container.replaceChildren(label, input);
     const selectedFiles = ReactiveValue_1.default.fromInitialValue([]);
-    // Support droping files
-    label.addEventListener('dragover', event => {
-        event.preventDefault();
-        label.classList.add('drag-target');
-    });
-    label.addEventListener('dragenter', event => {
-        event.preventDefault();
-        label.classList.add('drag-target');
-    });
-    label.addEventListener('dragleave', event => {
-        event.preventDefault();
-        // Ensure the event wasn't targeting a child.
-        // See https://stackoverflow.com/a/54271161 and
-        //     https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/relatedTarget
-        const enteringElement = event.relatedTarget;
-        if (!enteringElement || !label.contains(enteringElement)) {
-            label.classList.remove('drag-target');
-        }
-    });
-    // See https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/File_drag_and_drop#process_the_drop
-    label.addEventListener('drop', event => {
-        event.preventDefault();
-        label.classList.remove('drag-target');
-        const fileList = [];
-        if (event.dataTransfer) {
-            fileList.push(...event.dataTransfer.files);
-        }
-        selectedFiles.set(fileList);
-    });
-    input.addEventListener('change', () => {
-        const fileList = input.files ?? [];
-        selectedFiles.set([...fileList]);
-    });
-    selectedFiles.onUpdate(files => {
-        if (files.length === 0 && input.files && input.files.length > 0) {
-            input.value = '';
+    let loading = false;
+    let cancelLoading = null;
+    const updateStatusText = () => {
+        const files = selectedFiles.get();
+        if (loading) {
+            descriptionText.textContent = context.localization.fileInput__loading;
+            if (cancelLoading) {
+                const cancelText = document.createElement('b');
+                cancelText.textContent = context.localization.cancel;
+                cancelText.classList.add('cancel-button');
+                descriptionText.appendChild(cancelText);
+            }
+            icon.style.display = 'none';
         }
-    });
-    // Update the status text and hide/show the icon.
-    selectedFiles.onUpdateAndNow(files => {
-        if (files.length > 0) {
-            descriptionText.innerText = files.map(file => file.name).join('\n');
+        else if (files.length > 0) {
+            descriptionText.textContent = files.map(file => file.name).join('\n');
             // Only show the icon when there are files
             icon.style.display = 'none';
         }
@@ -90,7 +67,7 @@ const makeFileInput = (labelText, context, accepts = '*') => {
                 // Inside a {{pair of curly braces}}?
                 if (i % 2 === 1) {
                     const boldedText = document.createElement('b');
-                    boldedText.innerText = segments[i];
+                    boldedText.textContent = segments[i];
                     descriptionText.appendChild(boldedText);
                 }
                 else {
@@ -98,7 +75,87 @@ const makeFileInput = (labelText, context, accepts = '*') => {
                 }
             }
         }
+    };
+    const addFileEventListeners = () => {
+        // Support dropping files
+        label.addEventListener('dragover', event => {
+            event.preventDefault();
+            label.classList.add('drag-target');
+        });
+        label.addEventListener('dragenter', event => {
+            event.preventDefault();
+            label.classList.add('drag-target');
+        });
+        label.addEventListener('dragleave', event => {
+            event.preventDefault();
+            // Ensure the event wasn't targeting a child.
+            // See https://stackoverflow.com/a/54271161 and
+            //     https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/relatedTarget
+            const enteringElement = event.relatedTarget;
+            if (!enteringElement || !label.contains(enteringElement)) {
+                label.classList.remove('drag-target');
+            }
+        });
+        // See https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/File_drag_and_drop#process_the_drop
+        label.addEventListener('drop', event => {
+            event.preventDefault();
+            label.classList.remove('drag-target');
+            const fileList = [];
+            if (event.dataTransfer) {
+                fileList.push(...event.dataTransfer.files);
+            }
+            selectedFiles.set(fileList);
+        });
+        input.addEventListener('change', () => {
+            const fileList = input.files ?? [];
+            selectedFiles.set([...fileList]);
+        });
+    };
+    addFileEventListeners();
+    // Support for custom file pickers
+    if (customPickerAction) {
+        const promptForFiles = async () => {
+            if (loading) {
+                cancelLoading?.();
+                return;
+            }
+            container.classList.add('-loading');
+            loading = true;
+            updateStatusText();
+            try {
+                const data = await customPickerAction({
+                    setOnCancelCallback: (onCancel) => {
+                        if (!loading) {
+                            throw new Error('Task already completed. Can\'t register cancel handler.');
+                        }
+                        cancelLoading = () => {
+                            cancelLoading = null;
+                            updateStatusText();
+                            onCancel();
+                        };
+                        updateStatusText();
+                    },
+                });
+                if (data) {
+                    selectedFiles.set(data);
+                }
+            }
+            finally {
+                container.classList.remove('-loading');
+                loading = false;
+                updateStatusText();
+            }
+        };
+        input.onclick = promptForFiles;
+    }
+    selectedFiles.onUpdate(files => {
+        if (files.length === 0 && input.files && input.files.length > 0) {
+            input.value = '';
+        }
+        cancelLoading?.();
     });
+    // Update the status text and hide/show the icon.
+    selectedFiles.onUpdateAndNow(updateStatusText);
     return {
         container,
         input,

package/dist/cjs/toolbar/widgets/components/makeFileInput.test.d.ts

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

package/dist/cjs/toolbar/widgets/components/makeSnappedList.d.ts

@@ -0,0 +1,15 @@
+import { ReactiveValue } from '../../../util/ReactiveValue';
+export interface SnappedListItem<DataType> {
+    element: HTMLElement;
+    data: DataType;
+}
+type SnappedListItems<DataType> = Array<SnappedListItem<DataType>>;
+export interface SnappedListControl<DataType> {
+    container: HTMLElement;
+    visibleItem: ReactiveValue<DataType | null>;
+}
+/**
+ * Creates a list that snaps to each item and reports the selected item.
+ */
+declare const makeSnappedList: <DataType>(itemsValue: ReactiveValue<SnappedListItems<DataType>>) => SnappedListControl<DataType>;
+export default makeSnappedList;

package/dist/cjs/toolbar/widgets/components/makeSnappedList.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stopPropagationOfScrollingWheelEvents_1 = __importDefault(require("../../../util/stopPropagationOfScrollingWheelEvents"));
+const ReactiveValue_1 = require("../../../util/ReactiveValue");
+/**
+ * Creates a list that snaps to each item and reports the selected item.
+ */
+const makeSnappedList = (itemsValue) => {
+    const container = document.createElement('div');
+    container.classList.add('toolbar-snapped-scroll-list');
+    const visibleIndex = ReactiveValue_1.MutableReactiveValue.fromInitialValue(0);
+    let observer = null;
+    const createObserver = () => {
+        observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                if (entry.isIntersecting && entry.intersectionRatio > 0.7) {
+                    const indexString = entry.target.getAttribute('data-item-index');
+                    if (indexString === null)
+                        throw new Error('Could not find attribute data-item-index');
+                    const index = Number(indexString);
+                    visibleIndex.set(index);
+                    break;
+                }
+            }
+        }, {
+            // Element to use as the boudning box with which to intersect.
+            // See https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+            root: container,
+            // Fraction of an element that must be visible to trigger the callback:
+            threshold: 0.9,
+        });
+    };
+    const destroyObserver = () => {
+        if (observer) {
+            observer.disconnect();
+            visibleIndex.set(0);
+            observer = null;
+        }
+    };
+    const wrappedItems = ReactiveValue_1.ReactiveValue.map(itemsValue, items => {
+        return items.map((item, index) => {
+            const wrapper = document.createElement('div');
+            if (item.element.parentElement)
+                item.element.remove();
+            wrapper.appendChild(item.element);
+            wrapper.classList.add('item');
+            wrapper.setAttribute('data-item-index', `${index}`);
+            return {
+                element: wrapper,
+                data: item.data,
+            };
+        });
+    });
+    const lastItems = [];
+    wrappedItems.onUpdateAndNow(items => {
+        visibleIndex.set(-1);
+        for (const item of lastItems) {
+            observer?.unobserve(item.element);
+        }
+        container.replaceChildren();
+        // An observer is only necessary if there are multiple items to scroll through.
+        if (items.length > 1) {
+            createObserver();
+        }
+        else {
+            destroyObserver();
+        }
+        // Different styling is applied when empty
+        if (items.length === 0) {
+            container.classList.add('-empty');
+        }
+        else {
+            container.classList.remove('-empty');
+        }
+        for (const item of items) {
+            container.appendChild(item.element);
+        }
+        visibleIndex.set(0);
+        if (observer) {
+            for (const item of items) {
+                observer.observe(item.element);
+            }
+        }
+    });
+    const visibleItem = ReactiveValue_1.ReactiveValue.map(visibleIndex, index => {
+        const values = itemsValue.get();
+        if (0 <= index && index < values.length) {
+            return values[index].data;
+        }
+        return null;
+    });
+    // makeSnappedList is generally shown within the toolbar. This allows users to
+    // scroll it with a touchpad.
+    (0, stopPropagationOfScrollingWheelEvents_1.default)(container);
+    return {
+        container,
+        visibleItem,
+    };
+};
+exports.default = makeSnappedList;

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

@@ -1,4 +1,4 @@
-import { KeyPressEvent, PointerEvt } from '../inputEvents';
+import { GestureCancelEvt, KeyPressEvent, PointerEvt } from '../inputEvents';
 import BaseTool from './BaseTool';
 import Editor from '../Editor';
 import { MutableReactiveValue } from '../util/ReactiveValue';
@@ -22,6 +22,11 @@ export default class Eraser extends BaseTool {
     private eraseCommands;
     private addCommands;
     constructor(editor: Editor, description: string, options?: InitialEraserOptions);
+    /**
+     * @returns a tool that briefly enables the eraser when a physical eraser is used.
+     * This tool should be added to the tool list after the primary tools.
+     */
+    makeEraserSwitcherTool(): BaseTool;
     private clearPreview;
     private getSizeOnCanvas;
     private drawPreviewAt;
@@ -36,7 +41,7 @@ export default class Eraser extends BaseTool {
     onPointerDown(event: PointerEvt): boolean;
     onPointerMove(event: PointerEvt): void;
     onPointerUp(event: PointerEvt): void;
-    onGestureCancel(): void;
+    onGestureCancel(_event: GestureCancelEvt): void;
     onKeyPress(event: KeyPressEvent): boolean;
     /** Returns the side-length of the tip of this eraser. */
     getThickness(): number;

package/dist/cjs/tools/Eraser.js

@@ -19,6 +19,52 @@ var EraserMode;
     EraserMode["PartialStroke"] = "partial-stroke";
     EraserMode["FullStroke"] = "full-stroke";
 })(EraserMode || (exports.EraserMode = EraserMode = {}));
+/** Handles switching from other primary tools to the eraser and back */
+class EraserSwitcher extends BaseTool_1.default {
+    constructor(editor, eraser) {
+        super(editor.notifier, editor.localization.changeTool);
+        this.editor = editor;
+        this.eraser = eraser;
+    }
+    onPointerDown(event) {
+        if (event.allPointers.length === 1 && event.current.device === Pointer_1.PointerDevice.Eraser) {
+            const toolController = this.editor.toolController;
+            const enabledPrimaryTools = toolController.getPrimaryTools().filter(tool => tool.isEnabled());
+            if (enabledPrimaryTools.length) {
+                this.previousEnabledTool = enabledPrimaryTools[0];
+            }
+            else {
+                this.previousEnabledTool = null;
+            }
+            this.previousEraserEnabledState = this.eraser.isEnabled();
+            this.eraser.setEnabled(true);
+            if (this.eraser.onPointerDown(event)) {
+                return true;
+            }
+            else {
+                this.restoreOriginalTool();
+            }
+        }
+        return false;
+    }
+    onPointerMove(event) {
+        this.eraser.onPointerMove(event);
+    }
+    restoreOriginalTool() {
+        this.eraser.setEnabled(this.previousEraserEnabledState);
+        if (this.previousEnabledTool) {
+            this.previousEnabledTool.setEnabled(true);
+        }
+    }
+    onPointerUp(event) {
+        this.eraser.onPointerUp(event);
+        this.restoreOriginalTool();
+    }
+    onGestureCancel(event) {
+        this.eraser.onGestureCancel(event);
+        this.restoreOriginalTool();
+    }
+}
 class Eraser extends BaseTool_1.default {
     constructor(editor, description, options) {
         super(editor.notifier, description);
@@ -45,6 +91,13 @@ class Eraser extends BaseTool_1.default {
             });
         });
     }
+    /**
+     * @returns a tool that briefly enables the eraser when a physical eraser is used.
+     * This tool should be added to the tool list after the primary tools.
+     */
+    makeEraserSwitcherTool() {
+        return new EraserSwitcher(this.editor, this);
+    }
     clearPreview() {
         this.editor.clearWetInk();
     }
@@ -180,7 +233,7 @@ class Eraser extends BaseTool_1.default {
         }
         this.clearPreview();
     }
-    onGestureCancel() {
+    onGestureCancel(_event) {
         this.addCommands.forEach(cmd => cmd.unapply(this.editor));
         this.eraseCommands.forEach(cmd => cmd.unapply(this.editor));
         this.eraseCommands = [];

package/dist/cjs/tools/SelectionTool/Selection.d.ts

@@ -10,7 +10,7 @@ import AbstractComponent from '../../components/AbstractComponent';
 import Command from '../../commands/Command';
 export default class Selection {
     private editor;
-    private handles;
+    private childwidgets;
     private originalRegion;
     private selectionTightBoundingBox;
     private transformers;
@@ -52,7 +52,7 @@ export default class Selection {
     private removedFromImage;
     private addRemoveSelectionFromImage;
     private removeDeletedElemsFromSelection;
-    private targetHandle;
+    private activeHandle;
     private backgroundDragging;
     onDragStart(pointer: Pointer): boolean;
     onDragUpdate(pointer: Pointer): void;

package/dist/cjs/tools/SelectionTool/Selection.js

@@ -57,7 +57,7 @@ class Selection {
         this.hasParent = true;
         // Maps IDs to whether we removed the component from the image
         this.removedFromImage = {};
-        this.targetHandle = null;
+        this.activeHandle = null;
         this.backgroundDragging = false;
         this.selectionDuplicatedAnimationTimeout = null;
         this.originalRegion = new math_1.Rect2(startPoint.x, startPoint.y, 0, 0);
@@ -99,14 +99,14 @@ class Selection {
             side: math_1.Vec2.of(0.5, 0),
             icon: this.editor.icons.makeRotateIcon(),
         }, this, this.editor.viewport, (startPoint) => this.transformers.rotate.onDragStart(startPoint), (currentPoint) => this.transformers.rotate.onDragUpdate(currentPoint), () => this.transformers.rotate.onDragEnd());
-        this.handles = [
+        this.childwidgets = [
             resizeBothHandle,
             ...resizeHorizontalHandles,
             resizeVerticalHandle,
             rotationHandle,
         ];
-        for (const handle of this.handles) {
-            handle.addTo(this.backgroundElem);
+        for (const widget of this.childwidgets) {
+            widget.addTo(this.backgroundElem);
         }
         this.updateUI();
     }
@@ -321,8 +321,8 @@ class Selection {
         else {
             this.innerContainer.classList.remove('-empty');
         }
-        for (const handle of this.handles) {
-            handle.updatePosition();
+        for (const widget of this.childwidgets) {
+            widget.updatePosition(this.getScreenRegion());
         }
     }
     // Add/remove the contents of this seleciton from the editor.
@@ -376,16 +376,16 @@ class Selection {
     onDragStart(pointer) {
         // Clear the HTML selection (prevent HTML drag and drop being triggered by this drag)
         document.getSelection()?.removeAllRanges();
-        this.targetHandle = null;
+        this.activeHandle = null;
         let result = false;
         this.backgroundDragging = false;
         if (this.region.containsPoint(pointer.canvasPos)) {
             this.backgroundDragging = true;
             result = true;
         }
-        for (const handle of this.handles) {
-            if (handle.containsPoint(pointer.canvasPos)) {
-                this.targetHandle = handle;
+        for (const widget of this.childwidgets) {
+            if (widget.containsPoint(pointer.canvasPos)) {
+                this.activeHandle = widget;
                 this.backgroundDragging = false;
                 result = true;
             }
@@ -394,8 +394,8 @@ class Selection {
             this.removeDeletedElemsFromSelection();
             this.addRemoveSelectionFromImage(false);
         }
-        if (this.targetHandle) {
-            this.targetHandle.handleDragStart(pointer);
+        if (this.activeHandle) {
+            this.activeHandle.handleDragStart(pointer);
         }
         if (this.backgroundDragging) {
             this.transformers.drag.onDragStart(pointer.canvasPos);
@@ -406,25 +406,25 @@ class Selection {
         if (this.backgroundDragging) {
             this.transformers.drag.onDragUpdate(pointer.canvasPos);
         }
-        if (this.targetHandle) {
-            this.targetHandle.handleDragUpdate(pointer);
+        if (this.activeHandle) {
+            this.activeHandle.handleDragUpdate(pointer);
         }
     }
     onDragEnd() {
         if (this.backgroundDragging) {
             this.transformers.drag.onDragEnd();
         }
-        else if (this.targetHandle) {
-            this.targetHandle.handleDragEnd();
+        else if (this.activeHandle) {
+            this.activeHandle.handleDragEnd();
         }
         this.addRemoveSelectionFromImage(true);
         this.backgroundDragging = false;
-        this.targetHandle = null;
+        this.activeHandle = null;
         this.updateUI();
     }
     onDragCancel() {
         this.backgroundDragging = false;
-        this.targetHandle = null;
+        this.activeHandle = null;
         this.setTransform(math_1.Mat33.identity);
         this.addRemoveSelectionFromImage(true);
         this.updateUI();
@@ -452,7 +452,7 @@ class Selection {
         return false;
     }
     deleteSelectedObjects() {
-        if (this.backgroundDragging || this.targetHandle) {
+        if (this.backgroundDragging || this.activeHandle) {
             this.onDragEnd();
         }
         return new Erase_1.default(this.selectedElems);
@@ -469,7 +469,7 @@ class Selection {
         }, animationDuration);
     }
     async duplicateSelectedObjects() {
-        const wasTransforming = this.backgroundDragging || this.targetHandle;
+        const wasTransforming = this.backgroundDragging || this.activeHandle;
         let tmpApplyCommand = null;
         if (!wasTransforming) {
             this.runSelectionDuplicatedAnimation();

package/dist/cjs/tools/SelectionTool/SelectionHandle.d.ts

@@ -2,6 +2,7 @@ import { Point2, Vec2 } from '@js-draw/math';
 import Selection from './Selection';
 import Pointer from '../../Pointer';
 import Viewport from '../../Viewport';
+import { SelectionBoxChild } from './types';
 export declare enum HandleAction {
     ResizeXY = "resize-xy",
     Rotate = "rotate",
@@ -17,7 +18,7 @@ export declare const handleSize = 30;
 export type DragStartCallback = (startPoint: Point2) => void;
 export type DragUpdateCallback = (canvasPoint: Point2) => void;
 export type DragEndCallback = () => Promise<void> | void;
-export default class SelectionHandle {
+export default class SelectionHandle implements SelectionBoxChild {
     readonly presentation: HandlePresentation;
     private readonly parent;
     private readonly viewport;
@@ -34,6 +35,11 @@ export default class SelectionHandle {
      * element visible on the screen.
      */
     addTo(container: HTMLElement): void;
+    /**
+     * Removes this element from its container. Should only be called
+     * after {@link addTo}.
+     */
+    remove(): void;
     /**
      * Returns this handle's bounding box relative to the top left of the
      * selection box.
@@ -48,7 +54,7 @@ export default class SelectionHandle {
     /** @returns true iff `point` (in editor **canvas** coordinates) is in this. */
     containsPoint(point: Point2): boolean;
     private dragLastPos;
-    handleDragStart(pointer: Pointer): void;
+    handleDragStart(pointer: Pointer): boolean;
     handleDragUpdate(pointer: Pointer): void;
     handleDragEnd(): void | Promise<void>;
     setSnapToGrid(snap: boolean): void;

package/dist/cjs/tools/SelectionTool/SelectionHandle.js

@@ -64,6 +64,11 @@ class SelectionHandle {
     addTo(container) {
         container.appendChild(this.element);
     }
+    /**
+     * Removes this element from its container. Should only be called
+     * after {@link addTo}.
+     */
+    remove() { this.element.remove(); }
     /**
      * Returns this handle's bounding box relative to the top left of the
      * selection box.
@@ -112,6 +117,7 @@ class SelectionHandle {
     handleDragStart(pointer) {
         this.onDragStart(pointer.canvasPos);
         this.dragLastPos = pointer.canvasPos;
+        return true;
     }
     handleDragUpdate(pointer) {
         if (!this.dragLastPos) {

package/dist/cjs/tools/SelectionTool/SelectionTool.js

@@ -404,7 +404,7 @@ class SelectionTool extends BaseTool_1.default {
                     resolve(blob);
                 }
                 else {
-                    reject('Failed to convert canvas to blob.');
+                    reject(new Error('Failed to convert canvas to blob.'));
                 }
             }, 'image/png');
         }));

package/dist/cjs/tools/SelectionTool/types.d.ts

@@ -1,3 +1,5 @@
+import type { Rect2, Point2 } from '@js-draw/math';
+import Pointer from '../../Pointer';
 export declare enum ResizeMode {
     Both = 0,
     HorizontalOnly = 1,
@@ -7,3 +9,20 @@ export declare enum TransformMode {
     Snap = 0,
     NoSnap = 1
 }
+/**
+ * Represents a child of the selection that should move with the selection
+ * and handle events.
+ *
+ * Although selection children should be `HTMLElement`s, the selection may be
+ * hidden behind an invisible element. As such, these elements should handle
+ * drag start/update/end events.
+ */
+export interface SelectionBoxChild {
+    updatePosition(selectionScreenBBox: Rect2): void;
+    containsPoint(point: Point2): boolean;
+    addTo(container: HTMLElement): void;
+    remove(): void;
+    handleDragStart(pointer: Pointer): boolean;
+    handleDragUpdate(pointer: Pointer): void;
+    handleDragEnd(): void;
+}

package/dist/cjs/tools/TextTool.js

@@ -23,9 +23,10 @@ class TextTool extends BaseTool_1.default {
         this.textMeasuringCtx = null;
         this.textScale = math_1.Vec2.of(1, 1);
         this.removeExistingCommand = null;
+        const editorFonts = editor.getCurrentSettings().text?.fonts ?? [];
         this.textStyleValue = ReactiveValue_1.ReactiveValue.fromInitialValue({
             size: 32,
-            fontFamily: 'sans-serif',
+            fontFamily: editorFonts.length > 0 ? editorFonts[0] : 'sans-serif',
             renderingStyle: {
                 fill: math_1.Color4.purple,
             },

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

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

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

@@ -55,6 +55,8 @@ export default class ToolController implements InputEventListener {
     insertToolsAfter(insertAfter: BaseTool, toolsToInsert: BaseTool[]): void;
     /** @see {@link insertToolsAfter} */
     insertToolsBefore(insertBefore: BaseTool, toolsToInsert: BaseTool[]): void;
+    /** @internal */
+    changeActiveToolTo(tool: BaseTool): void;
     private onEventInternal;
     /** Alias for {@link dispatchInputEvent}. */
     onEvent(event: InputEvt): boolean;