@mirasen/chessboard 0.1.0

package/dist/animation/types.d.ts

@@ -0,0 +1,46 @@
+import { ReadonlyDeep } from 'type-fest';
+import type { NonEmptyPieceCode, Square } from '../state/board/types/internal';
+export interface AnimationTrackMove {
+    id: number;
+    pieceCode: NonEmptyPieceCode;
+    fromSq: Square;
+    toSq: Square;
+    effect: 'move';
+}
+export interface AnimationTrackFade {
+    id: number;
+    pieceCode: NonEmptyPieceCode;
+    sq: Square;
+    effect: 'fade-in' | 'fade-out';
+}
+export interface AnimationTrackStatic {
+    id: number;
+    pieceCode: NonEmptyPieceCode;
+    sq: Square;
+    effect: 'static';
+}
+export type AnimationTrack = AnimationTrackMove | AnimationTrackFade | AnimationTrackStatic;
+export interface AnimationPlan {
+    sessionId: number;
+    tracks: AnimationTrack[];
+}
+export interface AnimationSession {
+    id: number;
+    tracks: AnimationTrack[];
+    startTime: number;
+    duration: number;
+}
+export type AnimationSessionSnapshot = ReadonlyDeep<AnimationSession>;
+export interface AnimationTrackMoveExclude {
+    fromSq: Square;
+    toSq: Square;
+}
+export interface AnimationTrackSquareExclude {
+    sq: Square;
+}
+export type AnimationTrackExclude = AnimationTrackMoveExclude | AnimationTrackSquareExclude;
+export declare function isMoveExclude(e: AnimationTrackExclude): e is AnimationTrackMoveExclude;
+export declare function isSquareExclude(e: AnimationTrackExclude): e is AnimationTrackSquareExclude;
+export interface CalculateAnimationTracksOptions {
+    exclude?: AnimationTrackExclude[];
+}

package/dist/animation/types.js

@@ -0,0 +1,6 @@
+export function isMoveExclude(e) {
+    return 'fromSq' in e && 'toSq' in e;
+}
+export function isSquareExclude(e) {
+    return 'sq' in e && !('fromSq' in e) && !('toSq' in e);
+}

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

@@ -0,0 +1,3 @@
+import { ExtensionAnimationControllerInternalSurface, ExtensionAnimationSessionInternalSurface, ExtensionAnimationSessionSubmitOptions } from '../types/basic/animation';
+export declare function createExtensionAnimationSession(id: number, options: ExtensionAnimationSessionSubmitOptions): ExtensionAnimationSessionInternalSurface;
+export declare function createExtensionAnimationController(): ExtensionAnimationControllerInternalSurface;

package/dist/extensions/animation/factory.js

@@ -0,0 +1,88 @@
+import { ANIMATION_SESSION_STATUS_ALL } from '../types/basic/animation';
+function createExtensionAnimationSessionInternal(id, options) {
+    return {
+        id,
+        startTime: performance.now(),
+        duration: options.duration,
+        status: 'submitted',
+        pendingCleanup: false
+    };
+}
+export function createExtensionAnimationSession(id, options) {
+    const internalState = createExtensionAnimationSessionInternal(id, options);
+    return {
+        id: internalState.id,
+        startTime: internalState.startTime,
+        duration: internalState.duration,
+        get status() {
+            return internalState.status;
+        },
+        get elapsedTime() {
+            return performance.now() - internalState.startTime;
+        },
+        get progress() {
+            return Math.min(1, (performance.now() - internalState.startTime) / internalState.duration);
+        },
+        get pendingCleanup() {
+            return internalState.pendingCleanup;
+        },
+        setStatus(newStatus) {
+            internalState.status = newStatus;
+        },
+        markPendingCleanup() {
+            internalState.pendingCleanup = true;
+        }
+    };
+}
+function createExtensionAnimationControllerInternal() {
+    return {
+        sessions: new Map()
+    };
+}
+let gSessionId = 0;
+export function createExtensionAnimationController() {
+    const internalState = createExtensionAnimationControllerInternal();
+    return {
+        submit(options) {
+            gSessionId++;
+            const session = createExtensionAnimationSession(gSessionId, options);
+            internalState.sessions.set(gSessionId, session);
+            // Logic to start the animation can be added here
+            return session;
+        },
+        cancel(sessionId) {
+            const session = internalState.sessions.get(sessionId);
+            if (session) {
+                session.setStatus('cancelled');
+            }
+        },
+        getAll(status) {
+            const stati = status
+                ? // If iterable
+                    typeof status === 'string'
+                        ? new Set([status])
+                        : new Set([...status])
+                : ANIMATION_SESSION_STATUS_ALL;
+            const result = [];
+            for (const session of internalState.sessions.values()) {
+                if (stati.has(session.status)) {
+                    result.push(session);
+                }
+            }
+            return result;
+        },
+        remove(sessionId) {
+            if (typeof sessionId === 'number') {
+                internalState.sessions.delete(sessionId);
+            }
+            else {
+                for (const id of sessionId) {
+                    internalState.sessions.delete(id);
+                }
+            }
+        },
+        clear() {
+            internalState.sessions.clear();
+        }
+    };
+}

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

@@ -0,0 +1,11 @@
+import { ExtensionAnimationSessionInternalSurface, ExtensionAnimationSessionStatus } from '../types/basic/animation';
+export interface ExtensionAnimationSessionInternal {
+    readonly id: number;
+    readonly startTime: DOMHighResTimeStamp;
+    readonly duration: number;
+    status: ExtensionAnimationSessionStatus;
+    pendingCleanup: boolean;
+}
+export interface ExtensionAnimationControllerInternal {
+    readonly sessions: Map<number, ExtensionAnimationSessionInternalSurface>;
+}

package/dist/extensions/animation/types.js

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

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

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

package/dist/extensions/factory/main.js

@@ -0,0 +1,101 @@
+import { createExtensionAnimationController } from '../animation/factory';
+import { createExtensionInvalidationState } from '../invalidation/factory';
+import { extensionSystemUpdateState, extensionSystemUpdateUIMoveRequest } from '../update';
+import { createExtensionRuntimeSurface } from './runtime';
+function createExtensionSystemInternal(getInternalState, options) {
+    const extensions = new Map();
+    const extensionsArray = options.extensions ?? [];
+    for (const extensionDef of extensionsArray) {
+        if (extensions.has(extensionDef.id)) {
+            throw new Error(`Duplicate extension id found: ${extensionDef.id}`);
+        }
+        const instance = extensionDef.createInstance({
+            runtimeSurface: createExtensionRuntimeSurface(getInternalState, options.extensionRuntimeSurfaceCommands, extensionDef)
+        });
+        const record = {
+            id: extensionDef.id,
+            definition: extensionDef,
+            instance,
+            invalidation: createExtensionInvalidationState(),
+            animation: createExtensionAnimationController()
+        };
+        extensions.set(extensionDef.id, record);
+    }
+    return {
+        extensions,
+        transientVisualsSubscribers: new Set(),
+        eventSubscribers: new Map(),
+        currentFrame: null
+    };
+}
+export function createExtensionSystem(options) {
+    let internalState = null;
+    function getInternalState() {
+        if (!internalState) {
+            throw new Error('Extension system internal state is not initialized');
+        }
+        return internalState;
+    }
+    internalState = createExtensionSystemInternal(getInternalState, options);
+    return {
+        getSharedDataForRenderSystem() {
+            return {
+                extensions: internalState.extensions,
+                transientVisualsSubscribers: internalState.transientVisualsSubscribers
+            };
+        },
+        get hasSubmittedAnimations() {
+            for (const ext of internalState.extensions.values()) {
+                if (ext.animation.getAll('submitted').length > 0) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        get currentFrame() {
+            return internalState.currentFrame;
+        },
+        getPublicRecord() {
+            const publicRecord = {};
+            for (const [id, extRecord] of internalState.extensions.entries()) {
+                if ('getPublic' in extRecord.instance) {
+                    // We know that if getPublic exists, then the instance has a public API, so this type assertion is safe
+                    const instanceWithPublic = extRecord.instance;
+                    publicRecord[id] = instanceWithPublic.getPublic();
+                }
+            }
+            return publicRecord;
+        },
+        onUpdate(request) {
+            extensionSystemUpdateState(internalState, request);
+        },
+        onUIMoveRequest(context) {
+            extensionSystemUpdateUIMoveRequest(internalState, context);
+        },
+        onUnmount() {
+            internalState.transientVisualsSubscribers.clear();
+            internalState.eventSubscribers.clear();
+            internalState.currentFrame = null;
+            for (const extensionRec of internalState.extensions.values()) {
+                extensionRec.invalidation.clear();
+                extensionRec.animation.clear();
+            }
+        },
+        onDestroy() {
+            // We assume that the onUnmout was already called by runtime, but let's still validate
+            for (const extensionRec of internalState.extensions.values()) {
+                extensionRec.instance.destroy();
+                const onUnmountCalled = [
+                    extensionRec.invalidation.dirtyLayers === 0,
+                    extensionRec.animation.getAll().length === 0
+                ].every(Boolean);
+                if (!onUnmountCalled) {
+                    throw new Error(`Extension ${extensionRec.id} was not properly unmounted before destroy. Please make sure to call onUnmount before onDestroy to allow the extension to clean up its state and resources.`);
+                }
+            }
+            // So we just clear the extension map to release references to extension definitions and instances and allow them to be garbage collected
+            // Cause they also have back reference to our surface to manipulate the core state
+            internalState.extensions.clear();
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { AnyExtensionDefinition } from '../types/extension';
+import type { GetInternalState } from '../types/main';
+import type { ExtensionRuntimeSurfaceCommands } from '../types/surface/commands';
+import type { ExtensionRuntimeSurface } from '../types/surface/main';
+export declare function createExtensionRuntimeSurface(getInternalState: GetInternalState, commands: ExtensionRuntimeSurfaceCommands, extensionDef: AnyExtensionDefinition): ExtensionRuntimeSurface;

package/dist/extensions/factory/runtime.js

@@ -0,0 +1,43 @@
+import assert from '@ktarmyshov/assert';
+function createExtensionRuntimeSurfaceTransientVisuals(getInternalState, extensionDef) {
+    return {
+        subscribe() {
+            const internalState = getInternalState();
+            internalState.transientVisualsSubscribers.add(extensionDef.id);
+        },
+        unsubscribe() {
+            const internalState = getInternalState();
+            internalState.transientVisualsSubscribers.delete(extensionDef.id);
+        }
+    };
+}
+function createExtensionRuntimeSurfaceAnimation(getInternalState, extensionDef) {
+    function getController() {
+        const internalState = getInternalState();
+        const controller = internalState.extensions.get(extensionDef.id)?.animation;
+        assert(controller, 'Extension animation controller not found');
+        return controller;
+    }
+    return {
+        submit(options) {
+            const controller = getController();
+            return controller.submit(options);
+        },
+        cancel(sessionId) {
+            const controller = getController();
+            controller.cancel(sessionId);
+        },
+        getAll(status) {
+            const controller = getController();
+            return controller.getAll(status);
+        }
+    };
+}
+export function createExtensionRuntimeSurface(getInternalState, commands, extensionDef) {
+    // @ts-expect-error We will implement events later, for now we just return empty object for it to satisfy the interface
+    return {
+        commands,
+        animation: createExtensionRuntimeSurfaceAnimation(getInternalState, extensionDef),
+        transientVisuals: createExtensionRuntimeSurfaceTransientVisuals(getInternalState, extensionDef)
+    };
+}

package/dist/extensions/first-party/active-target/factory.d.ts

@@ -0,0 +1,2 @@
+import { ActiveTargetDefinition, ActiveTargetInitConfig } from './types';
+export declare function createActiveTarget(config?: ActiveTargetInitConfig): ActiveTargetDefinition;

package/dist/extensions/first-party/active-target/factory.js

@@ -0,0 +1,109 @@
+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';
+export function createActiveTarget(config = {}) {
+    const mergedConfig = toMerged(DEFAULT_CONFIG, config);
+    return {
+        id: EXTENSION_ID,
+        slots: EXTENSION_SLOTS,
+        createInstance() {
+            return createActiveTargetInstance(mergedConfig);
+        }
+    };
+}
+function createActiveTargetInternal(config) {
+    return {
+        ...extensionCreateInternalBase(),
+        svgRect: null,
+        svgCircle: null,
+        config
+    };
+}
+function extensionClean(state) {
+    state.svgRect = null;
+    state.svgCircle = null;
+}
+function createActiveTargetInstance(config) {
+    const internalState = createActiveTargetInternal(config);
+    return {
+        id: EXTENSION_ID,
+        mount(env) {
+            extensionMount(internalState, env.slotRoots);
+        },
+        onUpdate(context) {
+            const needsRender = context.mutation.hasMutation({
+                causes: ['layout.refreshGeometry'],
+                // we really need almost all: setDrag, updateTarget, clear, clearActive, so just take all interaction mutations
+                prefixes: ['state.interaction.']
+            }) && isUpdateContextRenderable(context);
+            if (!needsRender) {
+                return; // no-op
+            }
+            context.invalidation.markDirty(1 /* DirtyLayer.Highlight */);
+        },
+        render(context) {
+            assert(context.invalidation.dirtyLayers !== 0, 'Render should only be called when there are dirty layers');
+            // For AI: `release-targeting` is also represented by `dragSession`.
+            // `dragSession` here is the active interaction session, not only lifted-piece drag.
+            const square = context.currentFrame.state.interaction.dragSession?.targetSquare;
+            if (square === undefined || square === null) {
+                if (internalState.svgRect !== null) {
+                    internalState.svgRect.remove();
+                    internalState.svgRect = null;
+                    assert(internalState.svgCircle, 'svgCircle should be available if svgRect is available');
+                    internalState.svgCircle.remove();
+                    internalState.svgCircle = null;
+                }
+                return;
+            }
+            const geometry = context.currentFrame.layout.geometry;
+            const r = geometry.squareRect(square);
+            const rectAttributes = {
+                x: r.x.toString(),
+                y: r.y.toString(),
+                width: r.size.toString(),
+                height: r.size.toString(),
+                fill: internalState.config.squareColor.color,
+                'fill-opacity': internalState.config.squareColor.opacity.toString(),
+                'shape-rendering': 'crispEdges'
+            };
+            const radius = geometry.squareSize * internalState.config.halo.radiusRatio;
+            const centerX = r.x + r.size / 2;
+            const centerY = r.y + r.size / 2;
+            const haloAttributes = {
+                cx: centerX.toString(),
+                cy: centerY.toString(),
+                r: radius.toString(),
+                fill: internalState.config.halo.color.color,
+                'fill-opacity': internalState.config.halo.color.opacity.toString()
+            };
+            if (internalState.svgRect === null) {
+                assert(internalState.slotRoots, 'Slot roots should be available when render is called');
+                internalState.svgRect = createSvgElement(internalState.slotRoots.underPieces, 'rect', {
+                    'data-chessboard-id': 'active-target-square-highlight',
+                    ...rectAttributes
+                });
+                internalState.svgCircle = createSvgElement(internalState.slotRoots.overPieces, 'circle', {
+                    'data-chessboard-id': 'active-target-halo',
+                    ...haloAttributes
+                });
+            }
+            else {
+                updateElementAttributes(internalState.svgRect, rectAttributes);
+                assert(internalState.svgCircle, 'svgCircle should be available if svgRect is available');
+                updateElementAttributes(internalState.svgCircle, haloAttributes);
+            }
+        },
+        unmount() {
+            extensionUnmount(internalState);
+            extensionClean(internalState);
+        },
+        destroy() {
+            extensionDestroy(internalState);
+            extensionClean(internalState);
+        }
+    };
+}

package/dist/extensions/first-party/active-target/types.d.ts

@@ -0,0 +1,25 @@
+import { PartialDeep } from 'type-fest';
+import { ExtensionDefinition, ExtensionInstance } from '../../types/extension';
+import { ExtensionInternal, OpaqueColor } from '../common/types';
+export declare const EXTENSION_SLOTS: readonly ["underPieces", "overPieces"];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "activeTarget";
+export interface ActiveTargetConfig {
+    squareColor: OpaqueColor;
+    halo: {
+        color: OpaqueColor;
+        radiusRatio: number;
+    };
+}
+export declare const DEFAULT_CONFIG: ActiveTargetConfig;
+export type ActiveTargetInitConfig = PartialDeep<ActiveTargetConfig>;
+export type ActiveTargetDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export type ActiveTargetInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, never>;
+export interface ActiveTargetInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
+    svgRect: SVGRectElement | null;
+    svgCircle: SVGCircleElement | null;
+    readonly config: ActiveTargetConfig;
+}
+export declare const enum DirtyLayer {
+    Highlight = 1
+}

package/dist/extensions/first-party/active-target/types.js

@@ -0,0 +1,15 @@
+export const EXTENSION_SLOTS = ['underPieces', 'overPieces'];
+export const EXTENSION_ID = 'activeTarget';
+export const DEFAULT_CONFIG = {
+    squareColor: {
+        color: 'rgba(255, 255, 0)',
+        opacity: 0.4
+    },
+    halo: {
+        color: {
+            color: 'rgba(0, 0, 0)',
+            opacity: 0.2
+        },
+        radiusRatio: 1.2
+    }
+};

package/dist/extensions/first-party/board-events/factory.d.ts

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

package/dist/extensions/first-party/board-events/factory.js

@@ -0,0 +1,65 @@
+import { denormalizeMove } from '../../../state/board/denormalize';
+import { extensionCreateInternalBase, extensionDestroy, extensionUnmount } from '../common/helpers';
+import { EXTENSION_ID, EXTENSION_SLOTS } from './types';
+export function createBoardEvents() {
+    return {
+        id: EXTENSION_ID,
+        slots: EXTENSION_SLOTS,
+        createInstance() {
+            return createBoardEventsInstance();
+        }
+    };
+}
+function createBoardEventsInternal() {
+    return {
+        ...extensionCreateInternalBase(),
+        onUIMove: null,
+        onRawUpdate: null
+    };
+}
+function extensionClean(state) {
+    state.onUIMove = null;
+    state.onRawUpdate = null;
+}
+function createBoardEventsInstancePublic(state) {
+    return {
+        setOnUIMove(callback) {
+            state.onUIMove = callback;
+        },
+        setOnRawUpdate(callback) {
+            state.onRawUpdate = callback;
+        }
+    };
+}
+function createBoardEventsInstance() {
+    const internalState = createBoardEventsInternal();
+    const publicInterface = createBoardEventsInstancePublic(internalState);
+    return {
+        id: EXTENSION_ID,
+        mount() { },
+        onUpdate(context) {
+            if (internalState.onRawUpdate) {
+                internalState.onRawUpdate({
+                    previousFrame: context.previousFrame,
+                    mutation: context.mutation,
+                    currentFrame: context.currentFrame
+                });
+            }
+            if (context.mutation.hasMutation({ causes: ['state.change.setLastMove'] }) &&
+                context.currentFrame.state.change.lastMove) {
+                internalState.onUIMove?.(denormalizeMove(context.currentFrame.state.change.lastMove));
+            }
+        },
+        getPublic() {
+            return publicInterface;
+        },
+        unmount() {
+            extensionUnmount(internalState);
+            extensionClean(internalState);
+        },
+        destroy() {
+            extensionDestroy(internalState);
+            extensionClean(internalState);
+        }
+    };
+}

package/dist/extensions/first-party/board-events/types.d.ts

@@ -0,0 +1,27 @@
+import { RuntimeReadonlyMutationSession } from '../../../runtime/mutation/types';
+import { MoveOutput } from '../../../state/board/types/output';
+import { ExtensionSlotSvgRoots } from '../../types/basic/mount';
+import { UpdateFrameSnapshot } from '../../types/basic/update';
+import { ExtensionDefinition, ExtensionInstance } from '../../types/extension';
+import { ExtensionInternal } from '../common/types';
+export declare const EXTENSION_SLOTS: readonly [];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "events";
+export type BoardEventsDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, BoardEventsPublic>;
+export type OnUIMoveCallback = (move: MoveOutput) => void;
+export interface OnRawUpdateContext {
+    readonly previousFrame: UpdateFrameSnapshot | null;
+    readonly mutation: RuntimeReadonlyMutationSession;
+    readonly currentFrame: UpdateFrameSnapshot;
+}
+export type OnRawUpdateCallback = (context: OnRawUpdateContext) => void;
+export interface BoardEventsPublic {
+    setOnUIMove(callback: OnUIMoveCallback | null): void;
+    setOnRawUpdate(callback: OnRawUpdateCallback | null): void;
+}
+export type BoardEventsInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, BoardEventsPublic>;
+export type BoardEventsSlotRoots = ExtensionSlotSvgRoots<typeof EXTENSION_SLOTS>;
+export interface BoardEventsInstanceInternal extends ExtensionInternal<ExtensionSlotsType> {
+    onUIMove: OnUIMoveCallback | null;
+    onRawUpdate: OnRawUpdateCallback | null;
+}

package/dist/extensions/first-party/board-events/types.js

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

package/dist/extensions/first-party/common/helpers.d.ts

@@ -0,0 +1,8 @@
+import { ExtensionSlotName } from '../../types/basic/mount';
+import { ExtensionInternal } from './types';
+export declare function extensionCreateInternalBase<TSlots extends readonly ExtensionSlotName[]>(): ExtensionInternal<TSlots>;
+export declare function extensionIsMounted<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternal<TSlots>): boolean;
+export declare function extensionIsDestroyed<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternal<TSlots>): boolean;
+export declare function extensionMount<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternal<TSlots>, slotRoots: NonNullable<ExtensionInternal<TSlots>['slotRoots']>): void;
+export declare function extensionUnmount<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternal<TSlots>): void;
+export declare function extensionDestroy<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternal<TSlots>): void;

package/dist/extensions/first-party/common/helpers.js

@@ -0,0 +1,33 @@
+import assert from '@ktarmyshov/assert';
+import { clearElementChildren } from '../../../render/svg/helpers';
+export function extensionCreateInternalBase() {
+    return {
+        slotRoots: null,
+        destroyed: false
+    };
+}
+export function extensionIsMounted(state) {
+    return state.slotRoots !== null;
+}
+export function extensionIsDestroyed(state) {
+    return state.destroyed;
+}
+export function extensionMount(state, slotRoots) {
+    assert(!extensionIsMounted(state), 'Extension is already mounted');
+    assert(!extensionIsDestroyed(state), 'Extension is destroyed');
+    state.slotRoots = slotRoots;
+}
+export function extensionUnmount(state) {
+    assert(extensionIsMounted(state), 'Extension is not mounted');
+    for (const slotRoot of Object.values(state.slotRoots ?? {})) {
+        clearElementChildren(slotRoot);
+    }
+    state.slotRoots = null;
+}
+export function extensionDestroy(state) {
+    assert(!extensionIsDestroyed(state), 'Extension is already destroyed');
+    if (extensionIsMounted(state)) {
+        extensionUnmount(state);
+    }
+    state.destroyed = true;
+}

package/dist/extensions/first-party/common/types.d.ts

@@ -0,0 +1,10 @@
+import { ExtensionSlotName, ExtensionSlotSvgRoots } from '../../types/basic/mount';
+export interface ExtensionInternal<TSlots extends readonly ExtensionSlotName[]> {
+    slotRoots: ExtensionSlotSvgRoots<TSlots> | null;
+    destroyed: boolean;
+}
+export type AnyExtensionInternal = ExtensionInternal<readonly ExtensionSlotName[]>;
+export interface OpaqueColor {
+    color: string;
+    opacity: number;
+}

package/dist/extensions/first-party/common/types.js

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

package/dist/extensions/first-party/last-move/factory.d.ts

@@ -0,0 +1,2 @@
+import { LastMoveDefinition, LastMoveInitConfig } from './types';
+export declare function createLastMove(config?: LastMoveInitConfig): LastMoveDefinition;