js-draw 1.21.2 → 1.22.0

package/dist/cjs/tools/Eraser.js

@@ -0,0 +1,304 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EraserMode = void 0;
+const types_1 = require("../types");
+const BaseTool_1 = __importDefault(require("./BaseTool"));
+const math_1 = require("@js-draw/math");
+const Erase_1 = __importDefault(require("../commands/Erase"));
+const Pointer_1 = require("../Pointer");
+const keybindings_1 = require("./keybindings");
+const ReactiveValue_1 = require("../util/ReactiveValue");
+const EditorImage_1 = __importDefault(require("../image/EditorImage"));
+const uniteCommands_1 = __importDefault(require("../commands/uniteCommands"));
+const RenderablePathSpec_1 = require("../rendering/RenderablePathSpec");
+var EraserMode;
+(function (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();
+    }
+}
+/**
+ * A tool that allows a user to erase parts of an image.
+ */
+class Eraser extends BaseTool_1.default {
+    constructor(editor, description, options) {
+        super(editor.notifier, description);
+        this.editor = editor;
+        this.lastPoint = null;
+        this.isFirstEraseEvt = true;
+        this.toAdd = new Set();
+        // Commands that each remove one element
+        this.eraseCommands = [];
+        this.addCommands = [];
+        this.thickness = options?.thickness ?? 10;
+        this.thicknessValue = ReactiveValue_1.ReactiveValue.fromInitialValue(this.thickness);
+        this.thicknessValue.onUpdate((value) => {
+            this.thickness = value;
+            this.editor.notifier.dispatch(types_1.EditorEventType.ToolUpdated, {
+                kind: types_1.EditorEventType.ToolUpdated,
+                tool: this,
+            });
+        });
+        this.modeValue = ReactiveValue_1.ReactiveValue.fromInitialValue(options?.mode ?? EraserMode.FullStroke);
+        this.modeValue.onUpdate((_value) => {
+            this.editor.notifier.dispatch(types_1.EditorEventType.ToolUpdated, {
+                kind: types_1.EditorEventType.ToolUpdated,
+                tool: this,
+            });
+        });
+    }
+    /**
+     * @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();
+    }
+    getSizeOnCanvas() {
+        return this.thickness / this.editor.viewport.getScaleFactor();
+    }
+    drawPreviewAt(point) {
+        this.clearPreview();
+        const size = this.getSizeOnCanvas();
+        const renderer = this.editor.display.getWetInkRenderer();
+        const rect = this.getEraserRect(point);
+        const rect2 = this.getEraserRect(this.lastPoint ?? point);
+        const fill = {
+            fill: math_1.Color4.transparent,
+            stroke: { width: size / 10, color: math_1.Color4.gray },
+        };
+        renderer.drawPath((0, RenderablePathSpec_1.pathToRenderable)(math_1.Path.fromConvexHullOf([...rect.corners, ...rect2.corners]), fill));
+    }
+    /**
+     * @returns the eraser rectangle in canvas coordinates.
+     *
+     * For now, all erasers are rectangles or points.
+     */
+    getEraserRect(centerPoint) {
+        const size = this.getSizeOnCanvas();
+        const halfSize = math_1.Vec2.of(size / 2, size / 2);
+        return math_1.Rect2.fromCorners(centerPoint.minus(halfSize), centerPoint.plus(halfSize));
+    }
+    /** Erases in a line from the last point to the current. */
+    eraseTo(currentPoint) {
+        if (!this.isFirstEraseEvt && currentPoint.distanceTo(this.lastPoint) === 0) {
+            return;
+        }
+        this.isFirstEraseEvt = false;
+        // Currently only objects within eraserRect or that intersect a straight line
+        // from the center of the current rect to the previous are erased. TODO: Erase
+        // all objects as if there were pointerMove events between the two points.
+        const eraserRect = this.getEraserRect(currentPoint);
+        const line = new math_1.LineSegment2(this.lastPoint, currentPoint);
+        const region = math_1.Rect2.union(line.bbox, eraserRect);
+        const intersectingElems = this.editor.image
+            .getElementsIntersectingRegion(region)
+            .filter((component) => {
+            return component.intersects(line) || component.intersectsRect(eraserRect);
+        });
+        // Only erase components that could be selected (and thus interacted with)
+        // by the user.
+        const eraseableElems = intersectingElems.filter((elem) => elem.isSelectable());
+        if (this.modeValue.get() === EraserMode.FullStroke) {
+            // Remove any intersecting elements.
+            this.toRemove.push(...eraseableElems);
+            // Create new Erase commands for the now-to-be-erased elements and apply them.
+            const newPartialCommands = eraseableElems.map((elem) => new Erase_1.default([elem]));
+            newPartialCommands.forEach((cmd) => cmd.apply(this.editor));
+            this.eraseCommands.push(...newPartialCommands);
+        }
+        else {
+            const toErase = [];
+            const toAdd = [];
+            for (const targetElem of eraseableElems) {
+                toErase.push(targetElem);
+                // Completely delete items that can't be divided.
+                if (!targetElem.withRegionErased) {
+                    continue;
+                }
+                // Completely delete items that are completely or almost completely
+                // contained within the eraser.
+                const grownRect = eraserRect.grownBy(eraserRect.maxDimension / 3);
+                if (grownRect.containsRect(targetElem.getExactBBox())) {
+                    continue;
+                }
+                // Join the current and previous rectangles so that points between events are also
+                // erased.
+                const erasePath = math_1.Path.fromConvexHullOf([
+                    ...eraserRect.corners,
+                    ...this.getEraserRect(this.lastPoint ?? currentPoint).corners,
+                ].map((p) => this.editor.viewport.roundPoint(p)));
+                toAdd.push(...targetElem.withRegionErased(erasePath, this.editor.viewport));
+            }
+            const eraseCommand = new Erase_1.default(toErase);
+            const newAddCommands = toAdd.map((elem) => EditorImage_1.default.addElement(elem));
+            eraseCommand.apply(this.editor);
+            newAddCommands.forEach((command) => command.apply(this.editor));
+            const finalToErase = [];
+            for (const item of toErase) {
+                if (this.toAdd.has(item)) {
+                    this.toAdd.delete(item);
+                }
+                else {
+                    finalToErase.push(item);
+                }
+            }
+            this.toRemove.push(...finalToErase);
+            for (const item of toAdd) {
+                this.toAdd.add(item);
+            }
+            this.eraseCommands.push(new Erase_1.default(finalToErase));
+            this.addCommands.push(...newAddCommands);
+        }
+        this.drawPreviewAt(currentPoint);
+        this.lastPoint = currentPoint;
+    }
+    onPointerDown(event) {
+        if (event.allPointers.length === 1 || event.current.device === Pointer_1.PointerDevice.Eraser) {
+            this.lastPoint = event.current.canvasPos;
+            this.toRemove = [];
+            this.toAdd.clear();
+            this.isFirstEraseEvt = true;
+            this.drawPreviewAt(event.current.canvasPos);
+            return true;
+        }
+        return false;
+    }
+    onPointerMove(event) {
+        const currentPoint = event.current.canvasPos;
+        this.eraseTo(currentPoint);
+    }
+    onPointerUp(event) {
+        this.eraseTo(event.current.canvasPos);
+        const commands = [];
+        if (this.addCommands.length > 0) {
+            this.addCommands.forEach((cmd) => cmd.unapply(this.editor));
+            // Remove items from toAdd that are also present in toRemove -- adding, then
+            // removing these does nothing, and can break undo/redo.
+            for (const item of this.toAdd) {
+                if (this.toRemove.includes(item)) {
+                    this.toAdd.delete(item);
+                    this.toRemove = this.toRemove.filter((other) => other !== item);
+                }
+            }
+            for (const item of this.toRemove) {
+                if (this.toAdd.has(item)) {
+                    this.toAdd.delete(item);
+                    this.toRemove = this.toRemove.filter((other) => other !== item);
+                }
+            }
+            commands.push(...[...this.toAdd].map((a) => EditorImage_1.default.addElement(a)));
+            this.addCommands = [];
+        }
+        if (this.eraseCommands.length > 0) {
+            // Undo commands for each individual component and unite into a single command.
+            this.eraseCommands.forEach((cmd) => cmd.unapply(this.editor));
+            this.eraseCommands = [];
+            const command = new Erase_1.default(this.toRemove);
+            commands.push(command);
+        }
+        if (commands.length === 1) {
+            this.editor.dispatch(commands[0]); // dispatch: Makes undo-able.
+        }
+        else {
+            this.editor.dispatch((0, uniteCommands_1.default)(commands));
+        }
+        this.clearPreview();
+    }
+    onGestureCancel(_event) {
+        this.addCommands.forEach((cmd) => cmd.unapply(this.editor));
+        this.eraseCommands.forEach((cmd) => cmd.unapply(this.editor));
+        this.eraseCommands = [];
+        this.addCommands = [];
+        this.clearPreview();
+    }
+    onKeyPress(event) {
+        const shortcuts = this.editor.shortcuts;
+        let newThickness;
+        if (shortcuts.matchesShortcut(keybindings_1.decreaseSizeKeyboardShortcutId, event)) {
+            newThickness = (this.getThickness() * 2) / 3;
+        }
+        else if (shortcuts.matchesShortcut(keybindings_1.increaseSizeKeyboardShortcutId, event)) {
+            newThickness = (this.getThickness() * 3) / 2;
+        }
+        if (newThickness !== undefined) {
+            newThickness = Math.min(Math.max(1, newThickness), 200);
+            this.setThickness(newThickness);
+            return true;
+        }
+        return false;
+    }
+    /** Returns the side-length of the tip of this eraser. */
+    getThickness() {
+        return this.thickness;
+    }
+    /** Sets the side-length of this' tip. */
+    setThickness(thickness) {
+        this.thicknessValue.set(thickness);
+    }
+    /**
+     * Returns a {@link MutableReactiveValue} that can be used to watch
+     * this tool's thickness.
+     */
+    getThicknessValue() {
+        return this.thicknessValue;
+    }
+    /** @returns An object that allows switching between a full stroke and a partial stroke eraser. */
+    getModeValue() {
+        return this.modeValue;
+    }
+}
+exports.default = Eraser;

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

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

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

@@ -0,0 +1,21 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../inputEvents';
+import BaseTool from './BaseTool';
+export default class FindTool extends BaseTool {
+    private editor;
+    private overlay;
+    private searchInput;
+    private currentMatchIdx;
+    constructor(editor: Editor);
+    canReceiveInputInReadOnlyEditor(): boolean;
+    private getMatches;
+    private focusCurrentMatch;
+    private toNextMatch;
+    private toPrevMatch;
+    private fillOverlay;
+    private isVisible;
+    private setVisible;
+    private toggleVisible;
+    onKeyPress(event: KeyPressEvent): boolean;
+    setEnabled(enabled: boolean): void;
+}

package/dist/cjs/tools/FindTool.js

@@ -0,0 +1,137 @@
+"use strict";
+// Displays a find dialog that allows the user to search for and focus text.
+//
+// @packageDocumentation
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TextComponent_1 = __importDefault(require("../components/TextComponent"));
+const ImageComponent_1 = __importDefault(require("../components/ImageComponent"));
+const BaseTool_1 = __importDefault(require("./BaseTool"));
+const keybindings_1 = require("./keybindings");
+const cssPrefix = 'find-tool';
+class FindTool extends BaseTool_1.default {
+    constructor(editor) {
+        super(editor.notifier, editor.localization.findLabel);
+        this.editor = editor;
+        this.currentMatchIdx = 0;
+        this.overlay = document.createElement('div');
+        this.fillOverlay();
+        editor.createHTMLOverlay(this.overlay);
+        this.overlay.style.display = 'none';
+        this.overlay.classList.add(`${cssPrefix}-overlay`);
+    }
+    canReceiveInputInReadOnlyEditor() {
+        return true;
+    }
+    getMatches(searchFor) {
+        const lowerSearchFor = searchFor.toLocaleLowerCase();
+        const matchingComponents = this.editor.image.getAllElements().filter((component) => {
+            let text = '';
+            if (component instanceof TextComponent_1.default) {
+                text = component.getText();
+            }
+            else if (component instanceof ImageComponent_1.default) {
+                text = component.getAltText() ?? '';
+            }
+            else {
+                return false;
+            }
+            const hasLowercaseMatch = text.toLocaleLowerCase().indexOf(lowerSearchFor) !== -1;
+            const hasSameCaseMatch = text.indexOf(searchFor) !== -1;
+            return hasLowercaseMatch || hasSameCaseMatch;
+        });
+        return matchingComponents.map((match) => match.getBBox());
+    }
+    focusCurrentMatch() {
+        const matches = this.getMatches(this.searchInput.value);
+        let matchIdx = this.currentMatchIdx % matches.length;
+        if (matchIdx < 0) {
+            matchIdx = matches.length + matchIdx;
+        }
+        if (matchIdx < matches.length) {
+            const undoable = false;
+            void this.editor.dispatch(this.editor.viewport.zoomTo(matches[matchIdx], true, true), undoable);
+            this.editor.announceForAccessibility(this.editor.localization.focusedFoundText(matchIdx + 1, matches.length));
+        }
+    }
+    toNextMatch() {
+        this.currentMatchIdx++;
+        this.focusCurrentMatch();
+    }
+    toPrevMatch() {
+        this.currentMatchIdx--;
+        this.focusCurrentMatch();
+    }
+    fillOverlay() {
+        const label = document.createElement('label');
+        this.searchInput = document.createElement('input');
+        const nextBtn = document.createElement('button');
+        const closeBtn = document.createElement('button');
+        // Math.random() ensures that the ID is unique (to allow us to refer to it
+        // with an htmlFor).
+        this.searchInput.setAttribute('id', `${cssPrefix}-searchInput-${Math.random()}`);
+        label.htmlFor = this.searchInput.getAttribute('id');
+        label.innerText = this.editor.localization.findLabel;
+        nextBtn.innerText = this.editor.localization.toNextMatch;
+        closeBtn.innerText = this.editor.localization.closeDialog;
+        this.searchInput.onkeydown = (ev) => {
+            if (ev.key === 'Enter') {
+                if (ev.shiftKey) {
+                    this.toPrevMatch();
+                }
+                else {
+                    this.toNextMatch();
+                }
+            }
+            else if (ev.key === 'Escape') {
+                this.setVisible(false);
+            }
+            else if (this.editor.shortcuts.matchesShortcut(keybindings_1.toggleFindVisibleShortcutId, ev)) {
+                ev.preventDefault();
+                this.toggleVisible();
+            }
+        };
+        nextBtn.onclick = () => {
+            this.toNextMatch();
+        };
+        closeBtn.onclick = () => {
+            this.setVisible(false);
+        };
+        this.overlay.replaceChildren(label, this.searchInput, nextBtn, closeBtn);
+    }
+    isVisible() {
+        return this.overlay.style.display !== 'none';
+    }
+    setVisible(visible) {
+        if (visible !== this.isVisible()) {
+            this.overlay.style.display = visible ? 'block' : 'none';
+            if (visible) {
+                this.searchInput.focus();
+                this.editor.announceForAccessibility(this.editor.localization.findDialogShown);
+            }
+            else {
+                this.editor.focus();
+                this.editor.announceForAccessibility(this.editor.localization.findDialogHidden);
+            }
+        }
+    }
+    toggleVisible() {
+        this.setVisible(!this.isVisible());
+    }
+    onKeyPress(event) {
+        if (this.editor.shortcuts.matchesShortcut(keybindings_1.toggleFindVisibleShortcutId, event)) {
+            this.toggleVisible();
+            return true;
+        }
+        return false;
+    }
+    setEnabled(enabled) {
+        super.setEnabled(enabled);
+        if (this.isEnabled()) {
+            this.setVisible(false);
+        }
+    }
+}
+exports.default = FindTool;

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

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

package/dist/cjs/tools/InputFilter/ContextMenuRecognizer.d.ts

@@ -0,0 +1,17 @@
+import { InputEvt } from '../../inputEvents';
+import InputMapper from './InputMapper';
+export default class ContextMenuRecognizer extends InputMapper {
+    private canShowContextMenu;
+    private contextMenuTriggerPointer;
+    private contextMenuStartPoint;
+    private stationaryDetector;
+    private clickTolerance;
+    constructor();
+    /**
+     * In general, only certain events (i.e. touchscreens) are expected to be able to
+     * create long-press menus. This method checks whether `event` was generated by
+     * one such device.
+     */
+    private canMakeLongPressMenuEvent;
+    onEvent(event: InputEvt): boolean;
+}

package/dist/cjs/tools/InputFilter/ContextMenuRecognizer.js

@@ -0,0 +1,103 @@
+"use strict";
+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]; } };
+    }
+    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 });
+const inputEvents_1 = require("../../inputEvents");
+const InputMapper_1 = __importDefault(require("./InputMapper"));
+const StationaryPenDetector_1 = __importStar(require("../util/StationaryPenDetector"));
+const Pointer_1 = require("../../Pointer");
+class ContextMenuRecognizer extends InputMapper_1.default {
+    constructor() {
+        super();
+        this.canShowContextMenu = false;
+        this.stationaryDetector = null;
+        this.clickTolerance = 12;
+    }
+    /**
+     * In general, only certain events (i.e. touchscreens) are expected to be able to
+     * create long-press menus. This method checks whether `event` was generated by
+     * one such device.
+     */
+    canMakeLongPressMenuEvent(event) {
+        const allowedDevices = [Pointer_1.PointerDevice.Touch];
+        return event.allPointers.length === 1 && allowedDevices.includes(event.current.device);
+    }
+    onEvent(event) {
+        const sendContextMenuEvent = () => {
+            if (!(0, inputEvents_1.isPointerEvt)(event))
+                return false;
+            if (this.canShowContextMenu) {
+                const eventHandled = this.emit({
+                    kind: inputEvents_1.InputEvtType.ContextMenu,
+                    screenPos: event.current.screenPos,
+                    canvasPos: event.current.canvasPos,
+                });
+                if (eventHandled) {
+                    this.emit({
+                        kind: inputEvents_1.InputEvtType.GestureCancelEvt,
+                    });
+                    return true;
+                }
+            }
+            return false;
+        };
+        if (event.kind === inputEvents_1.InputEvtType.PointerDownEvt) {
+            if (event.allPointers.length === 1) {
+                this.canShowContextMenu = true;
+                this.contextMenuTriggerPointer = event.current;
+                this.contextMenuStartPoint = event.current.screenPos;
+                if (this.canMakeLongPressMenuEvent(event)) {
+                    this.stationaryDetector = new StationaryPenDetector_1.default(event.current, StationaryPenDetector_1.defaultStationaryDetectionConfig, sendContextMenuEvent);
+                }
+            }
+            else {
+                this.canShowContextMenu = false;
+            }
+        }
+        else if (event.kind === inputEvents_1.InputEvtType.PointerMoveEvt) {
+            if (this.canShowContextMenu) {
+                this.stationaryDetector?.onPointerMove(event.current);
+                // Only clicks/stationary long presses can create context menu events.
+                const deltaPosition = event.current.screenPos.minus(this.contextMenuStartPoint);
+                const threshold = this.clickTolerance;
+                if (deltaPosition.length() > threshold) {
+                    this.canShowContextMenu = false;
+                }
+            }
+        }
+        else if (event.kind === inputEvents_1.InputEvtType.PointerUpEvt) {
+            this.stationaryDetector?.destroy();
+            if (this.contextMenuTriggerPointer?.id === event.current.id &&
+                this.contextMenuTriggerPointer.device === Pointer_1.PointerDevice.RightButtonMouse &&
+                sendContextMenuEvent()) {
+                return true;
+            }
+        }
+        return this.emit(event);
+    }
+}
+exports.default = ContextMenuRecognizer;

package/dist/cjs/tools/InputFilter/ContextMenuRecognizer.test.d.ts

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

package/dist/cjs/tools/InputFilter/FunctionMapper.d.ts

@@ -0,0 +1,12 @@
+import { InputEvt } from '../../inputEvents';
+import InputMapper from './InputMapper';
+/**
+ * An `InputMapper` that applies a function to all events it receives.
+ *
+ * Useful for automated testing.
+ */
+export default class FunctionMapper extends InputMapper {
+    private fn;
+    constructor(fn: (event: InputEvt) => InputEvt);
+    onEvent(event: InputEvt): boolean;
+}

package/dist/cjs/tools/InputFilter/FunctionMapper.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InputMapper_1 = __importDefault(require("./InputMapper"));
+/**
+ * An `InputMapper` that applies a function to all events it receives.
+ *
+ * Useful for automated testing.
+ */
+class FunctionMapper extends InputMapper_1.default {
+    constructor(fn) {
+        super();
+        this.fn = fn;
+    }
+    onEvent(event) {
+        return this.emit(this.fn(event));
+    }
+}
+exports.default = FunctionMapper;

package/dist/cjs/tools/InputFilter/InputMapper.d.ts

@@ -0,0 +1,23 @@
+import { InputEvt } from '../../inputEvents';
+type OnEventCallback = (event: InputEvt) => boolean;
+export interface InputEventListener {
+    onEvent: OnEventCallback;
+}
+/**
+ * Accepts input events and emits input events.
+ */
+export default abstract class InputMapper implements InputEventListener {
+    #private;
+    constructor();
+    setEmitListener(listener: InputEventListener | OnEventCallback | null): void;
+    protected emit(event: InputEvt): boolean;
+    /**
+     * @returns true if the given `event` should be considered "handled" by the app and thus not
+     * forwarded to other targets. For example, returning "true" for a touchpad pinch event prevents
+     * the pinch event from zooming the webpage.
+     *
+     * Generally, this should return the result of calling `this.emit` with some event.
+     */
+    abstract onEvent(event: InputEvt): boolean;
+}
+export {};