@ue-too/board 0.5.1

package/input-interpretation/input-state-machine/kmt-input-context.d.ts

@@ -0,0 +1,130 @@
+import { Point } from "@ue-too/math";
+import { BaseContext } from "@ue-too/being";
+import { UserInputPublisher } from "../raw-input-publisher";
+import { CanvasPositionDimensionPublisher } from "../../utils";
+export declare enum CursorStyle {
+    GRAB = "grab",
+    DEFAULT = "default",
+    GRABBING = "grabbing"
+}
+/**
+ * @description A proxy for the canvas so that client code that needs to access
+ * the canvas dimensions and position does not need to access the DOM directly.
+ */
+export interface CanvasOperator {
+    width: number;
+    height: number;
+    position: Point;
+    setCursor: (style: CursorStyle) => void;
+}
+/**
+ * @description A dummy implementation of the CanvasOperator interface.
+ * This is specifically for the case where a input state machine that is for the relay of the input events to the web worker.
+ * The input state machine needs a canvas operator in its context, but this context does not have any functionality.
+ * @see DummyKmtInputContext
+ */
+export declare class DummyCanvasOperator implements CanvasOperator {
+    width: number;
+    height: number;
+    position: Point;
+    setCursor: (style: CursorStyle) => void;
+}
+export declare class CanvasCacheInWebWorker implements CanvasOperator {
+    private _width;
+    private _height;
+    private _position;
+    private _postMessageFunction;
+    constructor(postMessageFunction: typeof postMessage);
+    set width(width: number);
+    set height(height: number);
+    set position(position: Point);
+    get width(): number;
+    get height(): number;
+    get position(): Point;
+    setCursor(style: "grab" | "default" | "grabbing"): void;
+}
+export declare class CanvasProxy implements CanvasOperator {
+    private _width;
+    private _height;
+    private _position;
+    private _canvasPositionDimensionPublisher;
+    private _canvas;
+    constructor(canvas: HTMLCanvasElement, canvasPositionDimensionPublisher?: CanvasPositionDimensionPublisher);
+    get width(): number;
+    get height(): number;
+    get position(): Point;
+    setCursor(style: "grab" | "default" | "grabbing"): void;
+    attach(canvas: HTMLCanvasElement): void;
+}
+/**
+ * @description A proxy for the canvas that is used to communicate with the web worker.
+ * The primary purpose of this class is to cache the canvas dimensions and position in the DOM to reduce the calling of the getBoundingClientRect method.
+ * This class only serves as a relay of the updated canvas dimensions and position to the web worker.
+ *
+ */
+export declare class CanvasProxyWorkerRelay implements CanvasOperator {
+    private _width;
+    private _height;
+    private _position;
+    private _webWorker;
+    private _canvas;
+    constructor(canvas: HTMLCanvasElement, webWorker: Worker, canvasDiemsionPublisher: CanvasPositionDimensionPublisher);
+    get width(): number;
+    get height(): number;
+    get position(): Point;
+    setCursor(style: "grab" | "default" | "grabbing"): void;
+}
+/**
+ * @description The context for the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export interface KmtInputContext extends BaseContext {
+    alignCoordinateSystem: boolean;
+    canvas: CanvasOperator;
+    notifyOnPan: (delta: Point) => void;
+    notifyOnZoom: (zoomAmount: number, anchorPoint: Point) => void;
+    notifyOnRotate: (deltaRotation: number) => void;
+    setInitialCursorPosition: (position: Point) => void;
+    initialCursorPosition: Point;
+}
+/**
+ * @description A dummy implementation of the KmtInputContext interface.
+ * This is specifically for the case where a input state machine that is for the relay of the input events to the web worker.
+ * The input state machine needs a context, but this context does not have any functionality.
+ */
+export declare class DummyKmtInputContext implements KmtInputContext {
+    alignCoordinateSystem: boolean;
+    canvas: CanvasOperator;
+    initialCursorPosition: Point;
+    constructor();
+    notifyOnPan(delta: Point): void;
+    notifyOnZoom(zoomAmount: number, anchorPoint: Point): void;
+    notifyOnRotate(deltaRotation: number): void;
+    setInitialCursorPosition(position: Point): void;
+    cleanup(): void;
+    setup(): void;
+}
+/**
+ * @description The observable input tracker.
+ * This is used as the context for the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class ObservableInputTracker implements KmtInputContext {
+    private _alignCoordinateSystem;
+    private _canvasOperator;
+    private _inputPublisher;
+    private _initialCursorPosition;
+    constructor(canvasOperator: CanvasOperator, inputPublisher: UserInputPublisher);
+    get alignCoordinateSystem(): boolean;
+    get canvas(): CanvasOperator;
+    get initialCursorPosition(): Point;
+    set alignCoordinateSystem(value: boolean);
+    notifyOnPan(delta: Point): void;
+    notifyOnZoom(zoomAmount: number, anchorPoint: Point): void;
+    notifyOnRotate(deltaRotation: number): void;
+    setInitialCursorPosition(position: Point): void;
+    cleanup(): void;
+    setup(): void;
+}

package/input-interpretation/input-state-machine/kmt-input-state-machine.d.ts

@@ -0,0 +1,194 @@
+import { EventReactions, EventGuards, Guard, TemplateState, TemplateStateMachine } from "@ue-too/being";
+import type { Point } from "@ue-too/math";
+import { CanvasOperator, KmtInputContext } from "./kmt-input-context";
+/**
+ * @description The possible states of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export type KmtInputStates = "IDLE" | "READY_TO_PAN_VIA_SPACEBAR" | "READY_TO_PAN_VIA_SCROLL_WHEEL" | "PAN" | "INITIAL_PAN" | "PAN_VIA_SCROLL_WHEEL";
+/**
+ * @description The payload for the pointer event.
+ *
+ * @category Input State Machine
+ */
+export type PointerEventPayload = {
+    x: number;
+    y: number;
+};
+type EmptyPayload = {};
+/**
+ * @description The payload for the scroll event.
+ *
+ * @category Input State Machine
+ */
+export type ScrollEventPayload = {
+    deltaX: number;
+    deltaY: number;
+};
+/**
+ * @description The payload for the scroll with ctrl event.
+ *
+ * @category Input State Machine
+ */
+export type ScrollWithCtrlEventPayload = {
+    deltaX: number;
+    deltaY: number;
+    x: number;
+    y: number;
+};
+/**
+ * @description The payload mapping for the events of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export type KmtInputEventMapping = {
+    leftPointerDown: PointerEventPayload;
+    leftPointerUp: PointerEventPayload;
+    leftPointerMove: PointerEventPayload;
+    spacebarDown: EmptyPayload;
+    spacebarUp: EmptyPayload;
+    stayIdle: EmptyPayload;
+    cursorOnElement: EmptyPayload;
+    scroll: ScrollEventPayload;
+    scrollWithCtrl: ScrollWithCtrlEventPayload;
+    middlePointerDown: PointerEventPayload;
+    middlePointerUp: PointerEventPayload;
+    middlePointerMove: PointerEventPayload;
+};
+/**
+ * @description Converts the point from window coordinates(browser) to view port coordinates.
+ *
+ * @category Input State Machine
+ */
+export declare function convertFromWindow2ViewPort(point: Point, canvas: HTMLCanvasElement): Point;
+export declare function convertFromWindow2ViewPortWithCanvasOperator(point: Point, canvasOperator: CanvasOperator): Point;
+export declare function convertFromWindow2ViewPortCanvasOperator(point: Point, canvasOperator: CanvasOperator): Point;
+/**
+ * @description The possible target states of the idle state.
+ *
+ * @category Input State Machine
+ */
+export type KmtIdleStatePossibleTargetStates = "IDLE" | "READY_TO_PAN_VIA_SPACEBAR" | "READY_TO_PAN_VIA_SCROLL_WHEEL";
+/**
+ * @description The idle state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class KmtIdleState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    constructor();
+    protected _guards: Guard<KmtInputContext, "isIdle">;
+    protected _eventGuards: Partial<EventGuards<KmtInputEventMapping, KmtInputStates, KmtInputContext, Guard<KmtInputContext>>>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    scrollHandler(context: KmtInputContext, payload: ScrollEventPayload): void;
+    scrollWithCtrlHandler(context: KmtInputContext, payload: ScrollWithCtrlEventPayload): void;
+    spacebarDownHandler(context: KmtInputContext, payload: EmptyPayload): void;
+    middlePointerDownHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+}
+/**
+ * @description The possible target states of the ready to select state.
+ *
+ * @category Input State Machine
+ */
+export type ReadyToSelectStatePossibleTargetStates = "IDLE" | "SELECTING";
+/**
+ * @description The context for the ready to select state.
+ *
+ * @category Input State Machine
+ */
+export type SelectionContext = {
+    setSelectionEndPoint: (point: Point) => void;
+    toggleSelectionBox: (show: boolean) => void;
+    cleanup: () => void;
+    setup: () => void;
+    canvas: HTMLCanvasElement;
+};
+/**
+ * @description The ready to select state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class ReadyToSelectState extends TemplateState<KmtInputEventMapping, SelectionContext, ReadyToSelectStatePossibleTargetStates> {
+    constructor();
+    leftPointerMove: any;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, SelectionContext, ReadyToSelectStatePossibleTargetStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, SelectionContext, ReadyToSelectStatePossibleTargetStates>;
+}
+/**
+ * @description The ready to pan via space bar state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class ReadyToPanViaSpaceBarState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    constructor();
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    leftPointerDownHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    spacebarUpHandler(context: KmtInputContext, payload: EmptyPayload): void;
+}
+/**
+ * @description The initial pan state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class InitialPanState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    constructor();
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    leftPointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    leftPointerUpHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+}
+/**
+ * @description The ready to pan via scroll wheel state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class ReadyToPanViaScrollWheelState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    constructor();
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    middlePointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    middlePointerUpHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+}
+/**
+ * @description The pan state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class PanState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    constructor();
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    leftPointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    spacebarUpHandler(context: KmtInputContext, payload: EmptyPayload): void;
+    leftPointerUpHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+}
+/**
+ * @description The pan via scroll wheel state of the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class PanViaScrollWheelState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    middlePointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    middlePointerUpHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+}
+export declare class KmtEmptyState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    constructor();
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+}
+export type KmtInputStateMachine = TemplateStateMachine<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+/**
+ * @description Creates the keyboard mouse and trackpad input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare function createKmtInputStateMachine(context: KmtInputContext): KmtInputStateMachine;
+export declare class KmtInputStateMachineWebWorkerProxy extends TemplateStateMachine<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+    private _webworker;
+    constructor(webworker: Worker);
+    happens(event: keyof KmtInputEventMapping, payload: KmtInputEventMapping[keyof KmtInputEventMapping]): KmtInputStates | undefined;
+}
+export {};

package/input-interpretation/input-state-machine/touch-input-context.d.ts

@@ -0,0 +1,44 @@
+import type { Point } from "@ue-too/math";
+import { RawUserInputPublisher } from "../raw-input-publisher";
+import { BaseContext } from "@ue-too/being";
+import { CanvasOperator } from "./kmt-input-context";
+/**
+ * @description The touch points.
+ *
+ * @category Input State Machine
+ */
+export type TouchPoints = {
+    ident: number;
+    x: number;
+    y: number;
+};
+export interface TouchContext extends BaseContext {
+    addTouchPoints: (points: TouchPoints[]) => void;
+    removeTouchPoints: (idents: number[]) => void;
+    getCurrentTouchPointsCount: () => number;
+    getInitialTouchPointsPositions: (idents: number[]) => TouchPoints[];
+    updateTouchPoints: (pointsMoved: TouchPoints[]) => void;
+    notifyOnPan: (delta: Point) => void;
+    notifyOnZoom: (zoomAmount: number, anchorPoint: Point) => void;
+    alignCoordinateSystem: boolean;
+    canvas: CanvasOperator;
+}
+export declare class TouchInputTracker implements TouchContext {
+    private _inputPublisher;
+    private _touchPointsMap;
+    private _canvas;
+    private _alignCoordinateSystem;
+    constructor(canvas: CanvasOperator, inputPublisher: RawUserInputPublisher);
+    addTouchPoints(points: TouchPoints[]): void;
+    removeTouchPoints(identifiers: number[]): void;
+    getCurrentTouchPointsCount(): number;
+    getInitialTouchPointsPositions(idents: number[]): TouchPoints[];
+    updateTouchPoints(pointsMoved: TouchPoints[]): void;
+    notifyOnPan(delta: Point): void;
+    notifyOnZoom(zoomAmount: number, anchorPoint: Point): void;
+    get alignCoordinateSystem(): boolean;
+    set alignCoordinateSystem(value: boolean);
+    get canvas(): CanvasOperator;
+    cleanup(): void;
+    setup(): void;
+}

package/input-interpretation/input-state-machine/touch-input-state-machine.d.ts

@@ -0,0 +1,64 @@
+import { EventReactions, EventGuards, Guard, TemplateState, TemplateStateMachine } from "@ue-too/being";
+import { TouchContext, TouchPoints } from "./touch-input-context";
+export type TouchStates = "IDLE" | "PENDING" | "IN_PROGRESS";
+/**
+ * @description The touch event payload.
+ *
+ * @category Input State Machine
+ */
+export type TouchEventPayload = {
+    points: TouchPoints[];
+};
+/**
+ * @description The touch event mapping.
+ *
+ * @category Input State Machine
+ */
+export type TouchEventMapping = {
+    touchstart: TouchEventPayload;
+    touchmove: TouchEventPayload;
+    touchend: TouchEventPayload;
+};
+/**
+ * @description The idle state of the touch input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class IdleState extends TemplateState<TouchEventMapping, TouchContext, TouchStates> {
+    private _eventReactions;
+    protected _guards: Guard<TouchContext, "touchPointsCount">;
+    protected _eventGuards: Partial<EventGuards<TouchEventMapping, TouchStates, TouchContext, typeof this._guards>>;
+    get eventReactions(): EventReactions<TouchEventMapping, TouchContext, TouchStates>;
+    touchstart(context: TouchContext, payload: TouchEventPayload): void;
+    touchend(context: TouchContext, payload: TouchEventPayload): void;
+}
+/**
+ * @description The pending state of the touch input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class PendingState extends TemplateState<TouchEventMapping, TouchContext, TouchStates> {
+    private _eventReactions;
+    get eventReactions(): EventReactions<TouchEventMapping, TouchContext, TouchStates>;
+    touchstart(context: TouchContext, payload: TouchEventPayload): void;
+    touchend(context: TouchContext, payload: TouchEventPayload): void;
+    touchmove(context: TouchContext, payload: TouchEventPayload): void;
+}
+/**
+ * @description The in progress state of the touch input state machine.
+ *
+ * @category Input State Machine
+ */
+export declare class InProgressState extends TemplateState<TouchEventMapping, TouchContext, TouchStates> {
+    private _eventReactions;
+    get eventReactions(): EventReactions<TouchEventMapping, TouchContext, TouchStates>;
+    touchmove(context: TouchContext, payload: TouchEventPayload): void;
+    touchend(context: TouchContext, payload: TouchEventPayload): void;
+}
+/**
+ * @description The touch input state machine.
+ *
+ * @category Input State Machine
+ */
+export type TouchInputStateMachine = TemplateStateMachine<TouchEventMapping, TouchContext, TouchStates>;
+export declare function createTouchInputStateMachine(context: TouchContext): TouchInputStateMachine;

package/input-interpretation/raw-input-parser/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./vanilla-kmt-event-parser";
+export * from "./vanilla-touch-event-parser";

package/input-interpretation/raw-input-parser/vanilla-kmt-event-parser.d.ts

@@ -0,0 +1,87 @@
+import type { KmtInputStateMachine } from "../../input-interpretation/input-state-machine";
+/**
+ * @category Event Parser
+ */
+export interface KMTEventParser {
+    disabled: boolean;
+    setUp(): void;
+    tearDown(): void;
+    attach(canvas: HTMLCanvasElement): void;
+}
+/**
+ * @description The minimum pointer event.
+ * This is for the interoperability between the vanilla javascript and the pixijs event system.
+ *
+ * @category Event Parser
+ */
+export type MinimumPointerEvent = {
+    button: number;
+    pointerType: string;
+    clientX: number;
+    clientY: number;
+    buttons: number;
+};
+/**
+ * @description The minimum wheel event.
+ * This is for the interoperability between the vanilla javascript and the pixijs event system.
+ *
+ * @category Event Parser
+ */
+export type MinimumWheelEvent = {
+    preventDefault: () => void;
+    deltaX: number;
+    deltaY: number;
+    ctrlKey: boolean;
+    clientX: number;
+    clientY: number;
+};
+/**
+ * @description The minimum keyboard event.
+ * This is for the interoperability between the vanilla javascript and the pixijs event system.
+ *
+ * @category Event Parser
+ */
+export type MinimumKeyboardEvent = {
+    preventDefault: () => void;
+    key: string;
+};
+/**
+ * @description The event target with pointer events.
+ * This is for the interoperability between the vanilla javascript and the pixijs event system.
+ *
+ * @category Event Parser
+ */
+export type EventTargetWithPointerEvents = {
+    addEventListener: (type: string, listener: (event: any) => void, options?: {
+        passive: boolean;
+    }) => void;
+    removeEventListener: (type: string, listener: (event: any) => void) => void;
+};
+/**
+ * @description The vanilla keyboard mouse and trackpad(KMT) event parser.
+ * This parser converts the raw events to events that can be used by the input state machine.
+ *
+ * @category Event Parser
+ */
+export declare class VanillaKMTEventParser implements KMTEventParser {
+    private _disabled;
+    private _stateMachine;
+    private _keyfirstPressed;
+    private _abortController;
+    private _canvas;
+    constructor(canvas: HTMLCanvasElement, kmtInputStateMachine: KmtInputStateMachine);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get stateMachine(): KmtInputStateMachine;
+    addEventListeners(signal: AbortSignal): void;
+    setUp(): void;
+    tearDown(): void;
+    bindFunctions(): void;
+    pointerDownHandler(e: MinimumPointerEvent): void;
+    pointerUpHandler(e: MinimumPointerEvent): void;
+    pointerMoveHandler(e: MinimumPointerEvent): void;
+    scrollHandler(e: MinimumWheelEvent): void;
+    keypressHandler(e: KeyboardEvent): void;
+    keyupHandler(e: KeyboardEvent): void;
+    attach(canvas: HTMLCanvasElement): void;
+}

package/input-interpretation/raw-input-parser/vanilla-touch-event-parser.d.ts

@@ -0,0 +1,55 @@
+import { TouchInputStateMachine } from "../../input-interpretation/input-state-machine/touch-input-state-machine";
+/**
+ * @description The touch event parser.
+ * This is for the interoperability between the vanilla javascript and the pixijs event system.
+ *
+ * @category Event Parser
+ */
+export interface TouchEventParser {
+    disabled: boolean;
+    panDisabled: boolean;
+    zoomDisabled: boolean;
+    rotateDisabled: boolean;
+    enableStrategy(): void;
+    disableStrategy(): void;
+    setUp(): void;
+    tearDown(): void;
+    attach(canvas: HTMLCanvasElement): void;
+}
+/**
+ * @description The vanilla touch event parser.
+ * This parser converts the raw events to events that can be used by the input state machine.
+ *
+ * @category Event Parser
+ */
+export declare class VanillaTouchEventParser implements TouchEventParser {
+    private _canvas;
+    private _touchInputTracker;
+    private _disabled;
+    private _panDisabled;
+    private _zoomDisabled;
+    private _rotateDisabled;
+    private touchSM;
+    private _abortController;
+    constructor(canvas: HTMLCanvasElement, touchInputStateMachine: TouchInputStateMachine);
+    get touchStateMachine(): TouchInputStateMachine;
+    bindListeners(): void;
+    enableStrategy(): void;
+    disableStrategy(): void;
+    setUp(): void;
+    tearDown(): void;
+    get disabled(): boolean;
+    get alignCoordinateSystem(): boolean;
+    set alignCoordinateSystem(alignCoordinateSystem: boolean);
+    get panDisabled(): boolean;
+    set panDisabled(panDisabled: boolean);
+    get zoomDisabled(): boolean;
+    set zoomDisabled(zoomDisabled: boolean);
+    get rotateDisabled(): boolean;
+    set rotateDisabled(rotateDisabled: boolean);
+    touchstartHandler(e: TouchEvent): void;
+    touchcancelHandler(e: TouchEvent): void;
+    touchendHandler(e: TouchEvent): void;
+    touchmoveHandler(e: TouchEvent): void;
+    attach(canvas: HTMLCanvasElement): void;
+}

package/input-interpretation/raw-input-publisher/index.d.ts

@@ -0,0 +1 @@
+export * from "./raw-input-publisher";