@mirasen/chessboard 0.1.1 → 1.0.0-rc.0

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;

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

@@ -1,12 +1,67 @@
-export function mapBoardPointToSquare(x, y, geometry) {
+export function makeScenePointerEvent(state, e) {
+    const containerRect = state.container.getBoundingClientRect();
+    const sceneRect = makeSceneRectFromDOMRect(containerRect);
+    const point = toScenePoint(e, containerRect);
+    const clampedPoint = clampToSceneRect(point, sceneRect);
+    let clampedToBoardPoint = null;
+    let targetSquare = null;
+    const geometry = state.getRenderGeometry();
+    if (geometry) {
+        const sceneBoardRect = geometry.boardRect;
+        clampedToBoardPoint = clampToSceneRect(point, sceneBoardRect);
+        targetSquare = mapScenePointToSquare(point, geometry);
+    }
+    return {
+        // DOM part
+        type: e.type,
+        // scene part
+        point,
+        clampedPoint,
+        boardClampedPoint: clampedToBoardPoint,
+        // board part
+        targetSquare
+    };
+}
+function toScenePoint(e, inRect) {
+    return {
+        x: e.clientX - inRect.x,
+        y: e.clientY - inRect.y
+    };
+}
+function makeSceneRectFromDOMRect(domRect) {
+    return {
+        x: 0,
+        y: 0,
+        width: domRect.width,
+        height: domRect.height
+    };
+}
+function clampToSceneRect(point, boundRect) {
+    // X cannot go below boundRect.x, cannot go above boundRect.x + boundRect.width
+    // Y cannot go below boundRect.y, cannot go above boundRect.y + boundRect.height
+    return {
+        x: Math.max(boundRect.x, Math.min(point.x, boundRect.x + boundRect.width)),
+        y: Math.max(boundRect.y, Math.min(point.y, boundRect.y + boundRect.height))
+    };
+}
+function mapScenePointToSquare(point, geometry) {
+    const { x, y } = point;
     if (!Number.isFinite(x) || !Number.isFinite(y))
         return null;
-    const { boardSize, squareSize, orientation } = geometry;
-    if (x < 0 || x >= boardSize || y < 0 || y >= boardSize)
+    const orientation = geometry.orientation;
+    const boardRect = geometry.boardRect;
+    const boardSize = boardRect.width;
+    const squareSize = geometry.squareSize;
+    if (x < boardRect.x ||
+        x >= boardRect.x + boardSize ||
+        y < boardRect.y ||
+        y >= boardRect.y + boardSize)
         return null;
     // Grid cell indices, each in [0, 7].
-    const xIndex = Math.floor(x / squareSize);
-    const yIndex = Math.floor(y / squareSize);
+    const xIndex = Math.floor((x - boardRect.x) / squareSize);
+    const yIndex = Math.floor((y - boardRect.y) / squareSize);
+    if (xIndex < 0 || xIndex > 7 || yIndex < 0 || yIndex > 7)
+        return null;
     // Invert the orientation mapping used by geometry.squareRect:
     //   white: xIndex = file,     yIndex = 7 - rank  →  file = xIndex,     rank = 7 - yIndex
     //   black: xIndex = 7 - file, yIndex = rank       →  file = 7 - xIndex, rank = yIndex
@@ -14,10 +69,3 @@ export function mapBoardPointToSquare(x, y, geometry) {
     const rank = orientation === 0 /* ColorCode.White */ ? 7 - yIndex : yIndex;
     return (rank * 8 + file);
 }
-export function clampBoardPoint(point, geometry) {
-    const { boardSize } = geometry;
-    return {
-        x: Math.min(Math.max(point.x, 0), boardSize),
-        y: Math.min(Math.max(point.y, 0), boardSize)
-    };
-}

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

@@ -1,13 +1,9 @@
-import { ScenePointerEventType } from '../../../extensions/types/basic/events.js';
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
 import { InputAdapterInternal } from './types.js';
-export type PointerRelevantEvent = PointerEvent & {
-    type: ScenePointerEventType;
-};
-export declare function isPointerRelevantEvent(e: PointerEvent): e is PointerRelevantEvent;
+export declare function pointerEventHandler(state: InputAdapterInternal, e: PointerEvent): ExtensionOnEventContext;
 /** Release capture for the currently tracked pointer and clear tracking state. */
 export declare function releaseCapture(state: InputAdapterInternal): void;
-export declare function onPointerDown(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerMove(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerUp(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerCancel(state: InputAdapterInternal, e: PointerRelevantEvent): void;
-export declare function onPointerLeave(state: InputAdapterInternal, e: PointerRelevantEvent): void;
+export declare function adapterOnPointerDown(state: InputAdapterInternal, e: PointerEvent): void;
+export declare function adapterOnPointerUp(state: InputAdapterInternal, e: PointerEvent): void;
+export declare function adapterOnPointerCancel(state: InputAdapterInternal, e: PointerEvent): void;
+export declare function pointerEventDestroy(state: InputAdapterInternal): void;

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

@@ -1,9 +1,30 @@
 import assert from '@ktarmyshov/assert';
-import { SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events.js';
-import { clampBoardPoint, mapBoardPointToSquare } from './helpers.js';
-const validPointerEventTypes = new Set(SCENE_POINTER_EVENT_TYPES);
-export function isPointerRelevantEvent(e) {
-    return e instanceof PointerEvent && validPointerEventTypes.has(e.type);
+import { ALL_SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events.js';
+import { makeScenePointerEvent } from './helpers.js';
+export function pointerEventHandler(state, e) {
+    assert(ALL_SCENE_POINTER_EVENT_TYPES.has(e.type), `Unexpected pointer event type: ${e.type}`);
+    // First convert to scene event for controller
+    const sceneEvent = makeScenePointerEvent(state, e);
+    // Then handle pointer event within the adapter logic (e.g. tracking active pointer, capturing, etc.)
+    pointerEventAdapterHandler(state, e);
+    // Then create context and pass to controller for extension handling
+    return {
+        rawEvent: e,
+        sceneEvent
+    };
+}
+function pointerEventAdapterHandler(state, e) {
+    switch (e.type) {
+        case 'pointerdown':
+            adapterOnPointerDown(state, e);
+            break;
+        case 'pointerup':
+            adapterOnPointerUp(state, e);
+            break;
+        case 'pointercancel':
+            adapterOnPointerCancel(state, e);
+            break;
+    }
 }
 /** Release capture for the currently tracked pointer and clear tracking state. */
 export function releaseCapture(state) {
@@ -14,84 +35,30 @@ export function releaseCapture(state) {
     }
     state.activePointerId = null;
 }
-function resolvePointerTarget(state, e) {
-    const geometry = state.getGeometry();
-    if (!geometry)
-        return { target: null, rawPoint: null, clampedPoint: null };
-    const rect = state.container.getBoundingClientRect();
-    const x = e.clientX - rect.left;
-    const y = e.clientY - rect.top;
-    const target = mapBoardPointToSquare(x, y, geometry);
-    const point = { x, y };
-    return { target, rawPoint: point, clampedPoint: clampBoardPoint(point, geometry) };
-}
-function makeBoardPointerEvent(e, pointerTarget) {
-    assert(e.defaultPrevented === false, 'Expected event to be unhandled before making BoardPointerEvent');
-    let defaultPrevented = false;
-    return {
-        type: e.type,
-        // DOM part
-        pointerId: e.pointerId,
-        isPrimary: e.isPrimary,
-        button: e.button,
-        buttons: e.buttons,
-        ctrlKey: e.ctrlKey,
-        altKey: e.altKey,
-        shiftKey: e.shiftKey,
-        metaKey: e.metaKey,
-        // Board part
-        rawPoint: pointerTarget.rawPoint,
-        clampedPoint: pointerTarget.clampedPoint,
-        target: pointerTarget.target,
-        // Mechanics
-        get defaultPrevented() {
-            return defaultPrevented;
-        },
-        preventDefault() {
-            defaultPrevented = true;
-        }
-    };
-}
-export function onPointerDown(state, e) {
+export function adapterOnPointerDown(state, e) {
+    assert(e.type === 'pointerdown', `Expected pointerdown event, got ${e.type}`);
     if (!e.isPrimary)
         return; // ignore non-primary pointers
     if (state.activePointerId !== null)
         return; // already tracking
     state.activePointerId = e.pointerId;
     state.container.setPointerCapture(e.pointerId);
-    const pointerTarget = resolvePointerTarget(state, e);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    e.preventDefault(); // prevent native text selection during drag
-    state.controller.onEvent(boardEvent);
 }
-export function onPointerMove(state, e) {
+export function adapterOnPointerUp(state, e) {
+    assert(e.type === 'pointerup', `Expected pointerup event, got ${e.type}`);
     if (e.pointerId !== state.activePointerId)
         return;
-    const pointerTarget = resolvePointerTarget(state, e);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    e.preventDefault(); // prevent native text selection during drag
-    state.controller.onEvent(boardEvent);
-}
-export function onPointerUp(state, e) {
-    if (e.pointerId !== state.activePointerId)
-        return;
-    const pointerTarget = resolvePointerTarget(state, e); // resolve before releasing capture
     releaseCapture(state);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    state.controller.onEvent(boardEvent);
 }
-export function onPointerCancel(state, e) {
+export function adapterOnPointerCancel(state, e) {
+    assert(e.type === 'pointercancel', `Expected pointercancel event, got ${e.type}`);
     if (e.pointerId !== state.activePointerId)
         return;
-    const pointerTarget = resolvePointerTarget(state, e); // resolve before releasing capture
     releaseCapture(state);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    state.controller.onEvent(boardEvent);
 }
-export function onPointerLeave(state, e) {
-    if (e.pointerId !== state.activePointerId)
-        return;
-    const pointerTarget = resolvePointerTarget(state, e);
-    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
-    state.controller.onEvent(boardEvent);
+export function pointerEventDestroy(state) {
+    if (state.activePointerId !== null) {
+        releaseCapture(state);
+    }
+    state.activePointerId = null;
 }

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

@@ -1,16 +1,19 @@
-import { RenderGeometry } from '../../../layout/geometry/types.js';
+import { SceneRenderGeometry } from '../../../layout/geometry/types.js';
 import { InteractionController } from '../controller/types.js';
 export interface InputAdapterInitOptions {
     container: HTMLElement;
-    getGeometry: () => RenderGeometry | null;
+    getRenderGeometry: () => SceneRenderGeometry | null;
     controller: InteractionController;
 }
 export interface InputAdapterInternal {
     readonly container: HTMLElement;
-    readonly getGeometry: () => RenderGeometry | null;
+    readonly getRenderGeometry: () => SceneRenderGeometry | null;
     readonly controller: InteractionController;
     activePointerId: number | null;
 }
 export interface InputAdapter {
+    subscribeEvent<K extends keyof HTMLElementEventMap>(type: K): void;
+    unsubscribeEvent<K extends keyof HTMLElementEventMap>(type: K): void;
     destroy(): void;
 }
+export declare const NEED_EVENT_TYPES: Set<string>;

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

@@ -1 +1,6 @@
-export {};
+export const NEED_EVENT_TYPES = new Set([
+    'pointerdown',
+    'pointermove',
+    'pointerup',
+    'pointercancel'
+]);

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

@@ -1,4 +1,4 @@
-import { handlePointerCancel, handlePointerDown, handlePointerLeave, handlePointerMove, handlePointerUp } from './pointer.js';
+import { handlePointerCancel, handlePointerDown, handlePointerMove, handlePointerUp } from './pointer.js';
 import { transmitTransientInput } from './transient-visuals.js';
 function createInteractionControllerInternal(options) {
     return {
@@ -8,25 +8,26 @@ function createInteractionControllerInternal(options) {
 export function createInteractionController(options) {
     const internalState = createInteractionControllerInternal(options);
     return {
-        onEvent(event) {
-            switch (event.type) {
+        onEvent(context) {
+            internalState.surface.onEvent(context);
+            if (context.rawEvent.defaultPrevented) {
+                return; // The event has been handled by the surface (extensions)
+            }
+            switch (context.rawEvent.type) {
                 case 'pointerdown':
-                    handlePointerDown(internalState, event);
+                    handlePointerDown(internalState, context);
                     break;
                 case 'pointermove':
-                    handlePointerMove(internalState, event);
+                    handlePointerMove(internalState, context);
                     break;
                 case 'pointerup':
-                    handlePointerUp(internalState, event);
+                    handlePointerUp(internalState, context);
                     break;
                 case 'pointercancel':
-                    handlePointerCancel(internalState, event);
-                    break;
-                case 'pointerleave':
-                    handlePointerLeave(internalState, event);
+                    handlePointerCancel(internalState, context);
                     break;
             }
-            transmitTransientInput(internalState, event);
+            transmitTransientInput(internalState, context);
         }
     };
 }

package/dist/runtime/input/controller/pointer.d.ts

@@ -1,7 +1,6 @@
-import { ScenePointerEvent } from '../../../extensions/types/basic/events.js';
+import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
 import { InteractionControllerInternal } from './types.js';
-export declare function handlePointerDown(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerMove(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerUp(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerCancel(state: InteractionControllerInternal, event: ScenePointerEvent): void;
-export declare function handlePointerLeave(state: InteractionControllerInternal, event: ScenePointerEvent): void;
+export declare function handlePointerDown(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+export declare function handlePointerMove(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+export declare function handlePointerUp(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+export declare function handlePointerCancel(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;