js-draw 0.17.3 → 0.18.0

package/dist/mjs/src/rendering/localization.d.ts

@@ -0,0 +1,10 @@
+export interface TextRendererLocalization {
+    pathNodeCount(pathCount: number): string;
+    textNodeCount(nodeCount: number): string;
+    imageNodeCount(nodeCount: number): string;
+    textNode(content: string): string;
+    unlabeledImageNode: string;
+    imageNode(label: string): string;
+    rerenderAsText: string;
+}
+export declare const defaultTextRendererLocalization: TextRendererLocalization;

package/dist/mjs/src/rendering/renderers/AbstractRenderer.d.ts

@@ -0,0 +1,68 @@
+import Color4 from '../../Color4';
+import { LoadSaveDataTable } from '../../components/AbstractComponent';
+import Mat33 from '../../math/Mat33';
+import Path, { PathCommand } from '../../math/Path';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+export interface RenderablePathSpec {
+    startPoint: Point2;
+    commands: PathCommand[];
+    style: RenderingStyle;
+    path?: Path;
+}
+export interface RenderableImage {
+    transform: Mat33;
+    image: HTMLImageElement | HTMLCanvasElement;
+    base64Url: string;
+    label?: string;
+}
+export default abstract class AbstractRenderer {
+    private viewport;
+    private selfTransform;
+    private transformStack;
+    protected constructor(viewport: Viewport);
+    protected getViewport(): Viewport;
+    abstract displaySize(): Vec2;
+    abstract clear(): void;
+    protected abstract beginPath(startPoint: Point2): void;
+    protected abstract endPath(style: RenderingStyle): void;
+    protected abstract lineTo(point: Point2): void;
+    protected abstract moveTo(point: Point2): void;
+    protected abstract traceCubicBezierCurve(p1: Point2, p2: Point2, p3: Point2): void;
+    protected abstract traceQuadraticBezierCurve(controlPoint: Point2, endPoint: Point2): void;
+    abstract drawText(text: string, transform: Mat33, style: TextStyle): void;
+    abstract drawImage(image: RenderableImage): void;
+    abstract isTooSmallToRender(rect: Rect2): boolean;
+    setDraftMode(_draftMode: boolean): void;
+    protected objectLevel: number;
+    private currentPaths;
+    private flushPath;
+    drawPath(path: RenderablePathSpec): void;
+    drawRect(rect: Rect2, lineWidth: number, lineFill: RenderingStyle): void;
+    fillRect(rect: Rect2, fill: Color4): void;
+    startObject(_boundingBox: Rect2, _clip?: boolean): void;
+    /**
+     * Notes the end of an object.
+     * @param _loaderData - a map from strings to JSON-ifyable objects
+     * and contains properties attached to the object by whatever loader loaded the image. This
+     * is used to preserve attributes not supported by js-draw when loading/saving an image.
+     * Renderers may ignore this.
+     *
+     * @param _objectTags - a list of labels (e.g. `className`s) to be attached to the object.
+     * Renderers may ignore this.
+     */
+    endObject(_loaderData?: LoadSaveDataTable, _objectTags?: string[]): void;
+    protected getNestingLevel(): number;
+    abstract drawPoints(...points: Point2[]): void;
+    canRenderFromWithoutDataLoss(_other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(_renderTo: Mat33, other: AbstractRenderer): void;
+    setTransform(transform: Mat33 | null): void;
+    pushTransform(transform: Mat33): void;
+    popTransform(): void;
+    getCanvasToScreenTransform(): Mat33;
+    canvasToScreen(vec: Vec2): Vec2;
+    getSizeOfCanvasPixelOnScreen(): number;
+}

package/dist/{src/rendering/renderers/AbstractRenderer.js → mjs/src/rendering/renderers/AbstractRenderer.mjs}

@@ -1,6 +1,6 @@
-import Path, { PathCommandType } from '../../math/Path';
-import { Vec2 } from '../../math/Vec2';
-import { stylesEqual } from '../RenderingStyle';
+import  Path, { PathCommandType }  from '../../math/Path.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  { stylesEqual }  from '../RenderingStyle.mjs';
 export default class AbstractRenderer {
     constructor(viewport) {
         this.viewport = viewport;

package/dist/mjs/src/rendering/renderers/CanvasRenderer.d.ts

@@ -0,0 +1,63 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage, RenderablePathSpec } from './AbstractRenderer';
+/**
+ * Renders onto a `CanvasRenderingContext2D`.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor(document.body);
+ *
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ *
+ * // Ensure that the canvas can fit the entire rendering
+ * const viewport = editor.image.getImportExportViewport();
+ * canvas.width = viewport.getScreenRectSize().x;
+ * canvas.height = viewport.getScreenRectSize().y;
+ *
+ * // Render editor.image onto the renderer
+ * const renderer = new CanvasRenderer(ctx, viewport);
+ * editor.image.render(renderer, viewport);
+ * ```
+ */
+export default class CanvasRenderer extends AbstractRenderer {
+    private ctx;
+    private ignoreObjectsAboveLevel;
+    private ignoringObject;
+    private currentObjectBBox;
+    private minSquareCurveApproxDist;
+    private minRenderSizeAnyDimen;
+    private minRenderSizeBothDimens;
+    /**
+     * Creates a new `CanvasRenderer` that renders to the given rendering context.
+     * The `viewport` is used to determine the translation/rotation/scaling of the content
+     * to draw.
+     */
+    constructor(ctx: CanvasRenderingContext2D, viewport: Viewport);
+    private transformBy;
+    canRenderFromWithoutDataLoss(other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(transformBy: Mat33, other: AbstractRenderer): void;
+    setDraftMode(draftMode: boolean): void;
+    displaySize(): Vec2;
+    clear(): void;
+    protected beginPath(startPoint: Point2): void;
+    protected endPath(style: RenderingStyle): void;
+    protected lineTo(point: Point2): void;
+    protected moveTo(point: Point2): void;
+    protected traceCubicBezierCurve(p1: Point2, p2: Point2, p3: Point2): void;
+    protected traceQuadraticBezierCurve(controlPoint: Vec3, endPoint: Vec3): void;
+    drawPath(path: RenderablePathSpec): void;
+    drawText(text: string, transform: Mat33, style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    private clipLevels;
+    startObject(boundingBox: Rect2, clip?: boolean): void;
+    endObject(): void;
+    drawPoints(...points: Point2[]): void;
+    isTooSmallToRender(rect: Rect2): boolean;
+}

package/dist/{src/rendering/renderers/CanvasRenderer.js → mjs/src/rendering/renderers/CanvasRenderer.mjs}

@@ -1,9 +1,34 @@
-import Color4 from '../../Color4';
-import TextComponent from '../../components/TextComponent';
-import Path from '../../math/Path';
-import { Vec2 } from '../../math/Vec2';
-import AbstractRenderer from './AbstractRenderer';
+import  Color4  from '../../Color4.mjs';
+import  TextComponent  from '../../components/TextComponent.mjs';
+import  Path  from '../../math/Path.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  AbstractRenderer  from './AbstractRenderer.mjs';
+/**
+ * Renders onto a `CanvasRenderingContext2D`.
+ *
+ * @example
+ * ```ts
+ * const editor = new Editor(document.body);
+ *
+ * const canvas = document.createElement('canvas');
+ * const ctx = canvas.getContext('2d');
+ *
+ * // Ensure that the canvas can fit the entire rendering
+ * const viewport = editor.image.getImportExportViewport();
+ * canvas.width = viewport.getScreenRectSize().x;
+ * canvas.height = viewport.getScreenRectSize().y;
+ *
+ * // Render editor.image onto the renderer
+ * const renderer = new CanvasRenderer(ctx, viewport);
+ * editor.image.render(renderer, viewport);
+ * ```
+ */
 export default class CanvasRenderer extends AbstractRenderer {
+    /**
+     * Creates a new `CanvasRenderer` that renders to the given rendering context.
+     * The `viewport` is used to determine the translation/rotation/scaling of the content
+     * to draw.
+     */
     constructor(ctx, viewport) {
         super(viewport);
         this.ctx = ctx;
@@ -175,6 +200,7 @@ export default class CanvasRenderer extends AbstractRenderer {
             this.ignoringObject = false;
         }
     }
+    // @internal
     drawPoints(...points) {
         const pointRadius = 10;
         for (let i = 0; i < points.length; i++) {
@@ -191,6 +217,7 @@ export default class CanvasRenderer extends AbstractRenderer {
             this.ctx.fillText(`${i}`, point.x, point.y, pointRadius * 2);
         }
     }
+    // @internal
     isTooSmallToRender(rect) {
         // Should we ignore all objects within this object's bbox?
         const diagonal = this.getCanvasToScreenTransform().transformVec3(rect.size);

package/dist/mjs/src/rendering/renderers/DummyRenderer.d.ts

@@ -0,0 +1,35 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage } from './AbstractRenderer';
+export default class DummyRenderer extends AbstractRenderer {
+    clearedCount: number;
+    renderedPathCount: number;
+    lastFillStyle: RenderingStyle | null;
+    lastPoint: Point2 | null;
+    objectNestingLevel: number;
+    lastText: string | null;
+    lastImage: RenderableImage | null;
+    pointBuffer: Point2[];
+    constructor(viewport: Viewport);
+    displaySize(): Vec2;
+    clear(): void;
+    protected beginPath(startPoint: Vec3): void;
+    protected endPath(style: RenderingStyle): void;
+    protected lineTo(point: Vec3): void;
+    protected moveTo(point: Point2): void;
+    protected traceCubicBezierCurve(p1: Vec3, p2: Vec3, p3: Vec3): void;
+    protected traceQuadraticBezierCurve(controlPoint: Vec3, endPoint: Vec3): void;
+    drawPoints(..._points: Vec3[]): void;
+    drawText(text: string, _transform: Mat33, _style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    startObject(boundingBox: Rect2, _clip: boolean): void;
+    endObject(): void;
+    isTooSmallToRender(_rect: Rect2): boolean;
+    canRenderFromWithoutDataLoss(other: AbstractRenderer): boolean;
+    renderFromOtherOfSameType(transform: Mat33, other: AbstractRenderer): void;
+}

package/dist/{src/rendering/renderers/DummyRenderer.js → mjs/src/rendering/renderers/DummyRenderer.mjs}

@@ -1,5 +1,5 @@
-import { Vec2 } from '../../math/Vec2';
-import AbstractRenderer from './AbstractRenderer';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  AbstractRenderer  from './AbstractRenderer.mjs';
 // Renderer that outputs almost nothing. Useful for automated tests.
 export default class DummyRenderer extends AbstractRenderer {
     constructor(viewport) {

package/dist/mjs/src/rendering/renderers/SVGRenderer.d.ts

@@ -0,0 +1,57 @@
+import { LoadSaveDataTable } from '../../components/AbstractComponent';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2, Vec2 } from '../../math/Vec2';
+import Viewport from '../../Viewport';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage, RenderablePathSpec } from './AbstractRenderer';
+export declare const renderedStylesheetId = "js-draw-style-sheet";
+/**
+ * Renders onto an `SVGElement`.
+ *
+ * @see {@link Editor.toSVG}
+ */
+export default class SVGRenderer extends AbstractRenderer {
+    private elem;
+    private sanitize;
+    private lastPathStyle;
+    private lastPathString;
+    private objectElems;
+    private overwrittenAttrs;
+    /**
+     * Creates a renderer that renders onto `elem`. If `sanitize`, don't render potentially untrusted data.
+     *
+     * `viewport` is used to determine the translation/rotation/scaling/output size of the rendered
+     * data.
+     */
+    constructor(elem: SVGSVGElement, viewport: Viewport, sanitize?: boolean);
+    private addStyleSheet;
+    setRootSVGAttribute(name: string, value: string | null): void;
+    displaySize(): Vec2;
+    clear(): void;
+    private addPathToSVG;
+    drawPath(pathSpec: RenderablePathSpec): void;
+    private transformFrom;
+    private textContainer;
+    private textContainerTransform;
+    private textParentStyle;
+    drawText(text: string, transform: Mat33, style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    startObject(boundingBox: Rect2): void;
+    endObject(loaderData?: LoadSaveDataTable, elemClassNames?: string[]): void;
+    private unimplementedMessage;
+    protected beginPath(_startPoint: Point2): void;
+    protected endPath(_style: RenderingStyle): void;
+    protected lineTo(_point: Point2): void;
+    protected moveTo(_point: Point2): void;
+    protected traceCubicBezierCurve(_controlPoint1: Point2, _controlPoint2: Point2, _endPoint: Point2): void;
+    protected traceQuadraticBezierCurve(_controlPoint: Point2, _endPoint: Point2): void;
+    drawPoints(...points: Point2[]): void;
+    drawSVGElem(elem: SVGElement): void;
+    isTooSmallToRender(_rect: Rect2): boolean;
+    static fromViewport(viewport: Viewport, sanitize?: boolean): {
+        element: SVGSVGElement;
+        renderer: SVGRenderer;
+    };
+}

package/dist/{src/rendering/renderers/SVGRenderer.js → mjs/src/rendering/renderers/SVGRenderer.mjs}

@@ -1,13 +1,23 @@
-import Mat33 from '../../math/Mat33';
-import Path from '../../math/Path';
-import { toRoundedString } from '../../math/rounding';
-import { Vec2 } from '../../math/Vec2';
-import { svgAttributesDataKey, svgStyleAttributesDataKey } from '../../SVGLoader';
-import AbstractRenderer from './AbstractRenderer';
+import  Mat33  from '../../math/Mat33.mjs';
+import  Path  from '../../math/Path.mjs';
+import  { toRoundedString }  from '../../math/rounding.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  { svgAttributesDataKey, svgStyleAttributesDataKey }  from '../../SVGLoader.mjs';
+import  AbstractRenderer  from './AbstractRenderer.mjs';
 export const renderedStylesheetId = 'js-draw-style-sheet';
 const svgNameSpace = 'http://www.w3.org/2000/svg';
+/**
+ * Renders onto an `SVGElement`.
+ *
+ * @see {@link Editor.toSVG}
+ */
 export default class SVGRenderer extends AbstractRenderer {
-    // Renders onto `elem`. If `sanitize`, don't render potentially untrusted data.
+    /**
+     * Creates a renderer that renders onto `elem`. If `sanitize`, don't render potentially untrusted data.
+     *
+     * `viewport` is used to determine the translation/rotation/scaling/output size of the rendered
+     * data.
+     */
     constructor(elem, viewport, sanitize = false) {
         super(viewport);
         this.elem = elem;
@@ -275,4 +285,20 @@ export default class SVGRenderer extends AbstractRenderer {
     isTooSmallToRender(_rect) {
         return false;
     }
+    // Creates a new SVG element and SVGRenerer with attributes set for the given Viewport.
+    static fromViewport(viewport, sanitize = true) {
+        const svgNameSpace = 'http://www.w3.org/2000/svg';
+        const result = document.createElementNS(svgNameSpace, 'svg');
+        const rect = viewport.getScreenRectSize();
+        // rect.x -> size of rect in x direction, rect.y -> size of rect in y direction.
+        result.setAttribute('viewBox', [0, 0, rect.x, rect.y].map(part => toRoundedString(part)).join(' '));
+        result.setAttribute('width', toRoundedString(rect.x));
+        result.setAttribute('height', toRoundedString(rect.y));
+        // Ensure the image can be identified as an SVG if downloaded.
+        // See https://jwatt.org/svg/authoring/
+        result.setAttribute('version', '1.1');
+        result.setAttribute('baseProfile', 'full');
+        result.setAttribute('xmlns', svgNameSpace);
+        return { element: result, renderer: new SVGRenderer(result, viewport, sanitize) };
+    }
 }

package/dist/mjs/src/rendering/renderers/TextOnlyRenderer.d.ts

@@ -0,0 +1,29 @@
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import Vec3 from '../../math/Vec3';
+import Viewport from '../../Viewport';
+import { TextRendererLocalization } from '../localization';
+import RenderingStyle from '../RenderingStyle';
+import TextStyle from '../TextRenderingStyle';
+import AbstractRenderer, { RenderableImage } from './AbstractRenderer';
+export default class TextOnlyRenderer extends AbstractRenderer {
+    private localizationTable;
+    private descriptionBuilder;
+    private pathCount;
+    private textNodeCount;
+    private imageNodeCount;
+    constructor(viewport: Viewport, localizationTable: TextRendererLocalization);
+    displaySize(): Vec3;
+    clear(): void;
+    getDescription(): string;
+    protected beginPath(_startPoint: Vec3): void;
+    protected endPath(_style: RenderingStyle): void;
+    protected lineTo(_point: Vec3): void;
+    protected moveTo(_point: Vec3): void;
+    protected traceCubicBezierCurve(_p1: Vec3, _p2: Vec3, _p3: Vec3): void;
+    protected traceQuadraticBezierCurve(_controlPoint: Vec3, _endPoint: Vec3): void;
+    drawText(text: string, _transform: Mat33, _style: TextStyle): void;
+    drawImage(image: RenderableImage): void;
+    isTooSmallToRender(rect: Rect2): boolean;
+    drawPoints(..._points: Vec3[]): void;
+}

package/dist/{src/rendering/renderers/TextOnlyRenderer.js → mjs/src/rendering/renderers/TextOnlyRenderer.mjs}

@@ -1,5 +1,5 @@
-import { Vec2 } from '../../math/Vec2';
-import AbstractRenderer from './AbstractRenderer';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  AbstractRenderer  from './AbstractRenderer.mjs';
 // Outputs a description of what was rendered.
 export default class TextOnlyRenderer extends AbstractRenderer {
     constructor(viewport, localizationTable) {

package/dist/mjs/src/testing/beforeEachFile.d.ts

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

package/dist/{src/testing/beforeEachFile.js → mjs/src/testing/beforeEachFile.mjs}

@@ -1,4 +1,4 @@
-import loadExpectExtensions from './loadExpectExtensions';
+import  loadExpectExtensions  from './loadExpectExtensions.mjs';
 loadExpectExtensions();
 jest.useFakeTimers();
 // jsdom doesn't support HTMLCanvasElement#getContext — it logs an error

package/dist/mjs/src/testing/createEditor.d.ts

@@ -0,0 +1,4 @@
+import Editor from '../Editor';
+/** Creates an editor. Should only be used in test files. */
+declare const _default: () => Editor;
+export default _default;

package/dist/{src/testing/createEditor.js → mjs/src/testing/createEditor.mjs}

@@ -1,5 +1,5 @@
-import { RenderingMode } from '../rendering/Display';
-import Editor from '../Editor';
+import  { RenderingMode }  from '../rendering/Display.mjs';
+import  Editor  from '../Editor.mjs';
 /** Creates an editor. Should only be used in test files. */
 export default () => {
     if (jest === undefined) {

package/dist/mjs/src/testing/lib.d.ts

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

package/dist/mjs/src/testing/lib.mjs

@@ -0,0 +1,2 @@
+export  { default as sendPenEvent }  from './sendPenEvent.mjs';
+export  { default as sendTouchEvent }  from './sendTouchEvent.mjs';

package/dist/mjs/src/testing/loadExpectExtensions.d.ts

@@ -0,0 +1,2 @@
+export declare const loadExpectExtensions: () => void;
+export default loadExpectExtensions;

package/dist/mjs/src/testing/sendPenEvent.d.ts

@@ -0,0 +1,12 @@
+import Editor from '../Editor';
+import { Point2 } from '../math/Vec2';
+import Pointer from '../Pointer';
+import { InputEvtType } from '../types';
+/**
+ * Dispatch a pen event to the currently selected tool.
+ * Intended for unit tests.
+ *
+ * @see {@link sendTouchEvent}
+ */
+declare const sendPenEvent: (editor: Editor, eventType: InputEvtType.PointerDownEvt | InputEvtType.PointerMoveEvt | InputEvtType.PointerUpEvt, point: Point2, allPointers?: Pointer[]) => void;
+export default sendPenEvent;

package/dist/mjs/src/testing/sendPenEvent.mjs

@@ -0,0 +1,19 @@
+import  Pointer  from '../Pointer.mjs';
+import  { InputEvtType }  from '../types.mjs';
+/**
+ * Dispatch a pen event to the currently selected tool.
+ * Intended for unit tests.
+ *
+ * @see {@link sendTouchEvent}
+ */
+const sendPenEvent = (editor, eventType, point, allPointers) => {
+    const mainPointer = Pointer.ofCanvasPoint(point, eventType !== InputEvtType.PointerUpEvt, editor.viewport);
+    editor.toolController.dispatchInputEvent({
+        kind: eventType,
+        allPointers: allPointers !== null && allPointers !== void 0 ? allPointers : [
+            mainPointer,
+        ],
+        current: mainPointer,
+    });
+};
+export default sendPenEvent;

package/dist/mjs/src/testing/sendTouchEvent.d.ts

@@ -0,0 +1,42 @@
+import Editor from '../Editor';
+import { Vec2 } from '../math/Vec2';
+import Pointer from '../Pointer';
+import { InputEvtType } from '../types';
+/**
+ * Dispatch a touch event to the currently selected tool. Intended for unit tests.
+ *
+ * @see {@link sendPenEvent}
+ *
+ * @example
+ * **Simulating a horizontal swipe gesture:**
+ * ```ts
+ * sendTouchEvent(editor, InputEvtType.PointerDownEvt, Vec2.of(0, 0));
+ * for (let i = 1; i <= 10; i++) {
+ *   jest.advanceTimersByTime(10);
+ *   sendTouchEvent(editor, InputEvtType.PointerMoveEvt, Vec2.of(i * 10, 0));
+ * }
+ * ```
+ *
+ * @example
+ * **Simulating a pinch gesture.** This example assumes that you're using [Jest with timer mocks enabled](https://jestjs.io/docs/timer-mocks).
+ * ```ts
+ * let firstPointer = sendTouchEvent(editor, InputEvtType.PointerDownEvt, Vec2.of(0, 0));
+ * let secondPointer = sendTouchEvent(editor, InputEvtType.PointerDownEvt, Vec2.of(100, 0), [ firstPointer ]);
+ *
+ * // Simulate a pinch
+ * const maxIterations = 10;
+ * for (let i = 0; i < maxIterations; i++) {
+ *   // Use the unit testing framework's tool for increasing the current time
+ *   // returned by (new Date()).getTime(), etc.
+ *   jest.advanceTimersByTime(100);
+ *
+ *   const point1 = Vec2.of(-i * 5, 0);
+ *   const point2 = Vec2.of(i * 5 + 100, 0);
+ *
+ *   firstPointer = sendTouchEvent(editor, InputEvtType.PointerMoveEvt, point1, [ secondPointer ]);
+ *   secondPointer = sendTouchEvent(editor, InputEvtType.PointerMoveEvt, point2, [ firstPointer ]);
+ * }
+ * ```
+ */
+declare const sendTouchEvent: (editor: Editor, eventType: InputEvtType.PointerDownEvt | InputEvtType.PointerMoveEvt | InputEvtType.PointerUpEvt, screenPos: Vec2, allOtherPointers?: Pointer[]) => Pointer;
+export default sendTouchEvent;

package/dist/mjs/src/testing/sendTouchEvent.mjs

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