@mirasen/chessboard 0.1.0

package/dist/state/factory.js

@@ -0,0 +1,24 @@
+import { createBoardState } from './board/factory';
+import { createChangeState } from './change/factory';
+import { createInteractionState } from './interaction/factory';
+import { createViewState } from './view/factory';
+function createRuntimeStateInternal(options) {
+    return {
+        board: createBoardState(options.board ?? {}),
+        view: createViewState(options.view ?? {}),
+        interaction: createInteractionState(options.interaction ?? {}),
+        change: createChangeState()
+    };
+}
+export function createRuntimeState(options) {
+    const internalState = createRuntimeStateInternal(options);
+    return {
+        ...internalState,
+        getSnapshot: () => ({
+            board: internalState.board.getSnapshot(),
+            view: internalState.view.getSnapshot(),
+            interaction: internalState.interaction.getSnapshot(),
+            change: internalState.change.getSnapshot()
+        })
+    };
+}

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

@@ -0,0 +1,2 @@
+import { InteractionState, InteractionStateInitOptions } from './types/main';
+export declare function createInteractionState(options: InteractionStateInitOptions): InteractionState;

package/dist/state/interaction/factory.js

@@ -0,0 +1,83 @@
+import assert from '@ktarmyshov/assert';
+import { cloneDeep } from 'es-toolkit';
+import { updateActiveDestinations } from './helpers';
+import { normalizeMovability } from './normalize';
+import { interactionClear, interactionClearActive, interactionSetDragSession, interactionSetMovability, interactionSetSelected, interactionUpdateDragSessionCurrentTarget } from './reducers';
+const DefaultMovabilityDisabled = { mode: 0 /* MovabilityModeCode.Disabled */ };
+/**
+ * Create a fresh interaction state with all fields set to null or false.
+ */
+function createInteractionStateInternal(options) {
+    const movability = options.movability
+        ? normalizeMovability(options.movability)
+        : DefaultMovabilityDisabled;
+    return {
+        movability,
+        selected: null,
+        activeDestinations: new Map(),
+        dragSession: null
+    };
+}
+export function createInteractionState(options) {
+    const internalState = createInteractionStateInternal(options);
+    return {
+        get selected() {
+            return cloneDeep(internalState.selected);
+        },
+        setSelected(selected, mutationSession) {
+            const changed = mutationSession.addMutation('state.interaction.setSelectedSquare', interactionSetSelected(internalState, selected));
+            if (!changed)
+                return false; // no-op
+            updateActiveDestinations(internalState, mutationSession);
+            return changed;
+        },
+        get movability() {
+            return cloneDeep(internalState.movability);
+        },
+        setMovability(movability, mutationSession) {
+            const changed = mutationSession.addMutation('state.interaction.setMovability', interactionSetMovability(internalState, normalizeMovability(movability)));
+            if (!changed)
+                return false; // no-op
+            updateActiveDestinations(internalState, mutationSession);
+            return changed;
+        },
+        get activeDestinations() {
+            return cloneDeep(internalState.activeDestinations);
+        },
+        updateActiveDestinations(mutationSession) {
+            return updateActiveDestinations(internalState, mutationSession);
+        },
+        get dragSession() {
+            return internalState.dragSession ? { ...internalState.dragSession } : null;
+        },
+        setDragSession(session, mutationSession) {
+            // Assert that the selected is the same as the source of the drag session when setting a lifted-piece-drag session
+            if (session) {
+                assert(internalState.selected, 'There must be a selected piece to start a drag session');
+                if (session.type === 'lifted-piece-drag') {
+                    assert(internalState.selected, 'There must be a selected piece to start a lifted-piece-drag session');
+                    assert(session.sourceSquare === internalState.selected.square, 'The source square of the lifted-piece-drag session must match the selected square');
+                    assert(session.sourcePieceCode === internalState.selected.pieceCode, 'The source piece code of the lifted-piece-drag session must match the selected piece code');
+                }
+            }
+            return mutationSession.addMutation('state.interaction.setDragSession', interactionSetDragSession(internalState, session));
+        },
+        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));
+        },
+        clear(mutationSession) {
+            const changed = mutationSession.addMutation('state.interaction.clear', interactionClear(internalState));
+            if (!changed)
+                return false; // no-op
+            updateActiveDestinations(internalState, mutationSession);
+            return true;
+        },
+        clearActive(mutationSession) {
+            return mutationSession.addMutation('state.interaction.clearActive', interactionClearActive(internalState));
+        },
+        getSnapshot() {
+            return cloneDeep(internalState);
+        }
+    };
+}

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

@@ -0,0 +1,4 @@
+import { InteractionStateMutationSession } from './mutation';
+import { InteractionStateInternal, InteractionStateSelected } from './types/main';
+export declare function selectedEqual(a: InteractionStateSelected | null, b: InteractionStateSelected | null): boolean;
+export declare function updateActiveDestinations(state: InteractionStateInternal, mutationSession: InteractionStateMutationSession): boolean;

package/dist/state/interaction/helpers.js

@@ -0,0 +1,16 @@
+import { getActiveDestinations } from './movability';
+import { interactionSetActiveDestinations } from './reducers';
+export function selectedEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    return a.square === b.square && a.pieceCode === b.pieceCode;
+}
+export function updateActiveDestinations(state, mutationSession) {
+    if (!state.selected) {
+        return mutationSession.addMutation('state.interaction.updateActiveDestinations', interactionSetActiveDestinations(state, new Map()));
+    }
+    const activeDests = getActiveDestinations(state, state.selected.square);
+    return mutationSession.addMutation('state.interaction.updateActiveDestinations', interactionSetActiveDestinations(state, activeDests));
+}

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

@@ -0,0 +1,5 @@
+import type { Square } from '../board/types/internal';
+import { MoveDestinationSnapshot, type MovabilitySnapshot } from './types/internal';
+import { InteractionStateInternal } from './types/main';
+export declare function movabilitiesEqual(a: MovabilitySnapshot, b: MovabilitySnapshot): boolean;
+export declare function getActiveDestinations(state: InteractionStateInternal, from: Square): ReadonlyMap<Square, MoveDestinationSnapshot>;

package/dist/state/interaction/movability.js

@@ -0,0 +1,87 @@
+import { setsEqual } from '../../helpers/util';
+import { assertValidSquare } from '../board/check';
+function moveDestinationsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    return (a.to === b.to &&
+        a.capturedSquare === b.capturedSquare &&
+        a.secondary?.from === b.secondary?.from &&
+        a.secondary?.to === b.secondary?.to &&
+        setsEqual(new Set(a.promotedTo ? a.promotedTo : []), new Set(b.promotedTo ? b.promotedTo : [])));
+}
+function recordToDestinationsMap(record) {
+    const map = new Map();
+    for (const [key, dests] of Object.entries(record)) {
+        if (dests) {
+            const square = Number(key);
+            assertValidSquare(square);
+            if (map.has(square)) {
+                throw new RangeError(`Duplicate square key in movability destinations: ${key}`);
+            }
+            map.set(square, dests);
+        }
+    }
+    return map;
+}
+export function movabilitiesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.mode !== b.mode)
+        return false;
+    switch (a.mode) {
+        case 0 /* MovabilityModeCode.Disabled */:
+            return true;
+        case 1 /* MovabilityModeCode.Free */:
+            return true;
+        case 2 /* MovabilityModeCode.Strict */: {
+            const aDests = a.destinations;
+            const bDests = b.destinations;
+            const aIsResolver = typeof aDests === 'function';
+            const bIsResolver = typeof bDests === 'function';
+            if (aIsResolver && bIsResolver)
+                return aDests === bDests;
+            if (aIsResolver !== bIsResolver)
+                return false;
+            const aMap = recordToDestinationsMap(aDests);
+            const bMap = recordToDestinationsMap(bDests);
+            if (aMap.size !== bMap.size)
+                return false;
+            for (const [sq, aDestArr] of aMap) {
+                const bDestArr = bMap.get(sq);
+                if (!bDestArr)
+                    return false;
+                if (aDestArr.length !== bDestArr.length)
+                    return false;
+                for (let i = 0; i < aDestArr.length; i++) {
+                    if (!moveDestinationsEqual(aDestArr[i], bDestArr[i]))
+                        return false;
+                }
+            }
+            return true;
+        }
+        default:
+            throw new RangeError(`Unhandled movability mode code: ${a}`);
+    }
+}
+export function getActiveDestinations(state, from) {
+    const movability = state.movability;
+    if (movability.mode === 0 /* MovabilityModeCode.Disabled */)
+        return new Map();
+    if (movability.mode === 1 /* MovabilityModeCode.Free */)
+        return new Map();
+    // strict mode: normalize and build a Map keyed by destination square
+    const dests = getDestinationsForSource(movability.destinations, from) ?? [];
+    const map = new Map();
+    for (const dest of dests) {
+        map.set(dest.to, dest);
+    }
+    return map;
+}
+function getDestinationsForSource(destinations, source) {
+    if (typeof destinations === 'function') {
+        return destinations(source);
+    }
+    return destinations[source];
+}

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

@@ -0,0 +1,11 @@
+import type { MutationSession } from '../../mutation/types';
+export type InteractionStateMutationPayloadByCause = {
+    'state.interaction.setSelectedSquare': undefined;
+    'state.interaction.setDragSession': undefined;
+    'state.interaction.updateDragSessionCurrentTarget': undefined;
+    'state.interaction.clear': undefined;
+    'state.interaction.clearActive': undefined;
+    'state.interaction.setMovability': undefined;
+    'state.interaction.updateActiveDestinations': undefined;
+};
+export type InteractionStateMutationSession = MutationSession<InteractionStateMutationPayloadByCause>;

package/dist/state/interaction/mutation.js

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

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

@@ -0,0 +1,5 @@
+import { ReadonlyDeep } from 'type-fest';
+import { MovabilityInput, MoveDestinationInput } from './types/input';
+import { Movability, MoveDestination } from './types/internal';
+export declare function normalizeMoveDestinationInput(destination: ReadonlyDeep<MoveDestinationInput>): MoveDestination;
+export declare function normalizeMovability(movability: MovabilityInput): Movability;

package/dist/state/interaction/normalize.js

@@ -0,0 +1,50 @@
+import { denormalizeSquare } from '../board/denormalize';
+import { normalizeRolePromotion, normalizeSquare } from '../board/normalize';
+export function normalizeMoveDestinationInput(destination) {
+    return {
+        to: normalizeSquare(destination.to),
+        ...(destination.capturedSquare && {
+            capturedSquare: normalizeSquare(destination.capturedSquare)
+        }),
+        ...(destination.secondary && {
+            secondary: {
+                from: normalizeSquare(destination.secondary.from),
+                to: normalizeSquare(destination.secondary.to)
+            }
+        }),
+        ...(destination.promotedTo && {
+            promotedTo: destination.promotedTo.map(normalizeRolePromotion)
+        })
+    };
+}
+export function normalizeMovability(movability) {
+    if (movability.mode === 'disabled') {
+        return { mode: 0 /* MovabilityModeCode.Disabled */ };
+    }
+    if (movability.mode === 'free') {
+        return { mode: 1 /* MovabilityModeCode.Free */ };
+    }
+    // Strict mode
+    let destinations;
+    if (typeof movability.destinations === 'function') {
+        const resolverInput = movability.destinations;
+        destinations = (source) => {
+            const inputDests = resolverInput(denormalizeSquare(source));
+            return inputDests ? inputDests.map(normalizeMoveDestinationInput) : undefined;
+        };
+        return {
+            mode: 2 /* MovabilityModeCode.Strict */,
+            destinations
+        };
+    }
+    // Destinations as record
+    const recordInput = movability.destinations;
+    const destinationsRecord = {};
+    for (const [sqStr, destInputs] of Object.entries(recordInput)) {
+        destinationsRecord[normalizeSquare(sqStr)] = destInputs.map(normalizeMoveDestinationInput);
+    }
+    return {
+        mode: 2 /* MovabilityModeCode.Strict */,
+        destinations: destinationsRecord
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { ReadonlyDeep } from 'type-fest';
+import type { Square } from '../board/types/internal';
+import { Movability, type DragSessionSnapshot, type MoveDestination } from './types/internal';
+import { InteractionStateInternal, InteractionStateSelected } from './types/main';
+export declare function interactionSetSelected(state: InteractionStateInternal, selected: InteractionStateSelected | null): boolean;
+export declare function interactionSetMovability(state: InteractionStateInternal, m: Movability): 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 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

@@ -0,0 +1,81 @@
+import assert from '@ktarmyshov/assert';
+import { cloneDeep } from 'es-toolkit/object';
+import { setsEqual } from '../../helpers/util';
+import { selectedEqual } from './helpers';
+import { movabilitiesEqual } from './movability';
+export function interactionSetSelected(state, selected) {
+    const notChanged = selectedEqual(state.selected, selected);
+    if (notChanged)
+        return false;
+    state.selected = selected ? { ...selected } : null;
+    return true;
+}
+export function interactionSetMovability(state, m) {
+    if (movabilitiesEqual(state.movability, m))
+        return false; // no-op
+    state.movability = cloneDeep(m); // Defensive copy to prevent external mutations
+    return true;
+}
+function promotedTosEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    return setsEqual(new Set(a), new Set(b));
+}
+function activeDestinationsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const [sq, aDest] of a) {
+        const bDest = b.get(sq);
+        if (!bDest)
+            return false;
+        if (aDest.to !== bDest.to ||
+            aDest.capturedSquare !== bDest.capturedSquare ||
+            aDest.secondary?.from !== bDest.secondary?.from ||
+            aDest.secondary?.to !== bDest.secondary?.to ||
+            !promotedTosEqual(aDest.promotedTo, bDest.promotedTo))
+            return false;
+    }
+    return true;
+}
+export function interactionSetActiveDestinations(state, dests) {
+    if (activeDestinationsEqual(state.activeDestinations, dests))
+        return false;
+    state.activeDestinations = new Map(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
+    state.dragSession = session ? cloneDeep(session) : null;
+    return true;
+}
+export function interactionUpdateDragSessionCurrentTarget(state, sq) {
+    const changed = state.dragSession?.targetSquare !== sq;
+    if (!changed)
+        return false;
+    assert(state.dragSession !== null, 'No active drag session to update target of');
+    state.dragSession.targetSquare = sq;
+    return true;
+}
+export function interactionClear(state) {
+    const anySet = state.selected !== null || state.activeDestinations.size > 0 || state.dragSession !== null;
+    if (!anySet)
+        return false;
+    state.selected = null;
+    state.activeDestinations = new Map();
+    state.dragSession = null;
+    return true;
+}
+export function interactionClearActive(state) {
+    const anyActive = state.dragSession !== null;
+    if (!anyActive)
+        return false;
+    state.dragSession = null;
+    return true;
+}

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

@@ -0,0 +1,18 @@
+import { MoveRequestInput, RolePromotionInput, SquareString } from '../../board/types/input';
+export interface MoveDestinationInput extends Omit<MoveRequestInput, 'from' | 'promotedTo'> {
+    promotedTo?: RolePromotionInput[];
+}
+export type MovabilityDestinationsRecordInput = Partial<Record<SquareString, readonly MoveDestinationInput[]>>;
+export type MovabilityResolverInput = (source: SquareString) => readonly MoveDestinationInput[] | undefined;
+export type MovabilityDestinationsInput = MovabilityDestinationsRecordInput | MovabilityResolverInput;
+export type StrictMovabilityInput = {
+    mode: 'strict';
+    destinations: MovabilityDestinationsInput;
+};
+export type FreeMovabilityInput = {
+    mode: 'free';
+};
+export type DisabledMovabilityInput = {
+    mode: 'disabled';
+};
+export type MovabilityInput = StrictMovabilityInput | FreeMovabilityInput | DisabledMovabilityInput;

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

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

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

@@ -0,0 +1,35 @@
+import type { ReadonlyDeep } from 'type-fest';
+import type { MoveRequest, PieceCode, RolePromotionCode, Square } from '../../board/types/internal';
+export interface DragSession {
+    type: 'lifted-piece-drag' | 'release-targeting';
+    sourceSquare: Square;
+    sourcePieceCode: PieceCode;
+    targetSquare: Square | null;
+}
+export type DragSessionSnapshot = ReadonlyDeep<DragSession>;
+export interface MoveDestination extends Omit<MoveRequest, 'from' | 'promotedTo'> {
+    promotedTo?: RolePromotionCode[];
+}
+export type MoveDestinationSnapshot = ReadonlyDeep<MoveDestination>;
+export type MovabilityDestinationsRecord = Partial<Record<Square, readonly MoveDestination[]>>;
+export type MovabilityDestinationsRecordSnapshot = ReadonlyDeep<MovabilityDestinationsRecord>;
+export type MovabilityResolver = (source: Square) => readonly MoveDestination[] | undefined;
+export type MovabilityDestinations = MovabilityDestinationsRecord | MovabilityResolver;
+export type MovabilityDestinationsSnapshot = ReadonlyDeep<MovabilityDestinations>;
+export declare const enum MovabilityModeCode {
+    Disabled = 0,
+    Free = 1,
+    Strict = 2
+}
+export interface MovabilityStrict {
+    readonly mode: MovabilityModeCode.Strict;
+    readonly destinations: MovabilityDestinationsSnapshot;
+}
+export interface MovabilityFree {
+    readonly mode: MovabilityModeCode.Free;
+}
+export interface MovabilityDisabled {
+    readonly mode: MovabilityModeCode.Disabled;
+}
+export type Movability = MovabilityStrict | MovabilityFree | MovabilityDisabled;
+export type MovabilitySnapshot = ReadonlyDeep<Movability>;

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

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

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

@@ -0,0 +1,33 @@
+import { ReadonlyDeep } from 'type-fest';
+import { NonEmptyPieceCode, Square } from '../../board/types/internal';
+import { InteractionStateMutationSession } from '../mutation';
+import { MovabilityInput } from './input';
+import { DragSession, DragSessionSnapshot, Movability, MovabilitySnapshot, MoveDestinationSnapshot } from './internal';
+export interface InteractionStateSelected {
+    square: Square;
+    pieceCode: NonEmptyPieceCode;
+}
+export interface InteractionStateInternal {
+    selected: InteractionStateSelected | null;
+    movability: Movability;
+    activeDestinations: ReadonlyMap<Square, MoveDestinationSnapshot>;
+    dragSession: DragSession | null;
+}
+export type InteractionStateSnapshot = ReadonlyDeep<InteractionStateInternal>;
+export interface InteractionStateInitOptions {
+    movability?: MovabilityInput;
+}
+export interface InteractionState {
+    readonly selected: InteractionStateSelected | null;
+    setSelected(selected: InteractionStateSelected | null, mutationSession: InteractionStateMutationSession): boolean;
+    readonly movability: MovabilitySnapshot;
+    setMovability(movability: MovabilityInput, mutationSession: InteractionStateMutationSession): boolean;
+    readonly activeDestinations: ReadonlyMap<Square, MoveDestinationSnapshot>;
+    updateActiveDestinations(mutationSession: InteractionStateMutationSession): boolean;
+    readonly dragSession: DragSessionSnapshot | null;
+    setDragSession(session: DragSessionSnapshot | null, mutationSession: InteractionStateMutationSession): boolean;
+    updateDragSessionCurrentTarget(sq: Square | null, mutationSession: InteractionStateMutationSession): boolean;
+    clear(mutationSession: InteractionStateMutationSession): boolean;
+    clearActive(mutationSession: InteractionStateMutationSession): boolean;
+    getSnapshot(): InteractionStateSnapshot;
+}

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

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

package/dist/state/types.d.ts

@@ -0,0 +1,30 @@
+import { PositionInput } from './board/types/input';
+import { BoardState, BoardStateSnapshot } from './board/types/main';
+import type { ChangeState, ChangeStateSnapshot } from './change/types';
+import { InteractionState, InteractionStateInitOptions, InteractionStateSnapshot } from './interaction/types/main';
+import { ViewStateSnapshot } from './view/types/internal';
+import { ViewState, ViewStateInitOptions } from './view/types/main';
+export interface RuntimeStateInternal {
+    readonly board: BoardState;
+    readonly view: ViewState;
+    readonly interaction: InteractionState;
+    readonly change: ChangeState;
+}
+export interface RuntimeStateSnapshot {
+    readonly board: BoardStateSnapshot;
+    readonly view: ViewStateSnapshot;
+    readonly interaction: InteractionStateSnapshot;
+    readonly change: ChangeStateSnapshot;
+}
+export interface RuntimeStateInitOptions {
+    board?: PositionInput;
+    view?: ViewStateInitOptions;
+    interaction?: InteractionStateInitOptions;
+}
+export interface RuntimeState {
+    readonly board: BoardState;
+    readonly view: ViewState;
+    readonly interaction: InteractionState;
+    readonly change: ChangeState;
+    getSnapshot(): RuntimeStateSnapshot;
+}

package/dist/state/types.js

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

package/dist/state/view/factory.d.ts

@@ -0,0 +1,2 @@
+import { ViewState, ViewStateInitOptions } from './types/main';
+export declare function createViewState(options: ViewStateInitOptions): ViewState;

package/dist/state/view/factory.js

@@ -0,0 +1,24 @@
+import { cloneDeep } from 'es-toolkit/object';
+import { normalizeColor } from '../board/normalize';
+import { viewSetOrientation } from './reducers';
+function createViewStateInternal(opts) {
+    const orientation = opts.orientation ? normalizeColor(opts.orientation) : 0 /* ColorCode.White */;
+    return {
+        orientation
+    };
+}
+export function createViewState(options) {
+    const internalState = createViewStateInternal(options);
+    return {
+        get orientation() {
+            return internalState.orientation;
+        },
+        setOrientation(orientation, mutationSession) {
+            const newOrient = normalizeColor(orientation);
+            return mutationSession.addMutation('state.view.setOrientation', viewSetOrientation(internalState, newOrient));
+        },
+        getSnapshot() {
+            return cloneDeep(internalState);
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { MutationSession } from '../../mutation/types';
+export type ViewStateMutationPayloadByCause = {
+    'state.view.setOrientation': undefined;
+};
+export type ViewStateMutationSession = MutationSession<ViewStateMutationPayloadByCause>;

package/dist/state/view/mutation.js

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

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

@@ -0,0 +1,3 @@
+import { ColorCode } from '../board/types/internal';
+import type { ViewStateInternal } from './types/internal';
+export declare function viewSetOrientation(state: ViewStateInternal, orientation: ColorCode): boolean;

package/dist/state/view/reducers.js

@@ -0,0 +1,6 @@
+export function viewSetOrientation(state, orientation) {
+    if (state.orientation === orientation)
+        return false; // no-op
+    state.orientation = orientation;
+    return true;
+}

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

@@ -0,0 +1,6 @@
+import type { ReadonlyDeep } from 'type-fest';
+import { ColorCode } from '../../board/types/internal';
+export interface ViewStateInternal {
+    orientation: ColorCode;
+}
+export type ViewStateSnapshot = ReadonlyDeep<ViewStateInternal>;

package/dist/state/view/types/internal.js

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

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

@@ -0,0 +1,12 @@
+import { ColorInput } from '../../board/types/input';
+import { ColorCode } from '../../board/types/internal';
+import { ViewStateMutationSession } from '../mutation';
+import { ViewStateSnapshot } from './internal';
+export interface ViewStateInitOptions {
+    orientation?: ColorInput;
+}
+export interface ViewState {
+    readonly orientation: ColorCode;
+    setOrientation(orientation: ColorInput, mutationSession: ViewStateMutationSession): boolean;
+    getSnapshot(): ViewStateSnapshot;
+}

package/dist/state/view/types/main.js

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

package/dist/wrapper/factory.d.ts

@@ -0,0 +1,3 @@
+import { DefaultBuiltinChessboardExtensions } from '../extensions/types/wrapper';
+import { Chessboard, ChessboardExtensionInput, ChessboardInitOptions } from './types';
+export declare function createBoard<TExtensions extends readonly ChessboardExtensionInput[] = DefaultBuiltinChessboardExtensions>(options: ChessboardInitOptions<TExtensions>): Chessboard<TExtensions>;