@mirasen/chessboard 0.1.0 → 1.0.0-rc.0

package/dist/extensions/first-party/main-renderer/pieces/update.js

@@ -1,8 +1,8 @@
-import { setsEqual } from '../../../../helpers/util';
-import { piecePositionsEqual } from '../../../../state/board/check';
-import { isUpdateContextRenderable } from '../../../types/context/update';
-import { DirtyLayer } from '../types/extension';
-import { calculateSuppressedSquares } from './suppress';
+import { setsEqual } from '../../../../helpers/util.js';
+import { piecePositionsEqual } from '../../../../state/board/check.js';
+import { isUpdateContextRenderable } from '../../../types/context/update.js';
+import { DirtyLayer } from '../types/extension.js';
+import { calculateSuppressedSquares } from './suppress.js';
 export function rendererPiecesOnUpdate(state, context, animationSuppressedSquares) {
     if (!isUpdateContextRenderable(context) ||
         !context.mutation.hasMutation({

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

@@ -1,9 +1,9 @@
-import { ExtensionDefinition, ExtensionInstance } from '../../../types/extension';
-import { MainRendererConfigInput } from './input';
+import { ExtensionDefinition, ExtensionInstance } from '../../../types/extension.js';
+import { MainRendererConfigInput } from './input.js';
 export type MainRendererInitOptions = Partial<MainRendererConfigInput>;
 export declare const EXTENSION_SLOTS: readonly ["board", "coordinates", "pieces", "animation", "drag"];
 export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
-export declare const EXTENSION_ID: "main-renderer";
+export declare const EXTENSION_ID: "renderer";
 export type MainRendererDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
 export type MainRendererInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
 export declare enum DirtyLayer {

package/dist/extensions/first-party/main-renderer/types/extension.js

@@ -1,5 +1,5 @@
 export const EXTENSION_SLOTS = ['board', 'coordinates', 'pieces', 'animation', 'drag'];
-export const EXTENSION_ID = 'main-renderer';
+export const EXTENSION_ID = 'renderer';
 export var DirtyLayer;
 (function (DirtyLayer) {
     DirtyLayer[DirtyLayer["Board"] = 1] = "Board";

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

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

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

@@ -1,11 +1,11 @@
-import { ExtensionRuntimeSurface } from '../../../types/surface/main';
-import { ExtensionInternal } from '../../common/types';
-import { MainRendererAnimation } from '../animation/types';
-import { MainRendererBoard } from '../board/types';
-import { MainRendererCoordinates } from '../coordinates/types';
-import { MainRendererDrag } from '../drag/types';
-import { MainRendererPieces } from '../pieces/types';
-import { ExtensionSlotsType } from './extension';
+import { ExtensionRuntimeSurface } from '../../../types/surface/main.js';
+import { ExtensionInternal } from '../../common/types.js';
+import { MainRendererAnimation } from '../animation/types.js';
+import { MainRendererBoard } from '../board/types.js';
+import { MainRendererCoordinates } from '../coordinates/types.js';
+import { MainRendererDrag } from '../drag/types.js';
+import { MainRendererPieces } from '../pieces/types.js';
+import { ExtensionSlotsType } from './extension.js';
 export interface MainRendererInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
     readonly board: MainRendererBoard;
     readonly coordinates: MainRendererCoordinates;

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

@@ -1,5 +1,5 @@
-import { NonEmptyPieceCode } from '../../../../state/board/types/internal';
-import { TMainRendererConfig } from './template';
+import { NonEmptyPieceCode } from '../../../../state/board/types/internal.js';
+import { TMainRendererConfig } from './template.js';
 export interface ConfigColorPair {
     light: string;
     dark: string;

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

@@ -1,4 +1,4 @@
-import { ConfigColors } from './internal';
+import { ConfigColors } from './internal.js';
 export interface TMainRendererConfig<TPieceUrls> {
     colors: ConfigColors;
     pieceUrls: TPieceUrls;

package/dist/extensions/first-party/promotion/factory.d.ts

@@ -0,0 +1,3 @@
+import { PromotionInitConfig } from './types/input.js';
+import { PromotionDefinition } from './types/main.js';
+export declare function createPromotion(config?: PromotionInitConfig): PromotionDefinition;

package/dist/extensions/first-party/promotion/factory.js

@@ -0,0 +1,219 @@
+import assert from '@ktarmyshov/assert';
+import { createSvgElement, updateElementAttributes } from '../../../render/svg/helpers.js';
+import { fileOf, rankOf, squareOf } from '../../../state/board/coords.js';
+import { toPieceCode } from '../../../state/board/piece.js';
+import { isUpdateContextRenderable } from '../../types/context/update.js';
+import { extensionCreateInternalBase, extensionDestroy, extensionMount, extensionUnmount } from '../common/helpers.js';
+import { normalizePromotionConfig } from './normalize.js';
+import { EXTENSION_ID, EXTENSION_SLOTS } from './types/main.js';
+export function createPromotion(config = {}) {
+    const mergedConfig = normalizePromotionConfig(config);
+    return {
+        id: EXTENSION_ID,
+        slots: EXTENSION_SLOTS,
+        createInstance(options) {
+            return createPromotionInstance(options, mergedConfig);
+        }
+    };
+}
+function createPromotionInternal(options, config) {
+    return {
+        ...extensionCreateInternalBase(),
+        svgPromotionPieces: new Map(),
+        activePromotionSquares: new Map(),
+        svgHoverRect: null,
+        config,
+        runtimeSurface: options.runtimeSurface
+    };
+}
+function extensionCleanPieceNode(state, roleCode) {
+    const pieceNode = state.svgPromotionPieces.get(roleCode);
+    if (pieceNode) {
+        pieceNode.svg.remove();
+        pieceNode.rect.remove();
+        state.svgPromotionPieces.delete(roleCode);
+    }
+}
+function extensionCleanPieceNodes(state) {
+    for (const pieceNode of state.svgPromotionPieces.values()) {
+        pieceNode.svg.remove();
+        pieceNode.rect.remove();
+    }
+    state.svgPromotionPieces.clear();
+}
+function extensionCleanHoverRect(state) {
+    if (state.svgHoverRect) {
+        state.svgHoverRect.remove();
+        state.svgHoverRect = null;
+    }
+}
+function extensionClean(state) {
+    extensionCleanPieceNodes(state);
+    extensionCleanHoverRect(state);
+    state.activePromotionSquares.clear();
+}
+function createPromotionInstance(options, config) {
+    const internalState = createPromotionInternal(options, config);
+    return {
+        id: EXTENSION_ID,
+        mount(env) {
+            extensionMount(internalState, env.slotRoots);
+        },
+        onUIMoveRequest(context) {
+            const request = context.request;
+            if (request.status !== 'unresolved')
+                return; // no-op if the request is already resolved or deferred
+            if (request.canBeAutoResolved)
+                return; // no-op, core will auto-resolve
+            // OK! now this one is our request!
+            request.defer(); // defer the request until the user selects a piece to promote to
+        },
+        onUpdate(context) {
+            const needsRender = context.mutation.hasMutation({
+                causes: ['state.change.setDeferredUIMoveRequest', 'layout.refreshGeometry']
+            }) && isUpdateContextRenderable(context);
+            if (!needsRender) {
+                return; // no-op
+            }
+            const request = context.currentFrame.state.change.deferredUIMoveRequest;
+            if (request !== null) {
+                internalState.runtimeSurface.transientVisuals.subscribe();
+                internalState.runtimeSurface.events.subscribeEvent('pointerdown');
+            }
+            else {
+                internalState.runtimeSurface.transientVisuals.unsubscribe();
+                internalState.runtimeSurface.events.unsubscribeEvent('pointerdown');
+            }
+            context.invalidation.markDirty(1 /* DirtyLayer.Promotion */);
+        },
+        render(context) {
+            assert(context.invalidation.dirtyLayers !== 0, 'Render should only be called when there are dirty layers');
+            const deferredRequest = context.currentFrame.state.change.deferredUIMoveRequest;
+            if (deferredRequest === null) {
+                // No deferred request, so we can clean up any existing promotion piece nodes and highlights
+                extensionClean(internalState);
+                return;
+            }
+            const targetSquare = deferredRequest.destination.to;
+            const targetFile = fileOf(targetSquare);
+            const targetRank = rankOf(targetSquare);
+            const promotedTo = deferredRequest.destination.promotedTo;
+            assert(promotedTo && promotedTo.length > 1 && promotedTo.length <= 4, 'PromotedTo should be available in a deferred promotion request and have between 2 and 4 roles');
+            const promotedToSorted = promotedTo.toSorted((a, b) => b - a); // Descending order to render queen on top
+            const geometry = context.currentFrame.layout.geometry;
+            // Determine piece color from target rank
+            const isWhitePromotion = targetRank === 7;
+            const pieceColor = isWhitePromotion ? 0 /* ColorCode.White */ : 8 /* ColorCode.Black */;
+            // Direction: white pieces cascade downward (rank decreases), black upward (rank increases)
+            const rankStep = isWhitePromotion ? -1 : 1;
+            // Rebuild the active promotion squares set
+            internalState.activePromotionSquares.clear();
+            // Remove nodes for roles no longer in the desired set
+            const desiredRoles = new Set(promotedToSorted);
+            for (const [roleCode] of internalState.svgPromotionPieces) {
+                if (!desiredRoles.has(roleCode)) {
+                    extensionCleanPieceNode(internalState, roleCode);
+                }
+            }
+            // Create or update a node for each promotion role
+            assert(internalState.slotRoots, 'Slot roots should be available when render is called');
+            const layer = internalState.slotRoots.animation;
+            for (let i = 0; i < promotedToSorted.length; i++) {
+                const roleCode = promotedToSorted[i];
+                const displayRank = (targetRank + i * rankStep);
+                const displaySquare = squareOf(targetFile, displayRank);
+                const pieceCode = toPieceCode(roleCode, pieceColor);
+                const url = internalState.config.pieceUrls[pieceCode];
+                const r = geometry.getSquareRect(displaySquare);
+                const rectAttrs = {
+                    x: r.x.toString(),
+                    y: r.y.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString(),
+                    fill: internalState.config.squareColor.color,
+                    'fill-opacity': internalState.config.squareColor.opacity.toString(),
+                    'shape-rendering': 'crispEdges'
+                };
+                const imageAttrs = {
+                    href: url,
+                    x: r.x.toString(),
+                    y: r.y.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString()
+                };
+                internalState.activePromotionSquares.set(displaySquare, roleCode);
+                const existing = internalState.svgPromotionPieces.get(roleCode) ?? null;
+                if (existing !== null) {
+                    updateElementAttributes(existing.rect, rectAttrs);
+                    updateElementAttributes(existing.svg, imageAttrs);
+                }
+                else {
+                    const rect = createSvgElement(layer, 'rect', {
+                        'data-chessboard-id': `promotion-bg-${roleCode}`,
+                        ...rectAttrs
+                    });
+                    const svg = createSvgElement(layer, 'image', {
+                        'data-chessboard-id': `promotion-piece-${roleCode}`,
+                        ...imageAttrs
+                    });
+                    internalState.svgPromotionPieces.set(roleCode, { svg, rect });
+                }
+            }
+        },
+        renderTransientVisuals(context) {
+            const target = context.transientInput.target;
+            if (target !== null && internalState.activePromotionSquares.has(target)) {
+                // Hover is over one of the promotion squares
+                const geometry = context.currentFrame.layout.geometry;
+                const r = geometry.getSquareRect(target);
+                const attrs = {
+                    x: r.x.toString(),
+                    y: r.y.toString(),
+                    width: r.width.toString(),
+                    height: r.height.toString(),
+                    fill: internalState.config.hoverColor.color,
+                    'fill-opacity': internalState.config.hoverColor.opacity.toString(),
+                    'shape-rendering': 'crispEdges'
+                };
+                if (internalState.svgHoverRect) {
+                    updateElementAttributes(internalState.svgHoverRect, attrs);
+                }
+                else {
+                    assert(internalState.slotRoots, 'Slot roots should be available when renderTransientVisuals is called');
+                    const layer = internalState.slotRoots.animation;
+                    internalState.svgHoverRect = createSvgElement(layer, 'rect', {
+                        'data-chessboard-id': 'promotion-hover',
+                        ...attrs
+                    });
+                }
+            }
+            else {
+                // Not hovering over a promotion square — remove hover rect
+                extensionCleanHoverRect(internalState);
+            }
+        },
+        onEvent(context) {
+            assert(context.rawEvent.type === 'pointerdown', 'Only pointerdown events should be subscribed to');
+            const targetSquare = context.sceneEvent?.targetSquare ?? null;
+            if (targetSquare !== null) {
+                const roleCode = internalState.activePromotionSquares.get(targetSquare);
+                if (roleCode !== undefined) {
+                    context.rawEvent.preventDefault(); // Prevent focus change and other side effects if it is our promotion square
+                    internalState.runtimeSurface.commands.resolveDeferredUIMoveRequest({
+                        promotedTo: roleCode
+                    });
+                    return;
+                }
+            }
+            internalState.runtimeSurface.commands.cancelDeferredUIMoveRequest();
+        },
+        unmount() {
+            extensionUnmount(internalState);
+            extensionClean(internalState);
+        },
+        destroy() {
+            extensionDestroy(internalState);
+            extensionClean(internalState);
+        }
+    };
+}

package/dist/extensions/first-party/promotion/normalize.d.ts

@@ -0,0 +1,3 @@
+import { PromotionInitConfig } from './types/input.js';
+import { PromotionConfig } from './types/internal.js';
+export declare function normalizePromotionConfig(config: PromotionInitConfig): PromotionConfig;

package/dist/extensions/first-party/promotion/normalize.js

@@ -0,0 +1,37 @@
+import assert from '@ktarmyshov/assert';
+import { normalizePiece } from '../../../state/board/normalize.js';
+import { ALL_NON_EMPTY_PROMOTION_PIECE_CODES, DEFAULT_CONFIG } from './types/internal.js';
+function assertPieceUrlsComplete(pieceUrls) {
+    for (const pieceCode of ALL_NON_EMPTY_PROMOTION_PIECE_CODES) {
+        assert(pieceCode in pieceUrls, `Missing URL for piece code: ${pieceCode}`);
+    }
+}
+function assertPieceCodeIsPromotionPieceCode(pieceCode) {
+    assert(pieceCode === 5 /* PieceCode.WhiteQueen */ ||
+        pieceCode === 4 /* PieceCode.WhiteRook */ ||
+        pieceCode === 3 /* PieceCode.WhiteBishop */ ||
+        pieceCode === 2 /* PieceCode.WhiteKnight */ ||
+        pieceCode === 13 /* PieceCode.BlackQueen */ ||
+        pieceCode === 12 /* PieceCode.BlackRook */ ||
+        pieceCode === 11 /* PieceCode.BlackBishop */ ||
+        pieceCode === 10 /* PieceCode.BlackKnight */, `Invalid promotion piece code: ${pieceCode}`);
+}
+function normalizePromotionPieceUrls(input) {
+    const normalized = {};
+    for (const [key, url] of Object.entries(input)) {
+        const pieceCode = normalizePiece(key);
+        assertPieceCodeIsPromotionPieceCode(pieceCode);
+        normalized[pieceCode] = url;
+    }
+    assertPieceUrlsComplete(normalized);
+    return normalized;
+}
+export function normalizePromotionConfig(config) {
+    return {
+        squareColor: config.squareColor ?? DEFAULT_CONFIG.squareColor,
+        hoverColor: config.hoverColor ?? DEFAULT_CONFIG.hoverColor,
+        pieceUrls: config.pieceUrls
+            ? normalizePromotionPieceUrls(config.pieceUrls)
+            : DEFAULT_CONFIG.pieceUrls
+    };
+}

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

@@ -0,0 +1,10 @@
+import { ColorShort, RolePromotionShort } from '../../../../state/board/types/input.js';
+import { OpaqueColor } from '../../common/types.js';
+import { PieceUrlsInput } from '../../main-renderer/types/input.js';
+export type PromotionPieceString = `${ColorShort}${RolePromotionShort}`;
+export type PromotionPieceUrlsInput = Pick<PieceUrlsInput, PromotionPieceString>;
+export interface PromotionInitConfig {
+    squareColor?: OpaqueColor;
+    hoverColor?: OpaqueColor;
+    pieceUrls?: PromotionPieceUrlsInput;
+}

package/dist/extensions/first-party/promotion/types/internal.d.ts

@@ -0,0 +1,12 @@
+import { NonEmptyPieceCode, PieceCode } from '../../../../state/board/types/internal.js';
+import { OpaqueColor } from '../../common/types.js';
+export type PromotionPieceCode = Exclude<NonEmptyPieceCode, PieceCode.WhitePawn | PieceCode.BlackPawn | PieceCode.BlackKing | PieceCode.WhiteKing>;
+export type PromotionPieceUrls = Record<PromotionPieceCode, string>;
+export interface PromotionConfig {
+    squareColor: OpaqueColor;
+    hoverColor: OpaqueColor;
+    pieceUrls: PromotionPieceUrls;
+}
+export declare const PROMOTION_CHESSNUT_PIECE_URLS: PromotionPieceUrls;
+export declare const ALL_NON_EMPTY_PROMOTION_PIECE_CODES: PromotionPieceCode[];
+export declare const DEFAULT_CONFIG: PromotionConfig;

package/dist/extensions/first-party/promotion/types/internal.js

@@ -0,0 +1,22 @@
+export const PROMOTION_CHESSNUT_PIECE_URLS = {
+    [5 /* PieceCode.WhiteQueen */]: new URL('../../../../../assets/pieces/chessnut/wQ.svg', import.meta.url).toString(),
+    [4 /* PieceCode.WhiteRook */]: new URL('../../../../../assets/pieces/chessnut/wR.svg', import.meta.url).toString(),
+    [3 /* PieceCode.WhiteBishop */]: new URL('../../../../../assets/pieces/chessnut/wB.svg', import.meta.url).toString(),
+    [2 /* PieceCode.WhiteKnight */]: new URL('../../../../../assets/pieces/chessnut/wN.svg', import.meta.url).toString(),
+    [13 /* PieceCode.BlackQueen */]: new URL('../../../../../assets/pieces/chessnut/bQ.svg', import.meta.url).toString(),
+    [12 /* PieceCode.BlackRook */]: new URL('../../../../../assets/pieces/chessnut/bR.svg', import.meta.url).toString(),
+    [11 /* PieceCode.BlackBishop */]: new URL('../../../../../assets/pieces/chessnut/bB.svg', import.meta.url).toString(),
+    [10 /* PieceCode.BlackKnight */]: new URL('../../../../../assets/pieces/chessnut/bN.svg', import.meta.url).toString()
+};
+export const ALL_NON_EMPTY_PROMOTION_PIECE_CODES = Object.keys(PROMOTION_CHESSNUT_PIECE_URLS).map((code) => Number(code));
+export const DEFAULT_CONFIG = {
+    squareColor: {
+        color: 'rgba(255, 255, 255)',
+        opacity: 1
+    },
+    hoverColor: {
+        color: '#000000',
+        opacity: 0.15
+    },
+    pieceUrls: PROMOTION_CHESSNUT_PIECE_URLS
+};

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

@@ -0,0 +1,24 @@
+import { RolePromotionCode, Square } from '../../../../state/board/types/internal.js';
+import { ExtensionDefinition, ExtensionInstance } from '../../../types/extension.js';
+import { ExtensionRuntimeSurface } from '../../../types/surface/main.js';
+import { ExtensionInternal } from '../../common/types.js';
+import { PromotionConfig } from './internal.js';
+export declare const EXTENSION_SLOTS: readonly ["animation"];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "promotion";
+export type PromotionDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export type PromotionInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export interface PromotionPieceNode {
+    readonly svg: SVGImageElement;
+    readonly rect: SVGRectElement;
+}
+export interface PromotionInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
+    readonly config: PromotionConfig;
+    readonly svgPromotionPieces: Map<RolePromotionCode, PromotionPieceNode>;
+    readonly activePromotionSquares: Map<Square, RolePromotionCode>;
+    svgHoverRect: SVGRectElement | null;
+    readonly runtimeSurface: ExtensionRuntimeSurface;
+}
+export declare const enum DirtyLayer {
+    Promotion = 1
+}

package/dist/extensions/first-party/promotion/types/main.js

@@ -0,0 +1,2 @@
+export const EXTENSION_SLOTS = ['animation'];
+export const EXTENSION_ID = 'promotion';

package/dist/extensions/first-party/selected-square/factory.d.ts

@@ -1,2 +1,2 @@
-import { SelectedSquareDefinition, SelectedSquareInitConfig } from './types';
+import { SelectedSquareDefinition, SelectedSquareInitConfig } from './types.js';
 export declare function createSelectedSquare(config?: SelectedSquareInitConfig): SelectedSquareDefinition;

package/dist/extensions/first-party/selected-square/factory.js

@@ -1,9 +1,9 @@
 import assert from '@ktarmyshov/assert';
 import { toMerged } from 'es-toolkit';
-import { createSvgElement, updateElementAttributes } from '../../../render/svg/helpers';
-import { isUpdateContextRenderable } from '../../types/context/update';
-import { extensionCreateInternalBase, extensionDestroy, extensionMount, extensionUnmount } from '../common/helpers';
-import { DEFAULT_CONFIG, EXTENSION_ID, EXTENSION_SLOTS } from './types';
+import { createSvgElement, updateElementAttributes } from '../../../render/svg/helpers.js';
+import { isUpdateContextRenderable } from '../../types/context/update.js';
+import { extensionCreateInternalBase, extensionDestroy, extensionMount, extensionUnmount } from '../common/helpers.js';
+import { DEFAULT_CONFIG, EXTENSION_ID, EXTENSION_SLOTS } from './types.js';
 export function createSelectedSquare(config = {}) {
     const mergedConfig = toMerged(DEFAULT_CONFIG, config);
     return {
@@ -55,12 +55,12 @@ function createSelectedSquareInstance(config) {
                 return;
             }
             const geometry = context.currentFrame.layout.geometry;
-            const r = geometry.squareRect(selectedSquare);
+            const r = geometry.getSquareRect(selectedSquare);
             const rectAttributes = {
                 x: r.x.toString(),
                 y: r.y.toString(),
-                width: r.size.toString(),
-                height: r.size.toString(),
+                width: r.width.toString(),
+                height: r.height.toString(),
                 fill: internalState.config.color,
                 'fill-opacity': internalState.config.opacity.toString(),
                 'shape-rendering': 'crispEdges'

package/dist/extensions/first-party/selected-square/types.d.ts

@@ -1,6 +1,6 @@
 import { PartialDeep } from 'type-fest';
-import { ExtensionDefinition, ExtensionInstance } from '../../types/extension';
-import { ExtensionInternal, OpaqueColor } from '../common/types';
+import { ExtensionDefinition, ExtensionInstance } from '../../types/extension.js';
+import { ExtensionInternal, OpaqueColor } from '../common/types.js';
 export declare const EXTENSION_SLOTS: readonly ["underPieces"];
 export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
 export declare const EXTENSION_ID: "selectedSquare";

package/dist/extensions/index.d.ts

@@ -1,8 +1,8 @@
-export { createActiveTarget } from './first-party/active-target/factory';
-export { createBoardEvents } from './first-party/board-events/factory';
-export { createLastMove } from './first-party/last-move/factory';
-export { createLegalMoves } from './first-party/legal-moves/factory';
-export { createMainRenderer } from './first-party/main-renderer/factory';
-export { createSelectedSquare } from './first-party/selected-square/factory';
-export type { AnyExtensionDefinition, ExtensionDefinitionId, ExtensionDefinitionPublicApi } from './types/extension';
-export type { BuiltInExtensionId, DefaultBuiltinChessboardExtensions } from './types/wrapper';
+export { createActiveTarget } from './first-party/active-target/factory.js';
+export { createBoardEvents } from './first-party/board-events/factory.js';
+export { createLastMove } from './first-party/last-move/factory.js';
+export { createLegalMoves } from './first-party/legal-moves/factory.js';
+export { createMainRenderer } from './first-party/main-renderer/factory.js';
+export { createSelectedSquare } from './first-party/selected-square/factory.js';
+export type { AnyExtensionDefinition, ExtensionDefinitionId, ExtensionDefinitionPublicApi } from './types/extension.js';
+export type { builtInExtensionFactoryMap, BuiltInExtensionId } from './types/wrapper.js';

package/dist/extensions/index.js

@@ -1,6 +1,6 @@
-export { createActiveTarget } from './first-party/active-target/factory';
-export { createBoardEvents } from './first-party/board-events/factory';
-export { createLastMove } from './first-party/last-move/factory';
-export { createLegalMoves } from './first-party/legal-moves/factory';
-export { createMainRenderer } from './first-party/main-renderer/factory';
-export { createSelectedSquare } from './first-party/selected-square/factory';
+export { createActiveTarget } from './first-party/active-target/factory.js';
+export { createBoardEvents } from './first-party/board-events/factory.js';
+export { createLastMove } from './first-party/last-move/factory.js';
+export { createLegalMoves } from './first-party/legal-moves/factory.js';
+export { createMainRenderer } from './first-party/main-renderer/factory.js';
+export { createSelectedSquare } from './first-party/selected-square/factory.js';

package/dist/extensions/invalidation/factory.d.ts

@@ -1,2 +1,2 @@
-import type { ExtensionInvalidationState } from './types';
+import type { ExtensionInvalidationState } from './types.js';
 export declare function createExtensionInvalidationState(): ExtensionInvalidationState;

package/dist/extensions/types/basic/events.d.ts

@@ -1,34 +1,11 @@
-import { Square } from '../../../state/board/types/internal';
-import { ScenePoint } from '../basic/transient-visuals';
-interface SceneEventBase {
-    readonly defaultPrevented: boolean;
-    preventDefault(): void;
+import { Square } from '../../../state/board/types/internal.js';
+import { ScenePoint } from '../basic/transient-visuals.js';
+export interface ScenePointerEvent {
+    readonly type: 'pointercancel' | 'pointerdown' | 'pointerenter' | 'pointerleave' | 'pointermove' | 'pointerout' | 'pointerover' | 'pointerrawupdate' | 'pointerup';
+    readonly point: ScenePoint;
+    readonly clampedPoint: ScenePoint;
+    readonly boardClampedPoint: ScenePoint | null;
+    readonly targetSquare: Square | null;
 }
-export interface ScenePointerEvent extends SceneEventBase {
-    readonly type: 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel' | 'pointerleave';
-    readonly pointerId: number;
-    readonly isPrimary: boolean;
-    readonly button: number;
-    readonly buttons: number;
-    readonly ctrlKey: boolean;
-    readonly altKey: boolean;
-    readonly shiftKey: boolean;
-    readonly metaKey: boolean;
-    readonly rawPoint: ScenePoint | null;
-    readonly clampedPoint: ScenePoint | null;
-    readonly target: Square | null;
-}
-export type ScenePointerEventType = ScenePointerEvent['type'];
-export declare const SCENE_POINTER_EVENT_TYPES: ScenePointerEventType[];
-export interface SceneKeyboardEvent extends SceneEventBase {
-    readonly type: 'keydown' | 'keyup';
-    readonly key: string;
-    readonly repeat: boolean;
-    readonly ctrlKey: boolean;
-    readonly altKey: boolean;
-    readonly shiftKey: boolean;
-    readonly metaKey: boolean;
-}
-export type SceneEvent = ScenePointerEvent | SceneKeyboardEvent;
-export type SceneEventType = SceneEvent['type'];
-export {};
+export declare const ALL_SCENE_POINTER_EVENT_TYPES: ReadonlySet<string>;
+export type SceneEvent = ScenePointerEvent;

package/dist/extensions/types/basic/events.js

@@ -1,7 +1,11 @@
-export const SCENE_POINTER_EVENT_TYPES = [
+export const ALL_SCENE_POINTER_EVENT_TYPES = new Set([
+    'pointercancel',
     'pointerdown',
+    'pointerenter',
+    'pointerleave',
     'pointermove',
-    'pointerup',
-    'pointercancel',
-    'pointerleave'
-];
+    'pointerout',
+    'pointerover',
+    'pointerrawupdate',
+    'pointerup'
+]);

package/dist/extensions/types/basic/interaction.d.ts

@@ -0,0 +1,21 @@
+import { ReadonlyDeep } from 'type-fest';
+import type { PieceCode, Square } from '../../../state/board/types/internal.js';
+export interface ExtensionDragSessionBase {
+    sourceSquare: Square | null;
+    sourcePieceCode: PieceCode | null;
+    targetSquare: Square | null;
+}
+export interface ExtensionDragSessionLiftedPiece extends ExtensionDragSessionBase {
+    type: 'lifted-piece-drag';
+    sourcePieceCode: PieceCode;
+}
+export interface ExtensionDragSessionReleaseTargeting extends ExtensionDragSessionBase {
+    type: 'release-targeting';
+}
+type ExtensionCustomDragSessionType = `ext:${string}`;
+export interface ExtensionDragSessionCustom extends ExtensionDragSessionBase {
+    type: ExtensionCustomDragSessionType;
+}
+export type ExtensionDragSession = ExtensionDragSessionLiftedPiece | ExtensionDragSessionReleaseTargeting | ExtensionDragSessionCustom;
+export type ExtensionDragSessionSnapshot = ReadonlyDeep<ExtensionDragSession>;
+export {};

package/dist/extensions/types/basic/render.d.ts

@@ -1,5 +1,5 @@
-import { LayoutSnapshot } from '../../../layout/types';
-import { RuntimeStateSnapshot } from '../../../state/types';
+import { LayoutSnapshot } from '../../../layout/types.js';
+import { RuntimeStateSnapshot } from '../../../state/types.js';
 export interface RenderLayoutSnapshot extends LayoutSnapshot {
     readonly geometry: NonNullable<LayoutSnapshot['geometry']>;
 }

package/dist/extensions/types/basic/transient-visuals.d.ts

@@ -1,10 +1,11 @@
-import { Square } from '../../../state/board/types/internal';
+import { Square } from '../../../state/board/types/internal.js';
 export interface ScenePoint {
     readonly x: number;
     readonly y: number;
 }
 export interface TransientInput {
     target: Square | null;
-    rawPoint: ScenePoint;
+    point: ScenePoint;
     clampedPoint: ScenePoint;
+    boardClampedPoint: ScenePoint;
 }

package/dist/extensions/types/basic/update.d.ts

@@ -1,6 +1,6 @@
-import { LayoutSnapshot } from '../../../layout/types';
-import { RuntimeStateSnapshot } from '../../../state/types';
-import { RenderFrameSnapshot } from './render';
+import { LayoutSnapshot } from '../../../layout/types.js';
+import { RuntimeStateSnapshot } from '../../../state/types.js';
+import { RenderFrameSnapshot } from './render.js';
 export interface UpdateFrameSnapshotUnmounted {
     readonly isMounted: false;
     readonly state: RuntimeStateSnapshot;