@mirasen/chessboard 0.1.0

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

@@ -0,0 +1,18 @@
+import { PartialDeep } from 'type-fest';
+import { ExtensionDefinition, ExtensionInstance } from '../../types/extension';
+import { ExtensionInternal, OpaqueColor } from '../common/types';
+export declare const EXTENSION_SLOTS: readonly ["underPieces"];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "selectedSquare";
+export type SelectedSquareConfig = OpaqueColor;
+export declare const DEFAULT_CONFIG: SelectedSquareConfig;
+export type SelectedSquareInitConfig = PartialDeep<SelectedSquareConfig>;
+export type SelectedSquareDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export type SelectedSquareInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export interface SelectedSquareInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
+    svgRect: SVGRectElement | null;
+    readonly config: SelectedSquareConfig;
+}
+export declare const enum DirtyLayer {
+    Highlight = 1
+}

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

@@ -0,0 +1,6 @@
+export const EXTENSION_SLOTS = ['underPieces'];
+export const EXTENSION_ID = 'selectedSquare';
+export const DEFAULT_CONFIG = {
+    color: 'rgba(255, 255, 0)',
+    opacity: 0.4
+};

package/dist/extensions/index.d.ts

@@ -0,0 +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';

package/dist/extensions/index.js

@@ -0,0 +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';

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

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

package/dist/extensions/invalidation/factory.js

@@ -0,0 +1,22 @@
+function createExtensionInvalidationStateInternal() {
+    return {
+        dirtyLayers: 0
+    };
+}
+export function createExtensionInvalidationState() {
+    const internalState = createExtensionInvalidationStateInternal();
+    return {
+        get dirtyLayers() {
+            return internalState.dirtyLayers;
+        },
+        markDirty(layers) {
+            internalState.dirtyLayers |= layers;
+        },
+        clearDirty(layers) {
+            internalState.dirtyLayers &= ~layers;
+        },
+        clear() {
+            internalState.dirtyLayers = 0;
+        }
+    };
+}

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

@@ -0,0 +1,11 @@
+export interface ExtensionInvalidationStateInternal {
+    dirtyLayers: number;
+}
+export interface ExtensionReadonlyInvalidationState {
+    readonly dirtyLayers: number;
+}
+export interface ExtensionInvalidationState extends ExtensionReadonlyInvalidationState {
+    markDirty(layers: number): void;
+    clearDirty(layers: number): void;
+    clear(): void;
+}

package/dist/extensions/invalidation/types.js

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

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

@@ -0,0 +1,28 @@
+export type ExtensionAnimationSessionStatus = 'submitted' | 'active' | 'ended' | 'cancelled';
+export declare const ANIMATION_SESSION_STATUS_ALL: Set<ExtensionAnimationSessionStatus>;
+export interface ExtensionAnimationSessionSubmitOptions {
+    duration: number;
+}
+export interface ExtensionAnimationSession {
+    readonly id: number;
+    readonly startTime: DOMHighResTimeStamp;
+    readonly duration: number;
+    readonly status: ExtensionAnimationSessionStatus;
+}
+export interface ExtensionAnimationController {
+    submit(options: ExtensionAnimationSessionSubmitOptions): ExtensionAnimationSession;
+    cancel(sessionId: number): void;
+    getAll(status?: ExtensionAnimationSessionStatus | Iterable<ExtensionAnimationSessionStatus>): readonly ExtensionAnimationSession[];
+}
+export interface ExtensionAnimationSessionInternalSurface extends ExtensionAnimationSession {
+    readonly elapsedTime: DOMHighResTimeStamp;
+    readonly progress: number;
+    readonly pendingCleanup: boolean;
+    setStatus(status: ExtensionAnimationSessionStatus): void;
+    markPendingCleanup(): void;
+}
+export interface ExtensionAnimationControllerInternalSurface extends ExtensionAnimationController {
+    getAll(status?: ExtensionAnimationSessionStatus | Iterable<ExtensionAnimationSessionStatus>): readonly ExtensionAnimationSessionInternalSurface[];
+    remove(sessionId: number | Iterable<number>): void;
+    clear(): void;
+}

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

@@ -0,0 +1,6 @@
+export const ANIMATION_SESSION_STATUS_ALL = new Set([
+    'submitted',
+    'active',
+    'ended',
+    'cancelled'
+]);

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

@@ -0,0 +1,34 @@
+import { Square } from '../../../state/board/types/internal';
+import { ScenePoint } from '../basic/transient-visuals';
+interface SceneEventBase {
+    readonly defaultPrevented: boolean;
+    preventDefault(): void;
+}
+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 {};

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

@@ -0,0 +1,7 @@
+export const SCENE_POINTER_EVENT_TYPES = [
+    'pointerdown',
+    'pointermove',
+    'pointerup',
+    'pointercancel',
+    'pointerleave'
+];

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

@@ -0,0 +1,7 @@
+export type ExtensionSlotName = 'defs' | 'board' | 'coordinates' | 'underPieces' | 'pieces' | 'overPieces' | 'animation' | 'underDrag' | 'drag' | 'overDrag';
+export declare const ALL_EXTENSION_SLOTS: readonly ["defs", "board", "coordinates", "underPieces", "pieces", "overPieces", "animation", "underDrag", "drag", "overDrag"];
+export type ExtensionSlotSvgRoots<TSlots extends readonly ExtensionSlotName[]> = Readonly<Record<TSlots[number], SVGGElement>>;
+export type ExtensionAllocatedSlotsInternal = Partial<ExtensionSlotSvgRoots<readonly ExtensionSlotName[]>>;
+export interface ExtensionInstanceMountOptions<TSlots extends readonly ExtensionSlotName[]> {
+    slotRoots: ExtensionSlotSvgRoots<TSlots>;
+}

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

@@ -0,0 +1,14 @@
+export const ALL_EXTENSION_SLOTS = [
+    'defs',
+    'board',
+    'coordinates',
+    'underPieces',
+    'pieces',
+    'overPieces',
+    'animation',
+    'underDrag',
+    'drag',
+    'overDrag'
+];
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _checkAllExtensionSlotsExact = true;

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

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

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

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

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

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

package/dist/extensions/types/basic/transient-visuals.js

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

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

@@ -0,0 +1,16 @@
+import { LayoutSnapshot } from '../../../layout/types';
+import { RuntimeStateSnapshot } from '../../../state/types';
+import { RenderFrameSnapshot } from './render';
+export interface UpdateFrameSnapshotUnmounted {
+    readonly isMounted: false;
+    readonly state: RuntimeStateSnapshot;
+}
+export interface UpdateFrameSnapshotMounted {
+    readonly isMounted: true;
+    readonly state: RuntimeStateSnapshot;
+    readonly layout: LayoutSnapshot;
+}
+export type UpdateFrameSnapshot = UpdateFrameSnapshotUnmounted | UpdateFrameSnapshotMounted;
+export declare function isFrameMounted<T extends UpdateFrameSnapshot>(frame: T): frame is T & UpdateFrameSnapshotMounted;
+export declare function isFrameRenderable<T extends UpdateFrameSnapshot>(frame: T): frame is T & RenderFrameSnapshot;
+export declare function assertFrameRenderable<T extends UpdateFrameSnapshot>(frame: T): asserts frame is T & RenderFrameSnapshot;

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

@@ -0,0 +1,11 @@
+export function isFrameMounted(frame) {
+    return frame.isMounted;
+}
+export function isFrameRenderable(frame) {
+    return frame.isMounted && frame.layout.geometry !== null;
+}
+export function assertFrameRenderable(frame) {
+    if (!isFrameRenderable(frame)) {
+        throw new Error('Frame is not renderable. It must be mounted and have valid geometry.');
+    }
+}

package/dist/extensions/types/context/animation.d.ts

@@ -0,0 +1,31 @@
+import { ExtensionInvalidationState } from '../../invalidation/types';
+import { ExtensionAnimationSession } from '../basic/animation';
+import { ExtensionRenderContext } from './render';
+export interface ExtensionSubmittedAnimationSession extends ExtensionAnimationSession {
+    readonly status: 'submitted';
+}
+export interface ExtensionActiveAnimationSession extends ExtensionAnimationSession {
+    readonly status: 'active';
+    readonly elapsedTime: DOMHighResTimeStamp;
+    readonly progress: number;
+}
+export interface ExtensionFinishedAnimationSession extends ExtensionAnimationSession {
+    readonly status: 'ended' | 'cancelled';
+}
+export interface ExtensionPrepareAnimationContext extends ExtensionRenderContext {
+    readonly submittedSessions: readonly ExtensionSubmittedAnimationSession[];
+}
+export interface ExtensionRenderAnimationContext extends ExtensionRenderContext {
+    readonly activeSessions: readonly ExtensionActiveAnimationSession[];
+}
+export interface ExtensionAnimationFinishedContext extends ExtensionRenderContext {
+    readonly invalidation: ExtensionInvalidationState;
+    readonly finishedSessions: readonly ExtensionFinishedAnimationSession[];
+}
+export interface ExtensionCleanAnimationContext extends ExtensionRenderContext {
+    readonly invalidation: ExtensionInvalidationState;
+    readonly finishedSessions: readonly ExtensionFinishedAnimationSession[];
+}
+export declare function isExtensionSubmittedAnimationSession(session: ExtensionAnimationSession): session is ExtensionSubmittedAnimationSession;
+export declare function isExtensionActiveAnimationSession(session: ExtensionAnimationSession): session is ExtensionActiveAnimationSession;
+export declare function isExtensionFinishedAnimationSession(session: ExtensionAnimationSession): session is ExtensionFinishedAnimationSession;

package/dist/extensions/types/context/animation.js

@@ -0,0 +1,9 @@
+export function isExtensionSubmittedAnimationSession(session) {
+    return session.status === 'submitted';
+}
+export function isExtensionActiveAnimationSession(session) {
+    return session.status === 'active';
+}
+export function isExtensionFinishedAnimationSession(session) {
+    return session.status === 'ended' || session.status === 'cancelled';
+}

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

@@ -0,0 +1,6 @@
+import { ExtensionReadonlyInvalidationState } from '../../invalidation/types';
+import { RenderFrameSnapshot } from '../basic/render';
+export interface ExtensionRenderContext {
+    readonly currentFrame: RenderFrameSnapshot;
+    readonly invalidation: ExtensionReadonlyInvalidationState;
+}

package/dist/extensions/types/context/render.js

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

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

@@ -0,0 +1,7 @@
+import { ReadonlyDeep } from 'type-fest';
+import { RenderFrameSnapshot } from '../basic/render';
+import { TransientInput } from '../basic/transient-visuals';
+export interface ExtensionRenderTransientVisualsContext {
+    readonly currentFrame: RenderFrameSnapshot;
+    readonly transientInput: ReadonlyDeep<TransientInput>;
+}

package/dist/extensions/types/context/transient-visuals.js

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

package/dist/extensions/types/context/ui-move.d.ts

@@ -0,0 +1,16 @@
+import { MoveRequest, Square } from '../../../state/board/types/internal';
+import { MoveDestinationSnapshot } from '../../../state/interaction/types/internal';
+export type ExtensionUIMoveRequestStatus = 'unresolved' | 'deferred' | 'resolved';
+export interface ExtensionUIMoveRequestContextSnapshot {
+    readonly status: ExtensionUIMoveRequestStatus;
+    readonly sourceSquare: Square;
+    readonly destination: MoveDestinationSnapshot;
+    readonly canBeAutoResolved: boolean;
+    readonly resolvedMoveRequest: MoveRequest | null;
+}
+export interface ExtensionUIMoveRequestContext extends ExtensionUIMoveRequestContextSnapshot {
+    defer(): void;
+    resolve(request: MoveRequest): void;
+    autoresolve(): void;
+    getSnapshot(): ExtensionUIMoveRequestContextSnapshot;
+}

package/dist/extensions/types/context/ui-move.js

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

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

@@ -0,0 +1,25 @@
+import { RuntimeReadonlyMutationSession } from '../../../runtime/mutation/types';
+import { ExtensionInvalidationState } from '../../invalidation/types';
+import { RenderFrameSnapshot } from '../basic/render';
+import { UpdateFrameSnapshot, UpdateFrameSnapshotMounted, UpdateFrameSnapshotUnmounted } from '../basic/update';
+export interface ExtensionUpdateContextCommon {
+    readonly previousFrame: UpdateFrameSnapshot | null;
+    readonly mutation: RuntimeReadonlyMutationSession;
+    readonly currentFrame: UpdateFrameSnapshot;
+}
+export interface ExtensionUpdateContextCommonUnmounted extends ExtensionUpdateContextCommon {
+    readonly currentFrame: UpdateFrameSnapshotUnmounted;
+}
+export interface ExtensionUpdateContextCommonMounted extends ExtensionUpdateContextCommon {
+    readonly currentFrame: UpdateFrameSnapshotMounted;
+}
+export type ExtensionUpdateContextUnmounted = ExtensionUpdateContextCommonUnmounted;
+export interface ExtensionUpdateContextMounted extends ExtensionUpdateContextCommonMounted {
+    readonly invalidation: ExtensionInvalidationState;
+}
+export type ExtensionUpdateContext = ExtensionUpdateContextUnmounted | ExtensionUpdateContextMounted;
+export declare function isUpdateContextCommonMounted<T extends ExtensionUpdateContextCommon>(context: T): context is T & ExtensionUpdateContextCommonMounted;
+export declare function isUpdateContextMounted<T extends ExtensionUpdateContext>(context: T): context is T & ExtensionUpdateContextMounted;
+export declare function isUpdateContextRenderable<T extends ExtensionUpdateContext>(context: T): context is T & ExtensionUpdateContextMounted & {
+    currentFrame: RenderFrameSnapshot;
+};

package/dist/extensions/types/context/update.js

@@ -0,0 +1,10 @@
+import { isFrameMounted, isFrameRenderable } from '../basic/update';
+export function isUpdateContextCommonMounted(context) {
+    return isFrameMounted(context.currentFrame);
+}
+export function isUpdateContextMounted(context) {
+    return isFrameMounted(context.currentFrame);
+}
+export function isUpdateContextRenderable(context) {
+    return isFrameRenderable(context.currentFrame);
+}

package/dist/extensions/types/extension.d.ts

@@ -0,0 +1,40 @@
+import { SceneEvent } from './basic/events';
+import { ExtensionInstanceMountOptions, ExtensionSlotName } from './basic/mount';
+import { ExtensionAnimationFinishedContext, ExtensionCleanAnimationContext, ExtensionPrepareAnimationContext, ExtensionRenderAnimationContext } from './context/animation';
+import { ExtensionRenderContext } from './context/render';
+import { ExtensionRenderTransientVisualsContext } from './context/transient-visuals';
+import { ExtensionUIMoveRequestContext } from './context/ui-move';
+import { ExtensionUpdateContext } from './context/update';
+import { ExtensionRuntimeSurface } from './surface/main';
+interface ExtensionInstanceBase<TId extends string, TSlots extends readonly ExtensionSlotName[]> {
+    readonly id: TId;
+    mount(env: ExtensionInstanceMountOptions<TSlots>): void;
+    unmount(): void;
+    destroy(): void;
+    onUpdate(context: ExtensionUpdateContext): void;
+    onUIMoveRequest?(context: ExtensionUIMoveRequestContext): void;
+    render?(context: ExtensionRenderContext): void;
+    prepareAnimation?(context: ExtensionPrepareAnimationContext): void;
+    renderAnimation?(context: ExtensionRenderAnimationContext): void;
+    onAnimationFinished?(context: ExtensionAnimationFinishedContext): void;
+    cleanAnimation?(context: ExtensionCleanAnimationContext): void;
+    renderTransientVisuals?(context: ExtensionRenderTransientVisualsContext): void;
+    onEvent?(event: SceneEvent): void;
+}
+type ExtensionInstancePublicPart<TPublic> = [TPublic] extends [never] ? Record<never, never> : {
+    getPublic(): TPublic;
+};
+export type ExtensionInstance<TId extends string, TSlots extends readonly ExtensionSlotName[], TPublic = never> = ExtensionInstanceBase<TId, TSlots> & ExtensionInstancePublicPart<TPublic>;
+export type AnyExtensionInstance = ExtensionInstance<string, readonly ExtensionSlotName[], unknown>;
+export interface ExtensionCreateInstanceOptions {
+    runtimeSurface: ExtensionRuntimeSurface;
+}
+export interface ExtensionDefinition<TId extends string, TSlots extends readonly ExtensionSlotName[], TPublic> {
+    readonly id: TId;
+    readonly slots: TSlots;
+    createInstance(options: ExtensionCreateInstanceOptions): ExtensionInstance<TId, TSlots, TPublic>;
+}
+export type AnyExtensionDefinition = ExtensionDefinition<string, readonly ExtensionSlotName[], unknown>;
+export type ExtensionDefinitionId<T> = T extends ExtensionDefinition<infer TId, readonly ExtensionSlotName[], unknown> ? TId : never;
+export type ExtensionDefinitionPublicApi<T> = T extends ExtensionDefinition<string, readonly ExtensionSlotName[], infer TPublicApi> ? TPublicApi : never;
+export {};

package/dist/extensions/types/extension.js

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

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

@@ -0,0 +1,44 @@
+import { RuntimeReadonlyMutationSession } from '../../runtime/mutation/types';
+import { ExtensionInvalidationState } from '../invalidation/types';
+import { ExtensionAnimationControllerInternalSurface } from './basic/animation';
+import { SceneEventType } from './basic/events';
+import { UpdateFrameSnapshot } from './basic/update';
+import { ExtensionUIMoveRequestContext } from './context/ui-move';
+import { AnyExtensionDefinition, AnyExtensionInstance } from './extension';
+import { ExtensionRuntimeSurfaceCommands } from './surface/commands';
+export interface ExtensionSystemExtensionRecord {
+    readonly id: string;
+    readonly definition: AnyExtensionDefinition;
+    readonly instance: AnyExtensionInstance;
+    readonly invalidation: ExtensionInvalidationState;
+    readonly animation: ExtensionAnimationControllerInternalSurface;
+}
+export interface ExtensionSystemInitOptions {
+    extensionRuntimeSurfaceCommands: ExtensionRuntimeSurfaceCommands;
+    extensions?: readonly AnyExtensionDefinition[];
+}
+export interface ExtensionSystemInternal {
+    readonly extensions: Map<string, ExtensionSystemExtensionRecord>;
+    readonly transientVisualsSubscribers: Set<string>;
+    readonly eventSubscribers: Map<string, Set<SceneEventType>>;
+    currentFrame: UpdateFrameSnapshot | null;
+}
+export interface ExtensionSystemUpdateRequest {
+    readonly state: UpdateFrameSnapshot;
+    readonly mutation: RuntimeReadonlyMutationSession;
+}
+export interface ExtensionSystemSharedDataForRenderSystem {
+    readonly extensions: ReadonlyMap<string, ExtensionSystemExtensionRecord>;
+    readonly transientVisualsSubscribers: ReadonlySet<string>;
+}
+export interface ExtensionSystem {
+    readonly currentFrame: UpdateFrameSnapshot | null;
+    readonly hasSubmittedAnimations: boolean;
+    getPublicRecord(): Readonly<Record<string, unknown>>;
+    getSharedDataForRenderSystem(): ExtensionSystemSharedDataForRenderSystem;
+    onUpdate(request: ExtensionSystemUpdateRequest): void;
+    onUIMoveRequest(context: ExtensionUIMoveRequestContext): void;
+    onUnmount(): void;
+    onDestroy(): void;
+}
+export type GetInternalState = () => ExtensionSystemInternal;

package/dist/extensions/types/main.js

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

package/dist/extensions/types/surface/commands.d.ts

@@ -0,0 +1,26 @@
+import { LayoutSnapshot } from '../../../layout/types';
+import { ColorInput, MoveRequestInput, PiecePositionInput, PositionInput, SquareString } from '../../../state/board/types/input';
+import { Move } from '../../../state/board/types/internal';
+import { MovabilityInput } from '../../../state/interaction/types/input';
+import { RuntimeStateSnapshot } from '../../../state/types';
+export interface ExtensionRuntimeSurfaceCommandsSnapshot {
+    readonly state: RuntimeStateSnapshot;
+    readonly layout: LayoutSnapshot;
+}
+export interface ExtensionRuntimeSurfaceCommandsRenderRequest {
+    state?: boolean;
+    animation?: boolean;
+}
+export interface ExtensionRuntimeSurfaceCommands {
+    setPosition(input: PositionInput): boolean;
+    setPiecePosition(input: PiecePositionInput): boolean;
+    setTurn(turn: ColorInput): boolean;
+    move(request: MoveRequestInput): Move;
+    setOrientation(orientation: ColorInput): boolean;
+    setMovability(movability: MovabilityInput): boolean;
+    select(square: SquareString | null): boolean;
+    clearActiveInteraction(): boolean;
+    clearInteraction(): boolean;
+    requestRender(request: ExtensionRuntimeSurfaceCommandsRenderRequest): void;
+    getSnapshot(): ExtensionRuntimeSurfaceCommandsSnapshot;
+}

package/dist/extensions/types/surface/commands.js

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

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

@@ -0,0 +1,5 @@
+import { SceneEventType } from '../basic/events';
+export interface ExtensionRuntimeSurfaceEvents {
+    subscribe(events: Iterable<SceneEventType>): void;
+    unsubscribe(events?: Iterable<SceneEventType>): void;
+}

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

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

package/dist/extensions/types/surface/main.d.ts

@@ -0,0 +1,10 @@
+import { ExtensionAnimationController } from '../basic/animation';
+import { ExtensionRuntimeSurfaceCommands } from './commands';
+import { ExtensionRuntimeSurfaceEvents } from './events';
+import { ExtensionRuntimeSurfaceTransientVisuals } from './transient-visuals';
+export interface ExtensionRuntimeSurface {
+    readonly commands: ExtensionRuntimeSurfaceCommands;
+    readonly animation: ExtensionAnimationController;
+    readonly events: ExtensionRuntimeSurfaceEvents;
+    readonly transientVisuals: ExtensionRuntimeSurfaceTransientVisuals;
+}

package/dist/extensions/types/surface/main.js

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

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

@@ -0,0 +1,4 @@
+export interface ExtensionRuntimeSurfaceTransientVisuals {
+    subscribe(): void;
+    unsubscribe(): void;
+}

package/dist/extensions/types/surface/transient-visuals.js

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

package/dist/extensions/types/wrapper.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Public built-in extension ids accepted by createBoard({ extensions })
+ */
+import { ActiveTargetDefinition } from '../first-party/active-target/types';
+import { BoardEventsDefinition } from '../first-party/board-events/types';
+import { LastMoveDefinition } from '../first-party/last-move/types';
+import { LegalMovesDefinition } from '../first-party/legal-moves/types';
+import { MainRendererDefinition } from '../first-party/main-renderer/types/extension';
+import { SelectedSquareDefinition } from '../first-party/selected-square/types';
+export declare const DefaultBuiltinChessboardExtensions: readonly ["mainRenderer", "events", "selectedSquare", "activeTarget", "legalMoves", "lastMove"];
+export type BuiltInExtensionId = (typeof DefaultBuiltinChessboardExtensions)[number];
+/**
+ * Default built-in extensions used when createBoard(...) receives no extensions option
+ */
+export type DefaultBuiltinChessboardExtensions = typeof DefaultBuiltinChessboardExtensions;
+/**
+ * Map built-in public ids -> concrete extension definition types
+ */
+export interface BuiltInExtensionDefinitionMap {
+    mainRenderer: MainRendererDefinition;
+    events: BoardEventsDefinition;
+    selectedSquare: SelectedSquareDefinition;
+    activeTarget: ActiveTargetDefinition;
+    legalMoves: LegalMovesDefinition;
+    lastMove: LastMoveDefinition;
+}

package/dist/extensions/types/wrapper.js

@@ -0,0 +1,11 @@
+/**
+ * Public built-in extension ids accepted by createBoard({ extensions })
+ */
+export const DefaultBuiltinChessboardExtensions = [
+    'mainRenderer',
+    'events',
+    'selectedSquare',
+    'activeTarget',
+    'legalMoves',
+    'lastMove'
+];

package/dist/extensions/update.d.ts

@@ -0,0 +1,4 @@
+import { ExtensionUIMoveRequestContext } from './types/context/ui-move';
+import { ExtensionSystemInternal, ExtensionSystemUpdateRequest } from './types/main';
+export declare function extensionSystemUpdateState(state: ExtensionSystemInternal, request: ExtensionSystemUpdateRequest): void;
+export declare function extensionSystemUpdateUIMoveRequest(state: ExtensionSystemInternal, context: ExtensionUIMoveRequestContext): void;

package/dist/extensions/update.js

@@ -0,0 +1,29 @@
+import { isUpdateContextCommonMounted } from './types/context/update';
+export function extensionSystemUpdateState(state, request) {
+    // Prepare base context
+    const contextCommon = {
+        previousFrame: state.currentFrame,
+        mutation: request.mutation,
+        currentFrame: request.state
+    };
+    // Update invalidation state based on the new request
+    for (const extension of state.extensions.values()) {
+        const context = isUpdateContextCommonMounted(contextCommon)
+            ? {
+                ...contextCommon,
+                invalidation: extension.invalidation
+            }
+            : {
+                ...contextCommon
+            };
+        extension.instance.onUpdate(context);
+    }
+    state.currentFrame = request.state;
+}
+export function extensionSystemUpdateUIMoveRequest(state, context) {
+    for (const extension of state.extensions.values()) {
+        if (extension.instance.onUIMoveRequest) {
+            extension.instance.onUIMoveRequest(context);
+        }
+    }
+}

package/dist/helpers/util.d.ts

@@ -0,0 +1 @@
+export declare function setsEqual<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean;

package/dist/helpers/util.js

@@ -0,0 +1,9 @@
+export function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const value of a) {
+        if (!b.has(value))
+            return false;
+    }
+    return true;
+}