@mirasen/chessboard 1.2.3 → 1.3.0

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

@@ -1,8 +1,8 @@
 import assert from '@ktarmyshov/assert';
 import { isEmptyPieceCode, isNonEmptyPieceCode } from '../../../state/board/check.js';
 import { fromPieceCode } from '../../../state/board/piece.js';
-import { isDragSessionCoreOwned } from '../../../state/interaction/helpers.js';
-import { canMoveTo } from './helpers.js';
+import { isDragSessionActiveLiftedPiece, isDragSessionCoreOwned, isDragSessionPendingLiftedPiece, isDragSessionReleaseTargeting } from '../../../state/interaction/helpers.js';
+import { buttonToButtonsMask, canMoveTo, isMovementBeyondThreshold } from './helpers.js';
 export function determineActionPointerDown(state, context) {
     assert(context.rawEvent.type === 'pointerdown', 'determineActionPointerDown should only be called for pointerdown events');
     const rawEvent = context.rawEvent;
@@ -29,9 +29,10 @@ export function determineActionPointerDown(state, context) {
             const targetPieceCode = state.surface.getPieceCodeAt(sceneEvent.targetSquare);
             if (isEmptyPieceCode(targetPieceCode)) {
                 return {
-                    type: 'startReleaseTargetingDrag',
-                    source: interaction.selected.square,
-                    target: sceneEvent.targetSquare
+                    type: 'startReleaseTargetingDragSession',
+                    sourceSquare: interaction.selected.square,
+                    targetSquare: sceneEvent.targetSquare,
+                    startButton: rawEvent.button
                 };
             }
             const isLegalMoveTarget = interaction.movability.mode === 1 /* MovabilityModeCode.Free */ ||
@@ -40,9 +41,10 @@ export function determineActionPointerDown(state, context) {
             if (fromPieceCode(targetPieceCode).color !== fromPieceCode(selectedPieceCode).color &&
                 isLegalMoveTarget) {
                 return {
-                    type: 'startReleaseTargetingDrag',
-                    source: interaction.selected.square,
-                    target: sceneEvent.targetSquare
+                    type: 'startReleaseTargetingDragSession',
+                    sourceSquare: interaction.selected.square,
+                    targetSquare: sceneEvent.targetSquare,
+                    startButton: rawEvent.button
                 };
             }
         }
@@ -52,10 +54,24 @@ export function determineActionPointerDown(state, context) {
          */
         const pieceCode = state.surface.getPieceCodeAt(sceneEvent.targetSquare);
         if (!isEmptyPieceCode(pieceCode)) {
+            const thresholdPx = interaction.config.drag.liftedActivation.thresholdPx;
+            if (thresholdPx > 0) {
+                return {
+                    type: 'startLiftedDragSession',
+                    phase: 'pending',
+                    sourceSquare: sceneEvent.targetSquare,
+                    targetSquare: sceneEvent.targetSquare,
+                    startButton: rawEvent.button,
+                    startPoint: sceneEvent.point,
+                    thresholdPx
+                };
+            }
             return {
-                type: 'startLiftedDrag',
-                source: sceneEvent.targetSquare,
-                target: sceneEvent.targetSquare
+                type: 'startLiftedDragSession',
+                phase: 'active',
+                sourceSquare: sceneEvent.targetSquare,
+                targetSquare: sceneEvent.targetSquare,
+                startButton: rawEvent.button
             };
         }
     }
@@ -64,67 +80,65 @@ export function determineActionPointerDown(state, context) {
 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) {
-        return {
-            type: 'updateDragSessionCurrentTarget',
-            target: context.sceneEvent?.targetSquare ?? null
-        };
+    const dragSession = interaction.dragSession;
+    if (!dragSession) {
+        return null;
     }
-    return null;
+    const sceneEvent = context.sceneEvent;
+    assert(sceneEvent, 'pointermove requires a scene event');
+    if (isDragSessionPendingLiftedPiece(dragSession)) {
+        if (isMovementBeyondThreshold(dragSession.startPoint, sceneEvent.point, dragSession.thresholdPx)) {
+            return {
+                type: 'activatePendingLiftedDragSession',
+                targetSquare: sceneEvent.targetSquare
+            };
+        }
+        return { type: 'updateDragSessionCurrentTarget', targetSquare: sceneEvent.targetSquare };
+    }
+    return {
+        type: 'updateDragSessionCurrentTarget',
+        targetSquare: sceneEvent.targetSquare
+    };
 }
-export function determineActionPointerUp(state, context) {
-    assert(context.rawEvent.type === 'pointerup', 'determineActionPointerUp should only be called for pointerup events');
+function determineActionTerminalRelease(state, context) {
     const interaction = state.surface.getInteractionStateSnapshot();
     const dragSession = interaction.dragSession;
     if (!dragSession) {
-        // No active drag session, so nothing to do on pointer up
         return null;
     }
     const sceneEvent = context.sceneEvent;
-    assert(sceneEvent, 'Scene event should be present for pointer events');
+    assert(sceneEvent, 'Scene event should be present for terminal release');
     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.
         return {
-            type: 'completeExtensionDrag',
-            target: sceneEvent.targetSquare
+            type: 'completeExtensionDragSession',
+            targetSquare: 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) {
-        return {
-            type: 'cancelActiveInteraction'
-        };
+        return { type: 'cancelActiveInteraction' };
     }
-    // Check if the target square is a valid destination for the selected piece.
-    if (sceneEvent.targetSquare !== null && canMoveTo(interaction, sceneEvent.targetSquare)) {
-        return {
-            type: 'completeCoreDragTo',
-            target: sceneEvent.targetSquare
-        };
+    if (sceneEvent.targetSquare !== null &&
+        canMoveTo(interaction, sceneEvent.targetSquare) &&
+        (isDragSessionActiveLiftedPiece(dragSession) || isDragSessionReleaseTargeting(dragSession))) {
+        return { type: 'completeCoreDragSessionTo', targetSquare: 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') {
-        return {
-            type: 'cancelActiveInteraction'
-        };
+        return { type: 'cancelActiveInteraction' };
     }
     else {
-        return {
-            type: 'cancelInteraction'
-        };
+        return { type: 'cancelInteraction' };
     }
 }
+export function determineActionPointerUp(state, context) {
+    assert(context.rawEvent.type === 'pointerup', 'determineActionPointerUp should only be called for pointerup events');
+    return determineActionTerminalRelease(state, context);
+}
 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 null;
     }
-    // Cancel the active interaction on pointer cancel
     return {
         type: 'cancelActiveInteraction'
     };
@@ -132,12 +146,17 @@ export function determineActionPointerCancel(state, context) {
 export function determineActionLostPointerCapture(state, context) {
     assert(context.rawEvent.type === 'lostpointercapture', 'determineActionLostPointerCapture should only be called for lostpointercapture events');
     const interaction = state.surface.getInteractionStateSnapshot();
-    if (!interaction.dragSession) {
-        // No active drag session, so nothing to do on lost pointer capture
+    const dragSession = interaction.dragSession;
+    if (!dragSession) {
         return null;
     }
-    // Cancel the active interaction on lost pointer capture
-    return {
-        type: 'cancelActiveInteraction'
-    };
+    const rawEvent = context.rawEvent;
+    const mask = buttonToButtonsMask(dragSession.startButton);
+    if (mask === null) {
+        return { type: 'cancelActiveInteraction' };
+    }
+    if ((rawEvent.buttons & mask) === 0) {
+        return determineActionTerminalRelease(state, context);
+    }
+    return { type: 'cancelActiveInteraction' };
 }

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

@@ -1,14 +1,23 @@
 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 { DragSessionActiveLiftedPieceCoreOwned, DragSessionPendingLiftedPieceCoreOwned, DragSessionReleaseTargetingCoreOwned } from '../../../state/interaction/types/internal.js';
 import type { InteractionStateSnapshot } from '../../../state/interaction/types/main.js';
+export type StartPendingLiftedDragSessionInput = Pick<DragSessionPendingLiftedPieceCoreOwned, 'phase' | 'sourceSquare' | 'targetSquare' | 'startButton' | 'startPoint' | 'thresholdPx'>;
+export type StartActiveLiftedDragSessionInput = Pick<DragSessionActiveLiftedPieceCoreOwned, 'phase' | 'sourceSquare' | 'targetSquare' | 'startButton'>;
+export type StartLiftedDragSessionInput = StartPendingLiftedDragSessionInput | StartActiveLiftedDragSessionInput;
+export type ActivatePendingLiftedDragSessionInput = {
+    targetSquare: Square | null;
+};
+export type StartReleaseTargetingDragSessionInput = Pick<DragSessionReleaseTargetingCoreOwned, 'sourceSquare' | 'targetSquare' | 'startButton'>;
 export interface RuntimeInteractionSurface {
     getInteractionStateSnapshot(): InteractionStateSnapshot;
     getPieceCodeAt(square: Square): PieceCode;
-    startLiftedDrag(source: Square, target: Square): void;
-    startReleaseTargetingDrag(source: Square, target: Square): void;
-    completeCoreDragTo(target: Square): void;
-    completeExtensionDrag(target: Square | null): void;
+    startLiftedDragSession(input: StartLiftedDragSessionInput): void;
+    activatePendingLiftedDragSession(input: ActivatePendingLiftedDragSessionInput): void;
+    startReleaseTargetingDragSession(input: StartReleaseTargetingDragSessionInput): void;
+    completeCoreDragSessionTo(target: Square): void;
+    completeExtensionDragSession(target: Square | null): void;
     updateDragSessionCurrentTarget(target: Square | null): void;
     cancelActiveInteraction(): void;
     cancelInteraction(): void;

package/dist/runtime/mutation/interaction.js

@@ -4,7 +4,7 @@ export const reconcileInteractionSelectionAfterBoardStateChange = (context, muta
     const { current } = context;
     if (!mutationSession.hasMutation({ prefixes: ['state.board.'] }) ||
         mutationSession.hasMutation({
-            causes: ['state.interaction.clear', 'runtime.interaction.completeCoreDragTo']
+            causes: ['state.interaction.clear', 'runtime.interaction.completeCoreDragSessionTo']
         })) {
         return;
     }

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

@@ -6,8 +6,8 @@ import type { InteractionStateMutationPayloadByCause } from '../../state/interac
 import type { DragSessionCoreOwnedSnapshot, DragSessionExtensionOwnedSnapshot } from '../../state/interaction/types/internal.js';
 import type { ViewStateMutationPayloadByCause } from '../../state/view/mutation.js';
 type RuntimeOwnMutationPayloadByCause = {
-    'runtime.interaction.completeCoreDragTo': DragSessionCoreOwnedSnapshot;
-    'runtime.interaction.completeExtensionDragTo': DragSessionExtensionOwnedSnapshot;
+    'runtime.interaction.completeCoreDragSessionTo': DragSessionCoreOwnedSnapshot;
+    'runtime.interaction.completeExtensionDragSession': DragSessionExtensionOwnedSnapshot;
     'runtime.interaction.resolveDeferredUIMoveRequest': undefined;
     'runtime.interaction.cancelDeferredUIMoveRequest': undefined;
 };

package/dist/state/interaction/config.d.ts

@@ -0,0 +1,6 @@
+import type { InteractionConfig } from './types/config.js';
+import type { InteractionConfigInput } from './types/input.js';
+export declare const DefaultInteractionDesktopConfig: InteractionConfig;
+export declare const DefaultInteractionMobileConfig: InteractionConfig;
+export declare function normalizeInteractionConfig(input: InteractionConfigInput | undefined, base: InteractionConfig): InteractionConfig;
+export declare function areInteractionConfigsEqual(a: InteractionConfig, b: InteractionConfig): boolean;

package/dist/state/interaction/config.js

@@ -0,0 +1,30 @@
+import assert from '@ktarmyshov/assert';
+import { toMerged } from 'es-toolkit/object';
+import { isEqual } from 'es-toolkit/predicate';
+export const DefaultInteractionDesktopConfig = {
+    drag: {
+        liftedActivation: {
+            thresholdPx: 0
+        }
+    }
+};
+export const DefaultInteractionMobileConfig = {
+    drag: {
+        liftedActivation: {
+            thresholdPx: 5
+        }
+    }
+};
+function validateInteractionConfig(config) {
+    const { thresholdPx } = config.drag.liftedActivation;
+    assert(Number.isFinite(thresholdPx), 'drag.liftedActivation.thresholdPx must be a finite number');
+    assert(thresholdPx >= 0, 'drag.liftedActivation.thresholdPx must be >= 0');
+}
+export function normalizeInteractionConfig(input, base) {
+    const merged = toMerged(base, input ?? {});
+    validateInteractionConfig(merged);
+    return merged;
+}
+export function areInteractionConfigsEqual(a, b) {
+    return isEqual(a, b);
+}

package/dist/state/interaction/factory.js

@@ -1,8 +1,9 @@
 import assert from '@ktarmyshov/assert';
 import { cloneDeep } from 'es-toolkit';
+import { DefaultInteractionDesktopConfig, normalizeInteractionConfig } from './config.js';
 import { updateActiveDestinations } from './helpers.js';
 import { normalizeMovability } from './normalize.js';
-import { interactionClear, interactionClearActive, interactionSetDragSession, interactionSetMovability, interactionSetSelected, interactionUpdateDragSessionCurrentTarget } from './reducers.js';
+import { interactionActivatePendingLiftedDragSession, interactionClear, interactionClearActive, interactionSetConfig, interactionSetDragSession, interactionSetMovability, interactionSetSelected, interactionUpdateDragSessionCurrentTarget } from './reducers.js';
 const DefaultMovabilityDisabled = { mode: 0 /* MovabilityModeCode.Disabled */ };
 /**
  * Create a fresh interaction state with all fields set to null or false.
@@ -15,7 +16,8 @@ function createInteractionStateInternal(options) {
         movability,
         selected: null,
         activeDestinations: new Map(),
-        dragSession: null
+        dragSession: null,
+        config: normalizeInteractionConfig(options.config, DefaultInteractionDesktopConfig)
     };
 }
 export function createInteractionState(options) {
@@ -48,7 +50,7 @@ export function createInteractionState(options) {
             return updateActiveDestinations(internalState, mutationSession);
         },
         get dragSession() {
-            return internalState.dragSession ? { ...internalState.dragSession } : null;
+            return cloneDeep(internalState.dragSession);
         },
         setDragSession(session, mutationSession) {
             // assert that there is no active session when setting a new session.
@@ -64,6 +66,9 @@ export function createInteractionState(options) {
             }
             return mutationSession.addMutation('state.interaction.setDragSession', interactionSetDragSession(internalState, session));
         },
+        activatePendingLiftedDragSession(targetSquare, mutationSession) {
+            return mutationSession.addMutation('state.interaction.activatePendingLiftedDragSession', interactionActivatePendingLiftedDragSession(internalState, targetSquare));
+        },
         updateDragSessionCurrentTarget(sq, mutationSession) {
             assert(internalState.dragSession, 'There must be an active drag session to update its current target');
             return mutationSession.addMutation('state.interaction.updateDragSessionCurrentTarget', interactionUpdateDragSessionCurrentTarget(internalState, sq));
@@ -78,6 +83,13 @@ export function createInteractionState(options) {
         clearActive(mutationSession) {
             return mutationSession.addMutation('state.interaction.clearActive', interactionClearActive(internalState));
         },
+        setConfig(config, mutationSession) {
+            const nextConfig = normalizeInteractionConfig(config, internalState.config);
+            return mutationSession.addMutation('state.interaction.setConfig', interactionSetConfig(internalState, nextConfig));
+        },
+        getConfig() {
+            return cloneDeep(internalState.config);
+        },
         getSnapshot() {
             return cloneDeep(internalState);
         }

package/dist/state/interaction/helpers.d.ts

@@ -1,6 +1,22 @@
 import { InteractionStateMutationSession } from './mutation.js';
-import { DragSessionCoreOwnedSnapshot, DragSessionSnapshot } from './types/internal.js';
+import { DragSessionSnapshot } from './types/internal.js';
 import { InteractionStateInternal, InteractionStateSelected } from './types/main.js';
 export declare function selectedEqual(a: InteractionStateSelected | null, b: InteractionStateSelected | null): boolean;
 export declare function updateActiveDestinations(state: InteractionStateInternal, mutationSession: InteractionStateMutationSession): boolean;
-export declare function isDragSessionCoreOwned(session: DragSessionSnapshot): session is DragSessionCoreOwnedSnapshot;
+export declare function isDragSessionCoreOwned<T extends DragSessionSnapshot>(session: T): session is Extract<T, {
+    owner: 'core';
+}>;
+export declare function isDragSessionReleaseTargeting<T extends DragSessionSnapshot>(session: T): session is Extract<T, {
+    type: 'release-targeting';
+}>;
+export declare function isDragSessionLiftedPiece<T extends DragSessionSnapshot>(session: T): session is Extract<T, {
+    type: 'lifted-piece-drag';
+}>;
+export declare function isDragSessionPendingLiftedPiece<T extends DragSessionSnapshot>(session: T): session is Extract<T, {
+    type: 'lifted-piece-drag';
+    phase: 'pending';
+}>;
+export declare function isDragSessionActiveLiftedPiece<T extends DragSessionSnapshot>(session: T): session is Extract<T, {
+    type: 'lifted-piece-drag';
+    phase: 'active';
+}>;

package/dist/state/interaction/helpers.js

@@ -17,3 +17,15 @@ export function updateActiveDestinations(state, mutationSession) {
 export function isDragSessionCoreOwned(session) {
     return session.owner === 'core';
 }
+export function isDragSessionReleaseTargeting(session) {
+    return session.type === 'release-targeting';
+}
+export function isDragSessionLiftedPiece(session) {
+    return session.type === 'lifted-piece-drag';
+}
+export function isDragSessionPendingLiftedPiece(session) {
+    return isDragSessionLiftedPiece(session) && session.phase === 'pending';
+}
+export function isDragSessionActiveLiftedPiece(session) {
+    return isDragSessionLiftedPiece(session) && session.phase === 'active';
+}

package/dist/state/interaction/mutation.d.ts

@@ -2,10 +2,12 @@ import type { MutationSession } from '../../mutation/types.js';
 export type InteractionStateMutationPayloadByCause = {
     'state.interaction.setSelectedSquare': undefined;
     'state.interaction.setDragSession': undefined;
+    'state.interaction.activatePendingLiftedDragSession': undefined;
     'state.interaction.updateDragSessionCurrentTarget': undefined;
     'state.interaction.clear': undefined;
     'state.interaction.clearActive': undefined;
     'state.interaction.setMovability': undefined;
     'state.interaction.updateActiveDestinations': undefined;
+    'state.interaction.setConfig': undefined;
 };
 export type InteractionStateMutationSession = MutationSession<InteractionStateMutationPayloadByCause>;

package/dist/state/interaction/reducers.d.ts

@@ -1,11 +1,14 @@
 import type { ReadonlyDeep } from 'type-fest';
 import type { Square } from '../board/types/internal.js';
+import type { InteractionConfig } from './types/config.js';
 import { Movability, type DragSessionSnapshot, type MoveDestination } from './types/internal.js';
 import { InteractionStateInternal, InteractionStateSelected } from './types/main.js';
 export declare function interactionSetSelected(state: InteractionStateInternal, selected: InteractionStateSelected | null): boolean;
 export declare function interactionSetMovability(state: InteractionStateInternal, m: Movability): boolean;
+export declare function interactionSetConfig(state: InteractionStateInternal, config: InteractionConfig): boolean;
 export declare function interactionSetActiveDestinations(state: InteractionStateInternal, dests: ReadonlyMap<Square, ReadonlyDeep<MoveDestination>>): boolean;
 export declare function interactionSetDragSession(state: InteractionStateInternal, session: DragSessionSnapshot | null): boolean;
+export declare function interactionActivatePendingLiftedDragSession(state: InteractionStateInternal, targetSquare: Square | null): boolean;
 export declare function interactionUpdateDragSessionCurrentTarget(state: InteractionStateInternal, sq: Square | null): boolean;
 export declare function interactionClear(state: InteractionStateInternal): boolean;
 export declare function interactionClearActive(state: InteractionStateInternal): boolean;

package/dist/state/interaction/reducers.js

@@ -1,7 +1,9 @@
 import assert from '@ktarmyshov/assert';
 import { cloneDeep } from 'es-toolkit/object';
+import { isEqual } from 'es-toolkit/predicate';
 import { setsEqual } from '../../helpers/util.js';
-import { selectedEqual } from './helpers.js';
+import { areInteractionConfigsEqual } from './config.js';
+import { isDragSessionPendingLiftedPiece, selectedEqual } from './helpers.js';
 import { movabilitiesEqual } from './movability.js';
 export function interactionSetSelected(state, selected) {
     const notChanged = selectedEqual(state.selected, selected);
@@ -16,6 +18,12 @@ export function interactionSetMovability(state, m) {
     state.movability = cloneDeep(m); // Defensive copy to prevent external mutations
     return true;
 }
+export function interactionSetConfig(state, config) {
+    if (areInteractionConfigsEqual(state.config, config))
+        return false; // no-op
+    state.config = cloneDeep(config); // Defensive copy to prevent external mutations
+    return true;
+}
 function promotedTosEqual(a, b) {
     if (a === b)
         return true;
@@ -46,15 +54,22 @@ export function interactionSetActiveDestinations(state, dests) {
     return true;
 }
 export function interactionSetDragSession(state, session) {
-    const changed = state.dragSession?.type !== session?.type ||
-        state.dragSession?.sourceSquare !== session?.sourceSquare ||
-        state.dragSession?.sourcePieceCode !== session?.sourcePieceCode ||
-        state.dragSession?.targetSquare !== session?.targetSquare;
-    if (!changed)
-        return false; // no-op
+    if (state.dragSession === session)
+        return false;
+    if (isEqual(state.dragSession, session))
+        return false;
     state.dragSession = session ? cloneDeep(session) : null;
     return true;
 }
+export function interactionActivatePendingLiftedDragSession(state, targetSquare) {
+    const current = state.dragSession;
+    assert(current !== null, 'activatePendingLiftedDragSession requires an active drag session');
+    assert(isDragSessionPendingLiftedPiece(current), 'activatePendingLiftedDragSession requires a pending lifted-piece drag session');
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { startPoint: _startPoint, thresholdPx: _thresholdPx, ...rest } = current;
+    state.dragSession = { ...rest, phase: 'active', targetSquare };
+    return true;
+}
 export function interactionUpdateDragSessionCurrentTarget(state, sq) {
     const changed = state.dragSession?.targetSquare !== sq;
     if (!changed)

package/dist/state/interaction/types/config.d.ts

@@ -0,0 +1,9 @@
+export interface InteractionConfigDragLiftedActivation {
+    thresholdPx: number;
+}
+export interface InteractionConfigDrag {
+    liftedActivation: InteractionConfigDragLiftedActivation;
+}
+export interface InteractionConfig {
+    drag: InteractionConfigDrag;
+}

package/dist/state/interaction/types/config.js

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

package/dist/state/interaction/types/input.d.ts

@@ -1,4 +1,6 @@
+import { PartialDeep } from 'type-fest';
 import { MoveRequestInput, RolePromotionInput, SquareString } from '../../board/types/input.js';
+import { InteractionConfig } from './config.js';
 export interface MoveDestinationInput extends Omit<MoveRequestInput, 'from' | 'promotedTo'> {
     promotedTo?: RolePromotionInput[];
 }
@@ -16,3 +18,4 @@ export type DisabledMovabilityInput = {
     mode: 'disabled';
 };
 export type MovabilityInput = StrictMovabilityInput | FreeMovabilityInput | DisabledMovabilityInput;
+export type InteractionConfigInput = PartialDeep<InteractionConfig>;

package/dist/state/interaction/types/internal.d.ts

@@ -1,17 +1,26 @@
 import type { ReadonlyDeep } from 'type-fest';
-import type { ExtensionDragSession, ExtensionDragSessionBase } from '../../../extensions/types/basic/interaction.js';
+import type { ExtensionDragSession, ExtensionDragSessionActiveLiftedPiece, ExtensionDragSessionBase, ExtensionDragSessionPendingLiftedPiece } from '../../../extensions/types/basic/interaction.js';
 import type { MoveRequest, PieceCode, RolePromotionCode, Square } from '../../board/types/internal.js';
+import type { InteractionConfig } from './config.js';
 export type DragSessionExtensionOwned = ExtensionDragSession & {
     owner: string;
 };
 export type DragSessionExtensionOwnedSnapshot = ReadonlyDeep<DragSessionExtensionOwned>;
-export interface DragSessionCoreOwned extends ExtensionDragSessionBase {
+export interface DragSessionPendingLiftedPieceCoreOwned extends ExtensionDragSessionPendingLiftedPiece {
     owner: 'core';
-    type: 'lifted-piece-drag' | 'release-targeting';
+    sourceSquare: Square;
+}
+export interface DragSessionActiveLiftedPieceCoreOwned extends ExtensionDragSessionActiveLiftedPiece {
+    owner: 'core';
+    sourceSquare: Square;
+}
+export interface DragSessionReleaseTargetingCoreOwned extends ExtensionDragSessionBase {
+    owner: 'core';
+    type: 'release-targeting';
     sourceSquare: Square;
     sourcePieceCode: PieceCode;
-    targetSquare: Square | null;
 }
+export type DragSessionCoreOwned = DragSessionPendingLiftedPieceCoreOwned | DragSessionActiveLiftedPieceCoreOwned | DragSessionReleaseTargetingCoreOwned;
 export type DragSessionCoreOwnedSnapshot = ReadonlyDeep<DragSessionCoreOwned>;
 export type DragSession = DragSessionCoreOwned | DragSessionExtensionOwned;
 export type DragSessionSnapshot = ReadonlyDeep<DragSession>;
@@ -41,3 +50,4 @@ export interface MovabilityDisabled {
 }
 export type Movability = MovabilityStrict | MovabilityFree | MovabilityDisabled;
 export type MovabilitySnapshot = ReadonlyDeep<Movability>;
+export type InteractionConfigSnapshot = ReadonlyDeep<InteractionConfig>;

package/dist/state/interaction/types/main.d.ts

@@ -1,8 +1,9 @@
-import { ReadonlyDeep } from 'type-fest';
-import { NonEmptyPieceCode, Square } from '../../board/types/internal.js';
-import { InteractionStateMutationSession } from '../mutation.js';
-import { MovabilityInput } from './input.js';
-import { DragSession, DragSessionSnapshot, Movability, MovabilitySnapshot, MoveDestinationSnapshot } from './internal.js';
+import type { ReadonlyDeep } from 'type-fest';
+import type { NonEmptyPieceCode, Square } from '../../board/types/internal.js';
+import type { InteractionStateMutationSession } from '../mutation.js';
+import type { InteractionConfig } from './config.js';
+import type { InteractionConfigInput, MovabilityInput } from './input.js';
+import type { DragSession, DragSessionSnapshot, InteractionConfigSnapshot, Movability, MovabilitySnapshot, MoveDestinationSnapshot } from './internal.js';
 export interface InteractionStateSelected {
     square: Square;
     pieceCode: NonEmptyPieceCode;
@@ -12,10 +13,12 @@ export interface InteractionStateInternal {
     movability: Movability;
     activeDestinations: ReadonlyMap<Square, MoveDestinationSnapshot>;
     dragSession: DragSession | null;
+    config: InteractionConfig;
 }
 export type InteractionStateSnapshot = ReadonlyDeep<InteractionStateInternal>;
 export interface InteractionStateInitOptions {
     movability?: MovabilityInput;
+    config?: InteractionConfigInput;
 }
 export interface InteractionState {
     readonly selected: InteractionStateSelected | null;
@@ -26,8 +29,11 @@ export interface InteractionState {
     updateActiveDestinations(mutationSession: InteractionStateMutationSession): boolean;
     readonly dragSession: DragSessionSnapshot | null;
     setDragSession(session: DragSessionSnapshot | null, mutationSession: InteractionStateMutationSession): boolean;
+    activatePendingLiftedDragSession(targetSquare: Square | null, mutationSession: InteractionStateMutationSession): boolean;
     updateDragSessionCurrentTarget(sq: Square | null, mutationSession: InteractionStateMutationSession): boolean;
     clear(mutationSession: InteractionStateMutationSession): boolean;
     clearActive(mutationSession: InteractionStateMutationSession): boolean;
+    setConfig(config: InteractionConfigInput, mutationSession: InteractionStateMutationSession): boolean;
+    getConfig(): InteractionConfigSnapshot;
     getSnapshot(): InteractionStateSnapshot;
 }

package/dist/wrapper/factory.js

@@ -34,6 +34,8 @@ export function createBoard(options) {
         setOrientation: runtime.setOrientation,
         setMovability: runtime.setMovability,
         select: runtime.select,
+        setInteractionConfig: runtime.setInteractionConfig,
+        getInteractionConfig: runtime.getInteractionConfig,
         getSnapshot: runtime.getSnapshot,
         extensions: runtime.getExtensionsPublicRecord()
     };

package/dist/wrapper/types.d.ts

@@ -51,7 +51,7 @@ export type ChessboardInitOptions<TExtensions extends readonly ChessboardExtensi
 /**
  * Public board interface returned by createBoard(...)
  */
-export type ChessboardRuntimeSurface = Pick<Runtime, 'destroy' | 'move' | 'setPosition' | 'setPiecePosition' | 'setTurn' | 'setOrientation' | 'setMovability' | 'select' | 'getSnapshot'>;
+export type ChessboardRuntimeSurface = Pick<Runtime, 'destroy' | 'move' | 'setPosition' | 'setPiecePosition' | 'setTurn' | 'setOrientation' | 'setMovability' | 'select' | 'setInteractionConfig' | 'getInteractionConfig' | 'getSnapshot'>;
 export interface Chessboard<TExtensions extends readonly ChessboardExtensionInput[] = DefaultBuiltinChessboardExtensions> extends ChessboardRuntimeSurface {
     readonly extensions: ChessboardExtensionsPublicMap<TExtensions>;
 }

package/package.json

@@ -1,11 +1,10 @@
 {
 	"name": "@mirasen/chessboard",
 	"description": "Framework-agnostic TypeScript chessboard platform with real chess interaction built in.",
-	"version": "1.2.3",
+	"version": "1.3.0",
 	"license": "MIT",
 	"author": {
-		"name": "Mirasen",
-		"email": "konstantin@mirasen.io"
+		"name": "Mirasen"
 	},
 	"keywords": [
 		"mirasen",
@@ -63,8 +62,8 @@
 		"prepack": "publint",
 		"format": "prettier --write .",
 		"lint": "prettier --check . && eslint .",
-		"check": "tsc --skipLibCheck --noEmit",
-		"check:test": "tsc --project tsconfig-test.json --skipLibCheck --noEmit",
+		"check": "tsc --project tsconfig.json --noEmit",
+		"check:test": "tsc --project tsconfig-test.json",
 		"test": "npm run check:test && vitest run --run",
 		"coverage": "npm run check:test && vitest run --coverage",
 		"changeset:version": "changeset version && npm install && npm run format && git add --all",
@@ -97,7 +96,7 @@
 		"publint": "^0.3.11",
 		"rimraf": "^6.0.1",
 		"serve": "^14.2.6",
-		"typescript": "^5.8.2",
+		"typescript": "^6.0.3",
 		"typescript-eslint": "^8.57.0",
 		"vitest": "^4.0.18"
 	},

package/dist/extensions/first-party/main-renderer/types/input.d.ts

@@ -1,4 +0,0 @@
-import { PieceString } from '../../../../state/board/types/input.js';
-import { TMainRendererConfig } from './template.js';
-export type PieceUrlsInput = Record<PieceString, string>;
-export type MainRendererConfigInput = TMainRendererConfig<PieceUrlsInput>;