@mirasen/chessboard 1.1.5 → 1.2.0

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

@@ -1,6 +1,6 @@
-import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
+import { InteractionControllerOnEventContext } from '../controller/types.js';
 import { InputAdapterInternal } from './types.js';
-export declare function pointerEventHandler(state: InputAdapterInternal, e: PointerEvent): ExtensionOnEventContext;
+export declare function pointerEventHandler(state: InputAdapterInternal, e: PointerEvent): InteractionControllerOnEventContext;
 /** Release capture for the currently tracked pointer and clear tracking state. */
 export declare function releaseCapture(state: InputAdapterInternal): void;
 export declare function adapterOnPointerDown(state: InputAdapterInternal, e: PointerEvent): void;

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

@@ -1,2 +1,2 @@
-import { InteractionController, InteractionControllerInitOptions } from './types.js';
+import type { InteractionController, InteractionControllerInitOptions } from './types.js';
 export declare function createInteractionController(options: InteractionControllerInitOptions): InteractionController;

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

@@ -1,4 +1,4 @@
-import { handlePointerCancel, handlePointerDown, handlePointerMove, handlePointerUp } from './pointer.js';
+import { determineRuntimeInteractionAction } from './interaction.js';
 import { transmitTransientInput } from './transient-visuals.js';
 function createInteractionControllerInternal(options) {
     return {
@@ -9,24 +9,44 @@ export function createInteractionController(options) {
     const internalState = createInteractionControllerInternal(options);
     return {
         onEvent(context) {
-            internalState.surface.onEvent(context);
+            const action = determineRuntimeInteractionAction(internalState, context);
+            const extensionContext = {
+                ...context,
+                runtimeInteractionActionPreview: action
+            };
+            internalState.surface.onEvent(extensionContext);
             if (context.rawEvent.defaultPrevented) {
                 transmitTransientInput(internalState, context);
                 return; // The event has been handled by the surface (extensions)
             }
-            switch (context.rawEvent.type) {
-                case 'pointerdown':
-                    handlePointerDown(internalState, context);
-                    break;
-                case 'pointermove':
-                    handlePointerMove(internalState, context);
-                    break;
-                case 'pointerup':
-                    handlePointerUp(internalState, context);
-                    break;
-                case 'pointercancel':
-                    handlePointerCancel(internalState, context);
-                    break;
+            if (action) {
+                switch (action.type) {
+                    case 'startLiftedDrag':
+                        internalState.surface.startLiftedDrag(action.source, action.target);
+                        break;
+                    case 'startReleaseTargetingDrag':
+                        internalState.surface.startReleaseTargetingDrag(action.source, action.target);
+                        break;
+                    case 'completeCoreDragTo':
+                        internalState.surface.completeCoreDragTo(action.target);
+                        break;
+                    case 'completeExtensionDrag':
+                        internalState.surface.completeExtensionDrag(action.target);
+                        break;
+                    case 'updateDragSessionCurrentTarget':
+                        internalState.surface.updateDragSessionCurrentTarget(action.target);
+                        break;
+                    case 'cancelActiveInteraction':
+                        internalState.surface.cancelActiveInteraction();
+                        break;
+                    case 'cancelInteraction':
+                        internalState.surface.cancelInteraction();
+                        break;
+                    default:
+                        throw new Error(
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        `Unhandled RuntimeInteractionAction type: ${String(action.type)}`);
+                }
             }
             transmitTransientInput(internalState, context);
         }

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

@@ -1,3 +1,3 @@
 import type { Square } from '../../../state/board/types/internal.js';
-import { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
+import type { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
 export declare function canMoveTo(snapshot: InteractionStateSnapshot, target: Square): boolean;

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

@@ -0,0 +1,3 @@
+import type { RuntimeInteractionAction } from '../../../extensions/types/basic/events.js';
+import type { InteractionControllerInternal, InteractionControllerOnEventContext } from './types.js';
+export declare function determineRuntimeInteractionAction(state: InteractionControllerInternal, context: InteractionControllerOnEventContext): RuntimeInteractionAction | null;

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

@@ -0,0 +1,14 @@
+import { determineActionPointerCancel, determineActionPointerDown, determineActionPointerMove, determineActionPointerUp } from './pointer.js';
+export function determineRuntimeInteractionAction(state, context) {
+    switch (context.rawEvent.type) {
+        case 'pointerdown':
+            return determineActionPointerDown(state, context);
+        case 'pointermove':
+            return determineActionPointerMove(state, context);
+        case 'pointerup':
+            return determineActionPointerUp(state, context);
+        case 'pointercancel':
+            return determineActionPointerCancel(state, context);
+    }
+    return null;
+}

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

@@ -1,6 +1,6 @@
-import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
-import { InteractionControllerInternal } from './types.js';
-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;
+import type { RuntimeInteractionAction } from '../../../extensions/types/basic/events.js';
+import type { InteractionControllerInternal, InteractionControllerOnEventContext } from './types.js';
+export declare function determineActionPointerDown(state: InteractionControllerInternal, context: InteractionControllerOnEventContext): RuntimeInteractionAction | null;
+export declare function determineActionPointerMove(state: InteractionControllerInternal, context: InteractionControllerOnEventContext): RuntimeInteractionAction | null;
+export declare function determineActionPointerUp(state: InteractionControllerInternal, context: InteractionControllerOnEventContext): RuntimeInteractionAction | null;
+export declare function determineActionPointerCancel(state: InteractionControllerInternal, context: InteractionControllerOnEventContext): RuntimeInteractionAction | null;

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

@@ -3,19 +3,19 @@ import { isEmptyPieceCode, isNonEmptyPieceCode } from '../../../state/board/chec
 import { fromPieceCode } from '../../../state/board/piece.js';
 import { isDragSessionCoreOwned } from '../../../state/interaction/helpers.js';
 import { canMoveTo } from './helpers.js';
-export function handlePointerDown(state, context) {
-    assert(context.rawEvent.type === 'pointerdown', 'handlePointerDown should only be called for pointerdown events');
+export function determineActionPointerDown(state, context) {
+    assert(context.rawEvent.type === 'pointerdown', 'determineActionPointerDown should only be called for pointerdown events');
     const rawEvent = context.rawEvent;
     if (rawEvent.button !== 0) {
         // Only handle left-click for now
-        return;
+        return null;
     }
     const sceneEvent = context.sceneEvent;
     assert(sceneEvent, 'Scene event should be present for pointer events');
     const interaction = state.surface.getInteractionStateSnapshot();
     if (interaction.dragSession) {
         // Ignore pointer down events if there's already an active drag session
-        return;
+        return null;
     }
     if (sceneEvent.targetSquare !== null) {
         /**
@@ -28,16 +28,22 @@ export function handlePointerDown(state, context) {
             assert(isNonEmptyPieceCode(selectedPieceCode), 'Selected piece code must be non-zero');
             const targetPieceCode = state.surface.getPieceCodeAt(sceneEvent.targetSquare);
             if (isEmptyPieceCode(targetPieceCode)) {
-                state.surface.startReleaseTargetingDrag(interaction.selected.square, sceneEvent.targetSquare);
-                return;
+                return {
+                    type: 'startReleaseTargetingDrag',
+                    source: interaction.selected.square,
+                    target: sceneEvent.targetSquare
+                };
             }
             const isLegalMoveTarget = interaction.movability.mode === 1 /* MovabilityModeCode.Free */ ||
                 (interaction.movability.mode === 2 /* MovabilityModeCode.Strict */ &&
                     interaction.activeDestinations.has(sceneEvent.targetSquare));
             if (fromPieceCode(targetPieceCode).color !== fromPieceCode(selectedPieceCode).color &&
                 isLegalMoveTarget) {
-                state.surface.startReleaseTargetingDrag(interaction.selected.square, sceneEvent.targetSquare);
-                return;
+                return {
+                    type: 'startReleaseTargetingDrag',
+                    source: interaction.selected.square,
+                    target: sceneEvent.targetSquare
+                };
             }
         }
         /**
@@ -46,60 +52,80 @@ export function handlePointerDown(state, context) {
          */
         const pieceCode = state.surface.getPieceCodeAt(sceneEvent.targetSquare);
         if (!isEmptyPieceCode(pieceCode)) {
-            state.surface.startLiftedDrag(sceneEvent.targetSquare, sceneEvent.targetSquare);
+            return {
+                type: 'startLiftedDrag',
+                source: sceneEvent.targetSquare,
+                target: sceneEvent.targetSquare
+            };
         }
     }
+    return null;
 }
-export function handlePointerMove(state, context) {
-    assert(context.rawEvent.type === 'pointermove', 'handlePointerMove should only be called for pointermove events');
+export function determineActionPointerMove(state, context) {
+    assert(context.rawEvent.type === 'pointermove', 'determineActionPointerMove should only be called for pointermove events');
     const interaction = state.surface.getInteractionStateSnapshot();
     if (interaction.dragSession) {
-        state.surface.updateDragSessionCurrentTarget(context.sceneEvent?.targetSquare ?? null);
+        return {
+            type: 'updateDragSessionCurrentTarget',
+            target: context.sceneEvent?.targetSquare ?? null
+        };
     }
+    return null;
 }
-export function handlePointerUp(state, context) {
-    assert(context.rawEvent.type === 'pointerup', 'handlePointerUp should only be called for pointerup events');
+export function determineActionPointerUp(state, context) {
+    assert(context.rawEvent.type === 'pointerup', 'determineActionPointerUp should only be called for pointerup events');
     const interaction = state.surface.getInteractionStateSnapshot();
     const dragSession = interaction.dragSession;
     if (!dragSession) {
         // No active drag session, so nothing to do on pointer up
-        return;
+        return null;
     }
     const sceneEvent = context.sceneEvent;
     assert(sceneEvent, 'Scene event should be present for pointer events');
     if (!isDragSessionCoreOwned(dragSession)) {
         // For extension-owned drag sessions, we simply end the session without attempting to make a move,
         // since the runtime doesn't have enough information about the semantics of the drag session.
-        state.surface.completeExtensionDrag(sceneEvent.targetSquare);
-        return;
+        return {
+            type: 'completeExtensionDrag',
+            target: sceneEvent.targetSquare
+        };
     }
     // Check if the square is the same as the source square of the drag session.
     // If it is, then we can end the drag session without making a move.
     if (sceneEvent.targetSquare === dragSession.sourceSquare) {
-        state.surface.cancelActiveInteraction();
-        return;
+        return {
+            type: 'cancelActiveInteraction'
+        };
     }
     // Check if the target square is a valid destination for the selected piece.
     if (sceneEvent.targetSquare !== null && canMoveTo(interaction, sceneEvent.targetSquare)) {
-        state.surface.completeCoreDragTo(sceneEvent.targetSquare);
-        return;
+        return {
+            type: 'completeCoreDragTo',
+            target: sceneEvent.targetSquare
+        };
     }
     // Invalid target: piece returns to source for lifted drag (selection preserved),
     // or selection is cleared for release targeting.
     if (dragSession.type === 'lifted-piece-drag') {
-        state.surface.cancelActiveInteraction();
+        return {
+            type: 'cancelActiveInteraction'
+        };
     }
     else {
-        state.surface.cancelInteraction();
+        return {
+            type: 'cancelInteraction'
+        };
     }
 }
-export function handlePointerCancel(state, context) {
-    assert(context.rawEvent.type === 'pointercancel', 'handlePointerCancel should only be called for pointercancel events');
+export function determineActionPointerCancel(state, context) {
+    assert(context.rawEvent.type === 'pointercancel', 'determineActionPointerCancel should only be called for pointercancel events');
     const interaction = state.surface.getInteractionStateSnapshot();
     if (!interaction.dragSession) {
         // No active drag session, so nothing to do on pointer cancel
-        return;
+        return null;
     }
     // Cancel the active interaction on pointer cancel
-    state.surface.cancelActiveInteraction();
+    return {
+        type: 'cancelActiveInteraction'
+    };
 }

package/dist/runtime/input/controller/transient-visuals.d.ts

@@ -1,3 +1,2 @@
-import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
-import { InteractionControllerInternal } from './types.js';
-export declare function transmitTransientInput(state: InteractionControllerInternal, context: ExtensionOnEventContext): void;
+import type { InteractionControllerInternal, InteractionControllerOnEventContext } from './types.js';
+export declare function transmitTransientInput(state: InteractionControllerInternal, context: InteractionControllerOnEventContext): void;

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

@@ -1,7 +1,7 @@
-import { TransientInput } from '../../../extensions/types/basic/transient-visuals.js';
-import { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
-import { PieceCode, Square } from '../../../state/board/types/internal.js';
-import { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
+import type { TransientInput } from '../../../extensions/types/basic/transient-visuals.js';
+import type { ExtensionOnEventContext } from '../../../extensions/types/context/events.js';
+import type { PieceCode, Square } from '../../../state/board/types/internal.js';
+import type { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
 export interface RuntimeInteractionSurface {
     getInteractionStateSnapshot(): InteractionStateSnapshot;
     getPieceCodeAt(square: Square): PieceCode;
@@ -21,6 +21,7 @@ export interface InteractionControllerInternal {
 export interface InteractionControllerInitOptions {
     surface: RuntimeInteractionSurface;
 }
+export type InteractionControllerOnEventContext = Omit<ExtensionOnEventContext, 'runtimeInteractionActionPreview'>;
 export interface InteractionController {
-    onEvent(context: ExtensionOnEventContext): void;
+    onEvent(context: InteractionControllerOnEventContext): void;
 }

package/dist/runtime/types/main.d.ts

@@ -14,7 +14,7 @@ export interface RuntimeInternal extends RuntimeMutationPipelineContext {
 }
 export type GetInternalState = () => RuntimeInternal;
 export interface RuntimeInitOptions {
-    doc: Document;
+    element: HTMLElement;
     state?: RuntimeStateInitOptions;
     extensions?: readonly AnyExtensionDefinition[];
 }

package/dist/wrapper/factory.js

@@ -19,18 +19,13 @@ export function createBoard(options) {
         // assume it's already a definition
         return ext;
     });
-    const doc = 'document' in options && options.document ? options.document : options.element.ownerDocument;
     const runtime = createRuntime({
-        doc,
+        element: options.element,
         state: options.state,
         extensions
     });
-    if ('element' in options && options.element) {
-        runtime.mount(options.element);
-    }
+    runtime.mount(options.element);
     return {
-        mount: runtime.mount,
-        unmount: runtime.unmount,
         destroy: runtime.destroy,
         setPosition: runtime.setPosition,
         setPiecePosition: runtime.setPiecePosition,

package/dist/wrapper/types.d.ts

@@ -43,23 +43,15 @@ export type ChessboardExtensionsPublicMap<TExtensions extends readonly Chessboar
 /**
  * Public createBoard options
  */
-interface ChessboardInitOptionsDocument {
-    readonly document: Document;
-    readonly element?: never;
-}
-interface ChessboardInitOptionsElement {
-    readonly element: HTMLElement;
-    readonly document?: never;
-}
-type ChessboardInitTarget = ChessboardInitOptionsDocument | ChessboardInitOptionsElement;
-export type ChessboardInitOptions<TExtensions extends readonly ChessboardExtensionInput[] = DefaultBuiltinChessboardExtensions> = ChessboardInitTarget & {
+export type ChessboardInitOptions<TExtensions extends readonly ChessboardExtensionInput[] = DefaultBuiltinChessboardExtensions> = {
+    element: HTMLElement;
     readonly state?: RuntimeStateInitOptions;
     readonly extensions?: TExtensions;
 };
 /**
  * Public board interface returned by createBoard(...)
  */
-export type ChessboardRuntimeSurface = Pick<Runtime, 'mount' | 'unmount' | 'destroy' | 'move' | 'setPosition' | 'setPiecePosition' | 'setTurn' | 'setOrientation' | 'setMovability' | 'select' | 'getSnapshot'>;
+export type ChessboardRuntimeSurface = Pick<Runtime, 'destroy' | 'move' | 'setPosition' | 'setPiecePosition' | 'setTurn' | 'setOrientation' | 'setMovability' | 'select' | 'getSnapshot'>;
 export interface Chessboard<TExtensions extends readonly ChessboardExtensionInput[] = DefaultBuiltinChessboardExtensions> extends ChessboardRuntimeSurface {
     readonly extensions: ChessboardExtensionsPublicMap<TExtensions>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mirasen/chessboard",
 	"description": "Framework-agnostic TypeScript chessboard platform with real chess interaction built in.",
-	"version": "1.1.5",
+	"version": "1.2.0",
 	"license": "MIT",
 	"author": {
 		"name": "Mirasen",
@@ -54,7 +54,6 @@
 	"scripts": {
 		"build": "rimraf ./dist && tsc --project tsconfig.json && npm run prepack",
 		"build:release": "rimraf ./dist && tsc --project tsconfig-release.json && npm run prepack",
-		"prepare": "bash ./scripts/npm-link.sh",
 		"prepack": "publint",
 		"format": "prettier --write .",
 		"lint": "prettier --check . && eslint .",
@@ -92,7 +91,6 @@
 		"publint": "^0.3.11",
 		"rimraf": "^6.0.1",
 		"serve": "^14.2.6",
-		"tsc-alias": "^1.8.15",
 		"typescript": "^5.8.2",
 		"typescript-eslint": "^8.57.0",
 		"vitest": "^4.0.18"