@mirasen/chessboard 0.1.1 → 1.0.0

package/dist/layout/geometry/factory.js

@@ -1,32 +1,31 @@
 import { fileOf, rankOf } from '../../state/board/coords.js';
-/**
- * Create RenderGeometry for a given board size (in px) and orientation.
- * - Geometry uses an SVG-local coordinate system with origin at top-left.
- * - Orientation mapping:
- *   - 'white': files increase left→right (a..h), ranks increase bottom→top (1..8).
- *              yIndex = 7 - rank, xIndex = file
- *   - 'black': files increase right→left (a..h), ranks increase top→bottom (1..8).
- *              yIndex = rank, xIndex = 7 - file
- */
-export function createRenderGeometry(boardSize, orientation) {
-    if (!(boardSize > 0 && Number.isFinite(boardSize))) {
-        throw new RangeError(`Invalid boardSize: ${boardSize}`);
+import { makeBoardRect, measureBoardSize } from './helpers.js';
+export function createRenderGeometry(sceneSize, orientation) {
+    if (!(sceneSize.height > 0 &&
+        Number.isFinite(sceneSize.height) &&
+        sceneSize.width > 0 &&
+        Number.isFinite(sceneSize.width))) {
+        throw new RangeError(`Invalid sceneSize: ${JSON.stringify(sceneSize)}`);
     }
+    const boardSize = measureBoardSize(sceneSize);
+    const boardRect = makeBoardRect(sceneSize);
     const squareSize = boardSize / 8;
     const white = orientation === 0 /* ColorCode.White */;
     return {
-        boardSize,
+        sceneSize: { ...sceneSize },
+        boardRect,
         squareSize,
         orientation,
-        squareRect(sq) {
+        getSquareRect(sq) {
             const f = fileOf(sq);
             const r = rankOf(sq);
             const xIndex = white ? f : 7 - f;
             const yIndex = white ? 7 - r : r;
             return {
-                x: xIndex * squareSize,
-                y: yIndex * squareSize,
-                size: squareSize
+                x: boardRect.x + xIndex * squareSize,
+                y: boardRect.y + yIndex * squareSize,
+                width: squareSize,
+                height: squareSize
             };
         }
     };

package/dist/layout/geometry/helpers.d.ts

@@ -0,0 +1,5 @@
+import { Rect, RectSnapshot, Size, SizeSnapshot } from './types.js';
+export declare function sceneRectsEqual(rect1: RectSnapshot | null, rect2: RectSnapshot | null): boolean;
+export declare function sceneSizesEqual(size1: SizeSnapshot | null, size2: SizeSnapshot | null): boolean;
+export declare function measureBoardSize(sceneSize: Size): number;
+export declare function makeBoardRect(sceneSize: Size): Rect;

package/dist/layout/geometry/helpers.js

@@ -0,0 +1,33 @@
+export function sceneRectsEqual(rect1, rect2) {
+    if (rect1 === null && rect2 === null) {
+        return true;
+    }
+    if (rect1 === null || rect2 === null) {
+        return false;
+    }
+    return (rect1.x === rect2.x &&
+        rect1.y === rect2.y &&
+        rect1.width === rect2.width &&
+        rect1.height === rect2.height);
+}
+export function sceneSizesEqual(size1, size2) {
+    if (size1 === null && size2 === null) {
+        return true;
+    }
+    if (size1 === null || size2 === null) {
+        return false;
+    }
+    return size1.width === size2.width && size1.height === size2.height;
+}
+export function measureBoardSize(sceneSize) {
+    return Math.min(sceneSize.width, sceneSize.height);
+}
+export function makeBoardRect(sceneSize) {
+    const boardSize = measureBoardSize(sceneSize);
+    return {
+        x: (sceneSize.width - boardSize) / 2,
+        y: (sceneSize.height - boardSize) / 2,
+        width: boardSize,
+        height: boardSize
+    };
+}

package/dist/layout/geometry/types.d.ts

@@ -1,20 +1,21 @@
 import { ReadonlyDeep } from 'type-fest';
 import { ColorCode, Square } from '../../state/board/types/internal.js';
-export interface SquareRect {
+export interface Size {
+    width: number;
+    height: number;
+}
+export type SizeSnapshot = ReadonlyDeep<Size>;
+export interface Rect {
     x: number;
     y: number;
-    size: number;
+    width: number;
+    height: number;
 }
-export type SquareRectSnapshot = ReadonlyDeep<SquareRect>;
-/**
- * RenderGeometry represents the derived geometry of the rendered chessboard.
- * It includes the board size, square size, orientation, and square rectangle mapping.
- *
- * It is computed from layout inputs and used by rendering and interaction code.
- */
-export interface RenderGeometry {
-    readonly boardSize: number;
+export type RectSnapshot = ReadonlyDeep<Rect>;
+export interface SceneRenderGeometry {
+    readonly sceneSize: SizeSnapshot;
+    readonly boardRect: RectSnapshot;
     readonly squareSize: number;
     readonly orientation: ColorCode;
-    squareRect(sq: Square): SquareRectSnapshot;
+    getSquareRect(sq: Square): RectSnapshot;
 }

package/dist/layout/helpers.d.ts

@@ -1,4 +1,3 @@
-/**
- * Measure board size from container (square board fits within host).
- */
-export declare function measureBoardSize(container: HTMLElement): number;
+import { Size } from './geometry/types.js';
+export declare function measureSceneSize(container: HTMLElement): Size;
+export declare function isSceneSizeValid(size: Size | null): boolean;

package/dist/layout/helpers.js

@@ -1,6 +1,6 @@
-/**
- * Measure board size from container (square board fits within host).
- */
-export function measureBoardSize(container) {
-    return Math.min(container.clientWidth, container.clientHeight);
+export function measureSceneSize(container) {
+    return { width: container.clientWidth, height: container.clientHeight };
+}
+export function isSceneSizeValid(size) {
+    return size !== null && size.width > 0 && size.height > 0;
 }

package/dist/layout/reducers.js

@@ -1,5 +1,6 @@
 import { createRenderGeometry } from './geometry/factory.js';
-import { measureBoardSize } from './helpers.js';
+import { sceneSizesEqual } from './geometry/helpers.js';
+import { isSceneSizeValid, measureSceneSize } from './helpers.js';
 export function layoutRefreshGeometry(state, options) {
     const orientation = options.orientation ?? state.orientation;
     if (orientation === null) {
@@ -7,23 +8,23 @@ export function layoutRefreshGeometry(state, options) {
         // For now we throw
         throw new Error('Orientation is expected to be provided on the first pass of layout.refreshGeometry');
     }
-    let boardSize = options.container ? measureBoardSize(options.container) : state.boardSize;
-    if (boardSize !== null && boardSize <= 0)
-        boardSize = null;
-    const changed = boardSize !== state.boardSize || orientation !== state.orientation;
+    let sceneSize = options.container ? measureSceneSize(options.container) : state.sceneSize;
+    if (sceneSize !== null && !isSceneSizeValid(sceneSize))
+        sceneSize = null;
+    const changed = !sceneSizesEqual(sceneSize, state.sceneSize) || orientation !== state.orientation;
     if (!changed) {
         return false; // no-op, no relevant changes
     }
     // Update the state
-    state.boardSize = boardSize;
+    state.sceneSize = sceneSize;
     state.orientation = orientation;
-    if (boardSize === null || orientation === null) {
+    if (sceneSize === null || orientation === null) {
         // General invalid-geometry rule. Orientation is currently guarded above,
         // but this branch stays explicit in case null orientation is allowed later.
         state.geometry = null;
     }
     else {
-        state.geometry = createRenderGeometry(boardSize, orientation);
+        state.geometry = createRenderGeometry(sceneSize, orientation);
     }
     state.layoutEpoch++;
     return true;

package/dist/layout/types.d.ts

@@ -1,11 +1,11 @@
 import { ReadonlyDeep } from 'type-fest';
 import { ColorCode } from '../state/board/types/internal.js';
-import { RenderGeometry } from './geometry/types.js';
+import { SceneRenderGeometry, Size } from './geometry/types.js';
 import { LayoutMutationSession } from './mutation.js';
 export interface LayoutInternal {
-    boardSize: number | null;
+    sceneSize: Size | null;
     orientation: ColorCode | null;
-    geometry: RenderGeometry | null;
+    geometry: SceneRenderGeometry | null;
     layoutEpoch: number;
 }
 export type LayoutSnapshot = ReadonlyDeep<LayoutInternal>;
@@ -14,9 +14,9 @@ export interface LayoutRefreshOptions {
     orientation?: ColorCode;
 }
 export interface Layout {
-    readonly boardSize: number | null;
+    readonly sceneSize: Size | null;
     readonly orientation: ColorCode | null;
-    readonly geometry: RenderGeometry | null;
+    readonly geometry: SceneRenderGeometry | null;
     readonly layoutEpoch: number;
     refreshGeometry(options: LayoutRefreshOptions, mutationSession: LayoutMutationSession): boolean;
     getSnapshot(): LayoutSnapshot;

package/dist/render/mount.js

@@ -8,13 +8,13 @@ export function renderMount(state, element) {
     // Now call onMount for all extensions with their slot roots
     for (const extensionRec of state.extensions.values()) {
         const slotRoots = extensionRec.render.slots;
-        extensionRec.extension.instance.mount({ slotRoots });
+        extensionRec.extension.instance.mount?.({ slotRoots });
     }
 }
 export function renderUnmount(state) {
     validateIsMounted(state);
     for (const extensionRec of state.extensions.values()) {
-        extensionRec.extension.instance.unmount();
+        extensionRec.extension.instance.unmount?.();
         // clear the slot roots
         for (const slotRoot of Object.values(extensionRec.render.slots)) {
             clearElementChildren(slotRoot);

package/dist/render/rendering/state.js

@@ -1,3 +1,4 @@
+import { sceneSizesEqual } from '../../layout/geometry/helpers.js';
 import { updateElementAttributes } from '../svg/helpers.js';
 import { validateIsMounted } from './helpers.js';
 export function checkNeedsRender(state) {
@@ -16,14 +17,13 @@ export function performRenderPass(state, request) {
     if (!request.layout.geometry) {
         throw new Error('render() called without a valid layout geometry');
     }
-    const currentSize = request.layout.geometry.boardSize;
-    const prevSize = state.currentFrame?.layout.geometry?.boardSize;
-    if (currentSize !== prevSize) {
-        const size = String(currentSize);
+    const currentSize = request.layout.geometry.sceneSize;
+    const prevSize = state.currentFrame?.layout.geometry?.sceneSize ?? null;
+    if (!sceneSizesEqual(currentSize, prevSize)) {
         updateElementAttributes(state.svgRoots.svgRoot, {
-            width: size,
-            height: size,
-            viewBox: `0 0 ${size} ${size}`
+            width: currentSize.width.toString(),
+            height: currentSize.height.toString(),
+            viewBox: `0 0 ${currentSize.width} ${currentSize.height}`
         });
     }
     // Check if we have any invalidation states

package/dist/runtime/factory/events.d.ts

@@ -0,0 +1,3 @@
+import { ExtensionRuntimeSurfaceEvents } from '../../extensions/types/surface/events.js';
+import { GetInternalState } from '../types/main.js';
+export declare function createExtensionRuntimeSurfaceEvents(getInternalState: GetInternalState): ExtensionRuntimeSurfaceEvents;

package/dist/runtime/factory/events.js

@@ -0,0 +1,18 @@
+import assert from '@ktarmyshov/assert';
+import { NEED_EVENT_TYPES } from '../input/adapter/types.js';
+export function createExtensionRuntimeSurfaceEvents(getInternalState) {
+    return {
+        subscribeEvent(type) {
+            const internalState = getInternalState();
+            assert(internalState.inputAdapter, 'Input adapter not available in the current runtime state');
+            internalState.inputAdapter.subscribeEvent(type);
+        },
+        unsubscribeEvent(type) {
+            const internalState = getInternalState();
+            assert(internalState.inputAdapter, 'Input adapter not available in the current runtime state');
+            if (!NEED_EVENT_TYPES.has(type)) {
+                internalState.inputAdapter.unsubscribeEvent(type);
+            }
+        }
+    };
+}

package/dist/runtime/factory/helpers.js

@@ -1,9 +1,9 @@
 import assert from '@ktarmyshov/assert';
 import { isEmptyPieceCode } from '../../state/board/check.js';
+import { createPendingUIMoveRequest } from '../../state/change/factory/ui-move.js';
 import { canMoveTo } from '../input/controller/helpers.js';
-import { createUIMoveRequestContext } from './ui-move.js';
-function assertResolvedAfterAutoResolve(state) {
-    if (state.status !== 'resolved') {
+function assertResolvedAfterAutoResolve(request) {
+    if (request.status !== 'resolved') {
         throw new Error('UI move request must be resolved after autoresolve');
     }
 }
@@ -22,18 +22,18 @@ export function uiMoveCompleteTo(state, target) {
     assert(canMoveTo(interaction.getSnapshot(), target), 'dropTo/releaseTo target must be a valid move destination');
     // canMoveTo already confirmed we can move, but if 'FREE' movability it can be that there are no activeDestinations for the target square, so we need to handle that case as well
     const destination = interaction.activeDestinations.get(target) ?? { to: target };
-    const moveRequestContext = createUIMoveRequestContext(dragSession.sourceSquare, destination);
-    state.extensionSystem.onUIMoveRequest(moveRequestContext);
-    if (moveRequestContext.status === 'deferred') {
-        state.state.change.setDeferredUIMoveRequestContext(moveRequestContext, mutationSession);
+    const pendingUIMoveRequest = createPendingUIMoveRequest(dragSession.sourceSquare, destination);
+    state.extensionSystem.onUIMoveRequest({ request: pendingUIMoveRequest });
+    if (pendingUIMoveRequest.status === 'deferred') {
+        state.state.change.setDeferredUIMoveRequest(pendingUIMoveRequest, mutationSession);
     }
-    else if (moveRequestContext.status === 'unresolved') {
+    else if (pendingUIMoveRequest.status === 'unresolved') {
         // Try to auto-resolve if possible (e.g. if there are no promotion choices to be made)
-        moveRequestContext.autoresolve();
-        assertResolvedAfterAutoResolve(moveRequestContext);
+        pendingUIMoveRequest.autoresolve();
+        assertResolvedAfterAutoResolve(pendingUIMoveRequest);
     }
-    if (moveRequestContext.status === 'resolved') {
-        const moveRequest = moveRequestContext.resolvedMoveRequest;
+    if (pendingUIMoveRequest.status === 'resolved') {
+        const moveRequest = pendingUIMoveRequest.resolvedMoveRequest;
         if (moveRequest !== null) {
             state.state.board.move(moveRequest, mutationSession);
         }

package/dist/runtime/factory/input.js

@@ -1,5 +1,6 @@
 import assert from '@ktarmyshov/assert';
 import { isEmptyPieceCode } from '../../state/board/check.js';
+import { isDragSessionCoreOwned } from '../../state/interaction/helpers.js';
 import { runtimeRunMutationPipeline } from '../mutation/run.js';
 import { uiMoveCompleteTo } from './helpers.js';
 export function createRuntimeInteractionSurface(state) {
@@ -24,6 +25,7 @@ export function createRuntimeInteractionSurface(state) {
             };
             interaction.setSelected(interactionSource, interactionMutationSession);
             const dragSession = {
+                owner: 'core',
                 type: 'lifted-piece-drag',
                 sourceSquare: interactionSource.square,
                 sourcePieceCode: interactionSource.pieceCode,
@@ -36,27 +38,27 @@ export function createRuntimeInteractionSurface(state) {
             const internalState = state();
             internalState.renderSystem.requestRenderVisuals(input);
         },
-        dropTo(target) {
+        completeCoreDragTo(target) {
             const internalState = state();
             const mutationSession = internalState.mutation.getSession();
             const interaction = internalState.state.interaction;
             const dragSession = interaction.dragSession;
-            assert(dragSession !== null, 'dropTo requires an active drag session');
-            assert(dragSession.type === 'lifted-piece-drag', 'dropTo requires a lifted-piece-drag session');
+            assert(dragSession !== null, 'completeDragTo requires an active drag session');
+            assert(isDragSessionCoreOwned(dragSession), 'completeDragTo can only be called for core-owned drag sessions');
             uiMoveCompleteTo(internalState, target);
-            mutationSession.addMutation('runtime.interaction.dropTo', true);
+            mutationSession.addMutation('runtime.interaction.completeDragTo', true, dragSession);
             runtimeRunMutationPipeline(internalState);
         },
-        releaseTo(target) {
+        completeExtensionDrag(target) {
             const internalState = state();
             const mutationSession = internalState.mutation.getSession();
             const interaction = internalState.state.interaction;
             const dragSession = interaction.dragSession;
-            assert(dragSession !== null, 'releaseTo requires an active drag session');
-            assert(dragSession.type === 'release-targeting', 'releaseTo requires a release-targeting session');
-            uiMoveCompleteTo(internalState, target);
-            mutationSession.addMutation('runtime.interaction.releaseTo', true);
-            runtimeRunMutationPipeline(internalState);
+            assert(dragSession !== null, 'completeExtensionDrag requires an active drag session');
+            assert(!isDragSessionCoreOwned(dragSession), 'completeExtensionDrag can only be called for extension-owned drag sessions');
+            assert(dragSession.targetSquare === target, 'The target square in completeExtensionDrag must match the current target square of the drag session');
+            internalState.extensionSystem.completeDrag(dragSession);
+            internalState.state.interaction.setDragSession(null, mutationSession);
         },
         startReleaseTargetingDrag(source, target) {
             const internalState = state();
@@ -65,6 +67,7 @@ export function createRuntimeInteractionSurface(state) {
             assert(interaction.selected !== null, 'startReleaseTargetingDrag requires a selected piece');
             assert(interaction.selected.square === source, 'startReleaseTargetingDrag source must match selected square');
             const dragSession = {
+                owner: 'core',
                 type: 'release-targeting',
                 sourceSquare: source,
                 sourcePieceCode: interaction.selected.pieceCode,
@@ -93,6 +96,10 @@ export function createRuntimeInteractionSurface(state) {
             assert(currentDragSession !== null, 'No active drag session to update');
             internalState.state.interaction.updateDragSessionCurrentTarget(target, interactionMutationSession);
             runtimeRunMutationPipeline(internalState);
+        },
+        onEvent(context) {
+            const internalState = state();
+            internalState.extensionSystem.onEvent(context);
         }
     };
 }

package/dist/runtime/factory/main.js

@@ -10,6 +10,7 @@ import { createInteractionController } from '../input/controller/factory.js';
 import { runtimeDestroy, runtimeMount, runtimeUnmount } from '../lifecycle.js';
 import { createRuntimeMutationPipeline } from '../mutation/factory.js';
 import { runtimeRunMutationPipeline } from '../mutation/run.js';
+import { createExtensionRuntimeSurfaceEvents } from './events.js';
 import { createRuntimeInteractionSurface } from './input.js';
 function createRuntimeInternal(options) {
     const extensionSystem = createExtensionSystem(options);
@@ -30,7 +31,7 @@ function createRuntimeInternal(options) {
         })
     };
 }
-function createExtensionRuntimeSurfaceCommands(getInternalState) {
+function createExtensionRuntimeSurfaceCommandsInternalSurface(getInternalState) {
     return {
         setPosition(input) {
             const state = getInternalState();
@@ -103,6 +104,13 @@ function createExtensionRuntimeSurfaceCommands(getInternalState) {
             runtimeRunMutationPipeline(state);
             return changed;
         },
+        startDrag(session) {
+            const state = getInternalState();
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.interaction.setDragSession(session, mutationSession);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
         clearActiveInteraction() {
             const state = getInternalState();
             const mutationSession = state.mutation.getSession();
@@ -117,6 +125,36 @@ function createExtensionRuntimeSurfaceCommands(getInternalState) {
             runtimeRunMutationPipeline(state);
             return changed;
         },
+        resolveDeferredUIMoveRequest(details) {
+            const state = getInternalState();
+            const deferredRequest = state.state.change.deferredUIMoveRequest;
+            assert(deferredRequest, 'No deferred UI move request to resolve');
+            const { sourceSquare, destination } = deferredRequest;
+            const moveRequest = {
+                from: sourceSquare,
+                to: destination.to,
+                ...(destination.capturedSquare !== undefined && {
+                    capturedSquare: destination.capturedSquare
+                }),
+                ...(destination.secondary !== undefined && { secondary: destination.secondary }),
+                promotedTo: details.promotedTo
+            };
+            const mutationSession = state.mutation.getSession();
+            const move = state.state.board.move(moveRequest, mutationSession);
+            state.state.change.setDeferredUIMoveRequest(null, mutationSession);
+            mutationSession.addMutation('runtime.interaction.resolveDeferredUIMoveRequest', true);
+            runtimeRunMutationPipeline(state);
+            return move;
+        },
+        cancelDeferredUIMoveRequest() {
+            const state = getInternalState();
+            assert(state.state.change.deferredUIMoveRequest, 'No deferred UI move request to cancel');
+            const mutationSession = state.mutation.getSession();
+            const changed = state.state.change.setDeferredUIMoveRequest(null, mutationSession);
+            mutationSession.addMutation('runtime.interaction.cancelDeferredUIMoveRequest', changed);
+            runtimeRunMutationPipeline(state);
+            return changed;
+        },
         getSnapshot() {
             const state = getInternalState();
             return {
@@ -139,11 +177,13 @@ export function createRuntime(options) {
         return internalState;
     }
     // Create RuntimeExtensionSurface to pass to the extension system for initialization of extension instances
-    const extensionSurface = createExtensionRuntimeSurfaceCommands(getInternalState);
+    const extensionSurfaceCommands = createExtensionRuntimeSurfaceCommandsInternalSurface(getInternalState);
+    const extensionSurfaceEvents = createExtensionRuntimeSurfaceEvents(getInternalState);
     // Now construct the internal state
     const optionsInternal = {
         ...options,
-        extensionRuntimeSurfaceCommands: extensionSurface,
+        extensionRuntimeSurfaceCommands: extensionSurfaceCommands,
+        extensionRuntimeSurfaceEvents: extensionSurfaceEvents,
         getInternalState
     };
     internalState = createRuntimeInternal(optionsInternal);
@@ -174,7 +214,7 @@ export function createRuntime(options) {
             internalStatus = 'destroyed';
             internalState = null;
         },
-        ...extensionSurface,
+        ...extensionSurfaceCommands,
         getExtensionsPublicRecord() {
             return getInternalState().extensionSystem.getPublicRecord();
         }

package/dist/runtime/input/adapter/event.d.ts

@@ -0,0 +1,3 @@
+import { InputAdapterInternal } from './types.js';
+export declare function eventHandler(state: InputAdapterInternal, e: Event): void;
+export declare function eventDestroy(state: InputAdapterInternal): void;

package/dist/runtime/input/adapter/event.js

@@ -0,0 +1,19 @@
+import { ALL_SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events.js';
+import { pointerEventDestroy, pointerEventHandler } from './pointer.js';
+export function eventHandler(state, e) {
+    let context = null;
+    if (ALL_SCENE_POINTER_EVENT_TYPES.has(e.type)) {
+        context = pointerEventHandler(state, e);
+    }
+    if (!context) {
+        context = {
+            rawEvent: e,
+            sceneEvent: null
+        };
+    }
+    // Pass to controller for extension handling
+    state.controller.onEvent(context);
+}
+export function eventDestroy(state) {
+    pointerEventDestroy(state);
+}

package/dist/runtime/input/adapter/factory.js

@@ -1,55 +1,36 @@
-import { isPointerRelevantEvent, onPointerCancel, onPointerDown, onPointerLeave, onPointerMove, onPointerUp, releaseCapture } from './pointer.js';
+import assert from '@ktarmyshov/assert';
+import { eventDestroy, eventHandler } from './event.js';
+import { NEED_EVENT_TYPES } from './types.js';
 function createInputAdapterInternal(options) {
     return {
         container: options.container,
-        getGeometry: options.getGeometry,
+        getRenderGeometry: options.getRenderGeometry,
         controller: options.controller,
         activePointerId: null
     };
 }
 export function createInputAdapter(options) {
     const internalState = createInputAdapterInternal(options);
-    const onPointerDownHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerDown(internalState, e);
-    };
-    const onPointerMoveHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerMove(internalState, e);
-    };
-    const onPointerUpHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerUp(internalState, e);
-    };
-    const onPointerCancelHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerCancel(internalState, e);
-    };
-    const onPointerLeaveHandler = (e) => {
-        if (!isPointerRelevantEvent(e))
-            return;
-        onPointerLeave(internalState, e);
+    const onEventHander = (e) => {
+        eventHandler(internalState, e);
     };
     const inputAdapter = {
+        subscribeEvent(type) {
+            internalState.container.addEventListener(type, onEventHander);
+        },
+        unsubscribeEvent(type) {
+            assert(NEED_EVENT_TYPES.has(type), `Unsubscribe for event type ${type} is not supported. This is required event type for the board to function properly.`);
+            internalState.container.removeEventListener(type, onEventHander);
+        },
         destroy() {
-            if (internalState.activePointerId !== null) {
-                releaseCapture(internalState);
+            for (const type of NEED_EVENT_TYPES) {
+                internalState.container.removeEventListener(type, onEventHander);
             }
-            internalState.container.removeEventListener('pointerdown', onPointerDownHandler);
-            internalState.container.removeEventListener('pointermove', onPointerMoveHandler);
-            internalState.container.removeEventListener('pointerup', onPointerUpHandler);
-            internalState.container.removeEventListener('pointercancel', onPointerCancelHandler);
-            internalState.container.removeEventListener('pointerleave', onPointerLeaveHandler);
+            eventDestroy(internalState);
         }
     };
-    internalState.container.addEventListener('pointerdown', onPointerDownHandler);
-    internalState.container.addEventListener('pointermove', onPointerMoveHandler);
-    internalState.container.addEventListener('pointerup', onPointerUpHandler);
-    internalState.container.addEventListener('pointercancel', onPointerCancelHandler);
-    internalState.container.addEventListener('pointerleave', onPointerLeaveHandler);
+    for (const type of NEED_EVENT_TYPES) {
+        internalState.container.addEventListener(type, onEventHander);
+    }
     return inputAdapter;
 }

package/dist/runtime/input/adapter/helpers.d.ts

@@ -1,5 +1,3 @@
-import { ScenePoint } from '../../../extensions/types/basic/transient-visuals.js';
-import { RenderGeometry } from '../../../layout/geometry/types.js';
-import { Square } from '../../../state/board/types/internal.js';
-export declare function mapBoardPointToSquare(x: number, y: number, geometry: RenderGeometry): Square | null;
-export declare function clampBoardPoint(point: ScenePoint, geometry: RenderGeometry): ScenePoint;
+import { ScenePointerEvent } from '../../../extensions/types/basic/events.js';
+import { InputAdapterInternal } from './types.js';
+export declare function makeScenePointerEvent(state: InputAdapterInternal, e: PointerEvent): ScenePointerEvent;