@mirasen/chessboard 1.1.4 → 1.2.0

package/dist/extensions/first-party/annotations/render/helpers/circles.js

@@ -0,0 +1,30 @@
+import { createSvgElement, updateSvgElementAttributes } from '../../../../../render/svg/helpers.js';
+function computeCircleAttributes(params) {
+    const { square, color, radius, strokeWidth, opacity, geometry } = params;
+    const squareSize = geometry.squareSize;
+    const rect = geometry.getSquareRect(square);
+    return {
+        cx: (rect.x + rect.width / 2).toString(),
+        cy: (rect.y + rect.height / 2).toString(),
+        r: (squareSize * radius).toString(),
+        fill: 'none',
+        stroke: color,
+        'stroke-width': (squareSize * strokeWidth).toString(),
+        opacity: opacity.toString()
+    };
+}
+export function createAnnotationCircleSvg(params) {
+    const attributes = computeCircleAttributes(params);
+    const circle = createSvgElement(params.parent, 'circle', {
+        'data-chessboard-id': params.dataId,
+        ...attributes
+    });
+    return { circle };
+}
+export function updateAnnotationCircleSvg(rendered, params) {
+    const attributes = computeCircleAttributes(params);
+    updateSvgElementAttributes(rendered.circle, attributes);
+}
+export function removeAnnotationCircleSvg(rendered) {
+    rendered.circle.remove();
+}

package/dist/extensions/first-party/annotations/render/preview.d.ts

@@ -0,0 +1,3 @@
+import type { SceneRenderGeometry } from '../../../../layout/geometry/types.js';
+import type { AnnotationsStateInternal } from '../types/main.js';
+export declare function renderPreviewAnnotations(state: AnnotationsStateInternal, geometry: SceneRenderGeometry): void;

package/dist/extensions/first-party/annotations/render/preview.js

@@ -0,0 +1,96 @@
+import assert from '@ktarmyshov/assert';
+import { VISUAL_CONFIG } from '../constants.js';
+import { arrowAnnotationKeyNormalized } from '../normalize.js';
+import { createAnnotationArrowSvg, removeAnnotationArrowSvg, updateAnnotationArrowSvg } from './helpers/arrows.js';
+import { createAnnotationCircleSvg, removeAnnotationCircleSvg, updateAnnotationCircleSvg } from './helpers/circles.js';
+export function renderPreviewAnnotations(state, geometry) {
+    assert(state.slotRoots, 'Expected slotRoots to be initialized before rendering preview');
+    const gesture = state.activeDrawGesture;
+    const target = state.activeDrawPreviewTarget;
+    // No preview needed: clear any existing preview DOM
+    if (gesture === null || target === null) {
+        clearPreviewCircle(state);
+        clearPreviewArrow(state);
+        return;
+    }
+    const source = gesture.sourceSquare;
+    const color = gesture.color;
+    if (target === source) {
+        // Circle preview
+        clearPreviewArrow(state);
+        renderPreviewCircle(state, geometry, source, color);
+    }
+    else {
+        // Arrow preview
+        clearPreviewCircle(state);
+        renderPreviewArrowSvg(state, geometry, source, target, color);
+    }
+}
+function renderPreviewCircle(state, geometry, square, color) {
+    const { previewAdd, previewRemoveOpacity } = VISUAL_CONFIG.circle;
+    // Determine add vs remove style
+    const existingCircle = state.annotations.circles.get(square);
+    const isRemove = existingCircle !== undefined && existingCircle.color === color;
+    const opacity = isRemove ? previewRemoveOpacity : previewAdd.opacity;
+    assert(state.slotRoots, 'Expected slotRoots to be initialized before rendering preview');
+    const params = {
+        parent: state.slotRoots.drag,
+        dataId: 'annotation-circle-preview',
+        square,
+        color,
+        radius: previewAdd.radius,
+        strokeWidth: previewAdd.strokeWidth,
+        opacity,
+        geometry
+    };
+    if (state.previewSvg.circle) {
+        updateAnnotationCircleSvg(state.previewSvg.circle, params);
+    }
+    else {
+        state.previewSvg.circle = createAnnotationCircleSvg(params);
+    }
+}
+function renderPreviewArrowSvg(state, geometry, from, to, color) {
+    const { committed, previewAdd, previewRemoveOpacity } = VISUAL_CONFIG.arrow;
+    // Determine add vs remove style
+    const arrowKey = arrowAnnotationKeyNormalized(from, to);
+    const existingArrow = state.annotations.arrows.get(arrowKey);
+    const isRemove = existingArrow !== undefined && existingArrow.color === color;
+    const visual = isRemove ? committed : previewAdd;
+    const opacity = isRemove ? previewRemoveOpacity : previewAdd.opacity;
+    const markerId = state.svgIds.makeId('annotations', 'arrowhead-preview');
+    const markerHref = `url(${state.svgIds.makeHref('annotations', 'arrowhead-preview')})`;
+    const params = {
+        defsRoot: state.slotRoots.defs,
+        visualRoot: state.slotRoots.drag,
+        markerDataId: 'annotation-arrowhead-preview',
+        markerPathDataId: 'annotation-arrowhead-path-preview',
+        lineDataId: 'annotation-arrow-preview',
+        markerId,
+        markerHref,
+        from,
+        to,
+        color,
+        opacity,
+        visual,
+        geometry
+    };
+    if (state.previewSvg.arrow) {
+        updateAnnotationArrowSvg(state.previewSvg.arrow, params);
+    }
+    else {
+        state.previewSvg.arrow = createAnnotationArrowSvg(params);
+    }
+}
+function clearPreviewCircle(state) {
+    if (state.previewSvg.circle) {
+        removeAnnotationCircleSvg(state.previewSvg.circle);
+        state.previewSvg.circle = null;
+    }
+}
+function clearPreviewArrow(state) {
+    if (state.previewSvg.arrow) {
+        removeAnnotationArrowSvg(state.previewSvg.arrow);
+        state.previewSvg.arrow = null;
+    }
+}

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

@@ -0,0 +1,77 @@
+import type { Square } from '../../../../state/board/types/internal.js';
+import type { AnnotationsDrawModifier } from './public.js';
+/** Annotation color as a CSS-compatible color string. */
+export type AnnotationColor = string;
+export type CircleAnnotationKey = Square;
+export type ArrowAnnotationKey = number;
+export interface CircleAnnotation {
+    readonly key: CircleAnnotationKey;
+    readonly square: Square;
+    readonly color: AnnotationColor;
+}
+export interface ArrowAnnotation {
+    readonly key: ArrowAnnotationKey;
+    readonly from: Square;
+    readonly to: Square;
+    readonly color: AnnotationColor;
+}
+export interface AnnotationModifierColorConfig {
+    readonly none: AnnotationColor;
+    readonly ctrl: AnnotationColor;
+    readonly shift: AnnotationColor;
+    readonly alt: AnnotationColor;
+    readonly meta: AnnotationColor;
+}
+export interface AnnotationsConfig {
+    clearOnCoreInteraction: boolean;
+    drawButton: number;
+    drawModifier: AnnotationsDrawModifier | null;
+    readonly colors: AnnotationModifierColorConfig;
+}
+export interface ActiveDrawGesture {
+    readonly sourceSquare: Square;
+    readonly color: AnnotationColor;
+}
+export interface VisualConfigCircleAnnotation {
+    strokeWidth: number;
+    radius: number;
+    opacity: number;
+}
+export interface VisualConfigArrowAnnotation {
+    strokeWidth: number;
+    startOffset: number;
+    endOffset: number;
+    opacity: number;
+    markerWidth: number;
+    markerHeight: number;
+    markerRefX: number;
+    markerRefY: number;
+    markerViewBox: string;
+    markerPathD: string;
+}
+export interface VisualConfigCircle {
+    readonly committed: VisualConfigCircleAnnotation;
+    readonly previewAdd: VisualConfigCircleAnnotation;
+    /**
+     * Remove preview reuses previewAdd definitions
+     * and overrides only opacity.
+     */
+    readonly previewRemoveOpacity: number;
+}
+export interface VisualConfigArrow {
+    readonly committed: VisualConfigArrowAnnotation;
+    readonly previewAdd: VisualConfigArrowAnnotation;
+    /**
+     * Remove preview reuses committed arrow definitions
+     * and overrides only opacity.
+     */
+    readonly previewRemoveOpacity: number;
+}
+export interface VisualConfig {
+    readonly circle: VisualConfigCircle;
+    readonly arrow: VisualConfigArrow;
+}
+export declare const enum DirtyLayer {
+    COMMITTED = 1,
+    PREVIEW = 2
+}

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

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

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

@@ -0,0 +1,40 @@
+import type { Square } from '../../../../state/board/types/internal.js';
+import type { ExtensionDefinition, ExtensionInstance } from '../../../types/extension.js';
+import type { ExtensionRuntimeSurface } from '../../../types/surface/main.js';
+import type { ExtensionInternalBase } from '../../common/types.js';
+import type { ActiveDrawGesture, AnnotationsConfig, ArrowAnnotation, ArrowAnnotationKey, CircleAnnotation, CircleAnnotationKey } from './internal.js';
+import type { AnnotationsPublicAPI } from './public.js';
+export declare const EXTENSION_SLOTS: readonly ["defs", "overPieces", "drag"];
+export type ExtensionSlotsType = typeof EXTENSION_SLOTS;
+export declare const EXTENSION_ID: "annotations";
+export type AnnotationsDefinition = ExtensionDefinition<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, AnnotationsPublicAPI>;
+export type AnnotationsInstance = ExtensionInstance<typeof EXTENSION_ID, typeof EXTENSION_SLOTS, AnnotationsPublicAPI>;
+export interface RenderedAnnotationCircleSvg {
+    readonly circle: SVGCircleElement;
+}
+export interface RenderedAnnotationArrowSvg {
+    readonly line: SVGLineElement;
+    readonly marker: SVGMarkerElement;
+    readonly markerPath: SVGPathElement;
+}
+export interface AnnotationsStateInternalSvg {
+    readonly svgCircles: Map<CircleAnnotationKey, RenderedAnnotationCircleSvg>;
+    readonly svgArrows: Map<ArrowAnnotationKey, RenderedAnnotationArrowSvg>;
+}
+export interface AnnotationsStateInternalAnnotations {
+    readonly circles: Map<CircleAnnotationKey, CircleAnnotation>;
+    readonly arrows: Map<ArrowAnnotationKey, ArrowAnnotation>;
+}
+export interface AnnotationsStateInternalPreviewSvg {
+    circle: RenderedAnnotationCircleSvg | null;
+    arrow: RenderedAnnotationArrowSvg | null;
+}
+export interface AnnotationsStateInternal extends ExtensionInternalBase<ExtensionSlotsType> {
+    readonly runtimeSurface: ExtensionRuntimeSurface;
+    readonly svg: AnnotationsStateInternalSvg;
+    readonly annotations: AnnotationsStateInternalAnnotations;
+    readonly config: AnnotationsConfig;
+    activeDrawGesture: ActiveDrawGesture | null;
+    activeDrawPreviewTarget: Square | null;
+    readonly previewSvg: AnnotationsStateInternalPreviewSvg;
+}

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

@@ -0,0 +1,6 @@
+export const EXTENSION_SLOTS = [
+    'defs',
+    'overPieces',
+    'drag'
+];
+export const EXTENSION_ID = 'annotations';

package/dist/extensions/first-party/annotations/types/public.d.ts

@@ -0,0 +1,48 @@
+import type { SquareString } from '../../../../state/board/types/input.js';
+/** The annotation color resolved from user input modifiers. */
+export type AnnotationColorPublic = string;
+export interface CircleAnnotationPublic {
+    readonly square: SquareString;
+    readonly color: AnnotationColorPublic;
+}
+export interface ArrowAnnotationPublic {
+    readonly from: SquareString;
+    readonly to: SquareString;
+    readonly color: AnnotationColorPublic;
+}
+export interface AnnotationsInitOptionsConfigModifierColor {
+    none?: AnnotationColorPublic;
+    ctrl?: AnnotationColorPublic;
+    shift?: AnnotationColorPublic;
+    alt?: AnnotationColorPublic;
+    meta?: AnnotationColorPublic;
+}
+export type AnnotationsDrawModifier = Exclude<keyof AnnotationsInitOptionsConfigModifierColor, 'none'>;
+export interface AnnotationsInitOptionsConfig {
+    clearOnCoreInteraction?: boolean;
+    drawButton?: number;
+    drawModifier?: AnnotationsDrawModifier | null;
+    colors?: AnnotationsInitOptionsConfigModifierColor;
+}
+export interface AnnotationsInitOptionsAnnotations {
+    circles?: CircleAnnotationPublic[];
+    arrows?: ArrowAnnotationPublic[];
+}
+export interface AnnotationsInitOptions {
+    config?: AnnotationsInitOptionsConfig;
+    annotations?: AnnotationsInitOptionsAnnotations;
+}
+export type CircleAnnotationValuePublic = Omit<CircleAnnotationPublic, 'square'>;
+export type ArrowAnnotationValuePublic = Omit<ArrowAnnotationPublic, 'from' | 'to'>;
+export interface AnnotationsPublicAPI {
+    getCircles(): CircleAnnotationPublic[];
+    getArrows(): ArrowAnnotationPublic[];
+    setCircles(circles: CircleAnnotationPublic[]): void;
+    setArrows(arrows: ArrowAnnotationPublic[]): void;
+    circle(square: SquareString, annotation: CircleAnnotationValuePublic | null): void;
+    arrow(from: SquareString, to: SquareString, annotation: ArrowAnnotationValuePublic | null): void;
+    clear(): void;
+    clearOnCoreInteraction: boolean;
+    drawButton: number;
+    drawModifier: AnnotationsDrawModifier | null;
+}

package/dist/extensions/first-party/annotations/types/public.js

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

package/dist/extensions/first-party/annotations/update.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionUpdateContext } from '../../types/context/update.js';
+import type { AnnotationsStateInternal } from './types/main.js';
+export declare function annotationsOnUpdate(state: AnnotationsStateInternal, context: ExtensionUpdateContext): void;

package/dist/extensions/first-party/annotations/update.js

@@ -0,0 +1,45 @@
+import { isUpdateContextRenderable } from '../../types/context/update.js';
+import { clearCommittedAnnotations, hasCommittedAnnotations } from './committed.js';
+import { EXTENSION_ID } from './types/main.js';
+export function annotationsOnUpdate(state, context) {
+    if (state.config.clearOnCoreInteraction &&
+        hasCommittedAnnotations(state) &&
+        context.mutation.hasMutation({
+            causes: ['runtime.interaction.completeCoreDragTo']
+        })) {
+        clearCommittedAnnotations(state);
+        context.invalidation.markDirty(1 /* DirtyLayer.COMMITTED */);
+    }
+    if (context.mutation.hasMutation({
+        causes: ['layout.refreshGeometry']
+    }) &&
+        isUpdateContextRenderable(context)) {
+        context.invalidation.markDirty(1 /* DirtyLayer.COMMITTED */);
+        if (state.activeDrawPreviewTarget !== null ||
+            state.previewSvg.circle !== null ||
+            state.previewSvg.arrow !== null) {
+            context.invalidation.markDirty(2 /* DirtyLayer.PREVIEW */);
+        }
+    }
+    // Preview target tracking from ext:draw drag session
+    let nextPreviewTarget = null;
+    if (state.activeDrawGesture !== null) {
+        const dragSession = context.currentFrame.state.interaction.dragSession;
+        if (dragSession &&
+            dragSession.type === 'ext:draw' &&
+            'owner' in dragSession &&
+            dragSession.owner === EXTENSION_ID) {
+            nextPreviewTarget = dragSession.targetSquare;
+        }
+    }
+    if (nextPreviewTarget !== state.activeDrawPreviewTarget) {
+        state.activeDrawPreviewTarget = nextPreviewTarget;
+        context.invalidation.markDirty(2 /* DirtyLayer.PREVIEW */);
+        context.invalidation.markDirty(1 /* DirtyLayer.COMMITTED */);
+    }
+    else if (nextPreviewTarget === null &&
+        (state.previewSvg.circle !== null || state.previewSvg.arrow !== null)) {
+        context.invalidation.markDirty(2 /* DirtyLayer.PREVIEW */);
+        context.invalidation.markDirty(1 /* DirtyLayer.COMMITTED */);
+    }
+}

package/dist/extensions/first-party/auto-promote/factory.js

@@ -4,14 +4,14 @@ export function createAutoPromote() {
     return {
         id: EXTENSION_ID,
         slots: EXTENSION_SLOTS,
-        createInstance() {
-            return createAutoPromoteInstance();
+        createInstance(options) {
+            return createAutoPromoteInstance(options);
         }
     };
 }
-function createAutoPromoteInternal() {
+function createAutoPromoteInternal(options) {
     return {
-        ...extensionCreateInternalBase(),
+        ...extensionCreateInternalBase(options),
         toQueen: false
     };
 }
@@ -25,8 +25,8 @@ function createAutoPromoteInstancePublic(state) {
         }
     };
 }
-function createAutoPromoteInstance() {
-    const internalState = createAutoPromoteInternal();
+function createAutoPromoteInstance(options) {
+    const internalState = createAutoPromoteInternal(options);
     const publicInterface = createAutoPromoteInstancePublic(internalState);
     return {
         id: EXTENSION_ID,

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

@@ -5,14 +5,14 @@ export function createBoardEvents() {
     return {
         id: EXTENSION_ID,
         slots: EXTENSION_SLOTS,
-        createInstance() {
-            return createBoardEventsInstance();
+        createInstance(options) {
+            return createBoardEventsInstance(options);
         }
     };
 }
-function createBoardEventsInternal() {
+function createBoardEventsInternal(options) {
     return {
-        ...extensionCreateInternalBase(),
+        ...extensionCreateInternalBase(options),
         onUIMove: null,
         onRawUpdate: null
     };
@@ -27,8 +27,8 @@ function createBoardEventsInstancePublic(state) {
         }
     };
 }
-function createBoardEventsInstance() {
-    const internalState = createBoardEventsInternal();
+function createBoardEventsInstance(options) {
+    const internalState = createBoardEventsInternal(options);
     const publicInterface = createBoardEventsInstancePublic(internalState);
     return {
         id: EXTENSION_ID,

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

@@ -1,6 +1,7 @@
 import { ExtensionSlotName } from '../../types/basic/mount.js';
+import type { ExtensionCreateInstanceOptions } from '../../types/extension.js';
 import { ExtensionInternalBase } from './types.js';
-export declare function extensionCreateInternalBase<TSlots extends readonly ExtensionSlotName[]>(): ExtensionInternalBase<TSlots>;
+export declare function extensionCreateInternalBase<TSlots extends readonly ExtensionSlotName[]>(options: ExtensionCreateInstanceOptions): ExtensionInternalBase<TSlots>;
 export declare function extensionIsMountedBase<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternalBase<TSlots>): boolean;
 export declare function extensionIsDestroyedBase<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternalBase<TSlots>): boolean;
 export declare function extensionMountBase<TSlots extends readonly ExtensionSlotName[]>(state: ExtensionInternalBase<TSlots>, slotRoots: NonNullable<ExtensionInternalBase<TSlots>['slotRoots']>): void;

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

@@ -1,9 +1,10 @@
 import assert from '@ktarmyshov/assert';
-import { clearElementChildren } from '../../../render/svg/helpers.js';
-export function extensionCreateInternalBase() {
+import { clearSvgElementChildren } from '../../../render/svg/helpers.js';
+export function extensionCreateInternalBase(options) {
     return {
         slotRoots: null,
-        destroyed: false
+        destroyed: false,
+        svgIds: options.svgIds
     };
 }
 export function extensionIsMountedBase(state) {
@@ -19,8 +20,8 @@ export function extensionMountBase(state, slotRoots) {
 }
 export function extensionUnmountBase(state) {
     assert(extensionIsMountedBase(state), 'Extension is not mounted');
-    for (const slotRoot of Object.values(state.slotRoots ?? {})) {
-        clearElementChildren(slotRoot);
+    for (const [, slotRoot] of Object.entries(state.slotRoots ?? {})) {
+        clearSvgElementChildren(slotRoot);
     }
     state.slotRoots = null;
 }

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

@@ -1,7 +1,9 @@
+import type { SvgIdResolver } from '../../../render/svg/ids.js';
 import { ExtensionSlotName, ExtensionSlotSvgRoots } from '../../types/basic/mount.js';
 export interface ExtensionInternalBase<TSlots extends readonly ExtensionSlotName[]> {
     slotRoots: ExtensionSlotSvgRoots<TSlots> | null;
     destroyed: boolean;
+    readonly svgIds: SvgIdResolver;
 }
 export interface OpaqueColor {
     color: string;

package/dist/extensions/first-party/last-move/factory.js

@@ -1,6 +1,6 @@
 import assert from '@ktarmyshov/assert';
 import { toMerged } from 'es-toolkit';
-import { createSvgElement, updateElementAttributes } from '../../../render/svg/helpers.js';
+import { createSvgElement, updateSvgElementAttributes } from '../../../render/svg/helpers.js';
 import { isUpdateContextRenderable } from '../../types/context/update.js';
 import { extensionCreateInternalBase, extensionDestroyBase, extensionMountBase, extensionUnmountBase } from '../common/helpers.js';
 import { DEFAULT_CONFIG, EXTENSION_ID, EXTENSION_SLOTS } from './types.js';
@@ -9,14 +9,14 @@ export function createLastMove(config = {}) {
     return {
         id: EXTENSION_ID,
         slots: EXTENSION_SLOTS,
-        createInstance() {
-            return createLastMoveInstance(mergedConfig);
+        createInstance(options) {
+            return createLastMoveInstance(options, mergedConfig);
         }
     };
 }
-function createLastMoveInternal(config) {
+function createLastMoveInternal(options, config) {
     return {
-        ...extensionCreateInternalBase(),
+        ...extensionCreateInternalBase(options),
         svgRectFrom: null,
         svgRectTo: null,
         config
@@ -26,8 +26,8 @@ function extensionClean(state) {
     state.svgRectFrom = null;
     state.svgRectTo = null;
 }
-function createLastMoveInstance(config) {
-    const internalState = createLastMoveInternal(config);
+function createLastMoveInstance(options, config) {
+    const internalState = createLastMoveInternal(options, config);
     return {
         id: EXTENSION_ID,
         mount(env) {
@@ -89,9 +89,9 @@ function createLastMoveInstance(config) {
                 });
             }
             else {
-                updateElementAttributes(internalState.svgRectFrom, rectFromAttributes);
+                updateSvgElementAttributes(internalState.svgRectFrom, rectFromAttributes);
                 assert(internalState.svgRectTo, 'svgRectTo should be available if svgRectFrom is available');
-                updateElementAttributes(internalState.svgRectTo, rectToAttributes);
+                updateSvgElementAttributes(internalState.svgRectTo, rectToAttributes);
             }
         },
         unmount() {

package/dist/extensions/first-party/legal-moves/factory.js

@@ -1,6 +1,6 @@
 import assert from '@ktarmyshov/assert';
 import { toMerged } from 'es-toolkit';
-import { clearElementChildren, createSvgElement } from '../../../render/svg/helpers.js';
+import { clearSvgElementChildren, createSvgElement } from '../../../render/svg/helpers.js';
 import { isNonEmptyPieceCode } from '../../../state/board/check.js';
 import { fromPieceCode } from '../../../state/board/piece.js';
 import { isUpdateContextRenderable } from '../../types/context/update.js';
@@ -11,14 +11,14 @@ export function createLegalMoves(config = {}) {
     return {
         id: EXTENSION_ID,
         slots: EXTENSION_SLOTS,
-        createInstance() {
-            return createLegalMovesInstance(mergedConfig);
+        createInstance(options) {
+            return createLegalMovesInstance(options, mergedConfig);
         }
     };
 }
-function createLegalMovesInternal(config) {
+function createLegalMovesInternal(options, config) {
     return {
-        ...extensionCreateInternalBase(),
+        ...extensionCreateInternalBase(options),
         svgCircles: [],
         config
     };
@@ -26,8 +26,8 @@ function createLegalMovesInternal(config) {
 function extensionClean(state) {
     state.svgCircles = [];
 }
-function createLegalMovesInstance(config) {
-    const internalState = createLegalMovesInternal(config);
+function createLegalMovesInstance(options, config) {
+    const internalState = createLegalMovesInternal(options, config);
     return {
         id: EXTENSION_ID,
         mount(env) {
@@ -47,7 +47,7 @@ function createLegalMovesInstance(config) {
         render(context) {
             assert(context.invalidation.dirtyLayers !== 0, 'Render should only be called when there are dirty layers');
             assert(internalState.slotRoots, 'Slot roots should be available when render is called');
-            clearElementChildren(internalState.slotRoots.overPieces);
+            clearSvgElementChildren(internalState.slotRoots.overPieces);
             internalState.svgCircles = [];
             const interaction = context.currentFrame.state.interaction;
             const needsRender = interaction.movability.mode === 2 /* MovabilityModeCode.Strict */ &&

package/dist/extensions/first-party/main-renderer/animation/factory.d.ts

@@ -1,4 +1,4 @@
 import type { ExtensionRuntimeSurface } from '../../../types/surface/main.js';
-import type { PieceUrls } from '../types/internal.js';
+import type { PieceSymbolResolver } from '../piece-symbols.js';
 import type { MainRendererAnimation } from './types.js';
-export declare function createMainRendererAnimation(config: PieceUrls, runtimeSurface: ExtensionRuntimeSurface): MainRendererAnimation;
+export declare function createMainRendererAnimation(runtimeSurface: ExtensionRuntimeSurface, resolver: PieceSymbolResolver): MainRendererAnimation;

package/dist/extensions/first-party/main-renderer/animation/factory.js

@@ -1,18 +1,18 @@
 import { cleanAnimationPlan } from '../../../../animation/render/plan.js';
 import { getAnimationSuppressedSquares, rendererAnimationClean, rendererAnimationPrepare, rendererAnimationRender } from './render.js';
 import { rendererAnimationOnUpdate } from './update.js';
-export function createMainRendererAnimation(config, runtimeSurface) {
+export function createMainRendererAnimation(runtimeSurface, resolver) {
     const state = {
-        config,
         runtimeSurface,
+        resolver,
         entries: new Map()
     };
     return {
         onUpdate(context) {
             rendererAnimationOnUpdate(state, context);
         },
-        prepareAnimation(context, layer) {
-            rendererAnimationPrepare(state, context, layer);
+        prepareAnimation(context, slot) {
+            rendererAnimationPrepare(state, context, slot);
         },
         renderAnimation(context) {
             rendererAnimationRender(state, context);

package/dist/extensions/first-party/main-renderer/animation/render.d.ts

@@ -1,7 +1,7 @@
 import type { Square } from '../../../../state/board/types/internal.js';
 import type { ExtensionCleanAnimationContext, ExtensionPrepareAnimationContext, ExtensionRenderAnimationContext } from '../../../types/context/animation.js';
 import type { MainRendererAnimationInternal } from './types.js';
-export declare function rendererAnimationPrepare(state: MainRendererAnimationInternal, context: ExtensionPrepareAnimationContext, layer: SVGElement): void;
+export declare function rendererAnimationPrepare(state: MainRendererAnimationInternal, context: ExtensionPrepareAnimationContext, slot: SVGGElement): void;
 export declare function rendererAnimationRender(state: MainRendererAnimationInternal, context: ExtensionRenderAnimationContext): void;
 export declare function rendererAnimationClean(state: MainRendererAnimationInternal, context: ExtensionCleanAnimationContext): void;
 export declare function getAnimationSuppressedSquares(state: MainRendererAnimationInternal): ReadonlySet<Square>;

package/dist/extensions/first-party/main-renderer/animation/render.js

@@ -1,10 +1,10 @@
 import { cleanAnimationPlan, prepareAnimationPlan, renderAnimationPlan } from '../../../../animation/render/plan.js';
 const EMPTY_SQUARES = new Set();
-export function rendererAnimationPrepare(state, context, layer) {
+export function rendererAnimationPrepare(state, context, slot) {
     for (const session of context.submittedSessions) {
         const entry = state.entries.get(session.id);
         if (entry && entry.nodes === null) {
-            entry.nodes = prepareAnimationPlan(entry.plan, context.currentFrame.layout.geometry, state.config, layer);
+            entry.nodes = prepareAnimationPlan(entry.plan, context.currentFrame.layout.geometry, state.resolver.getHref, slot);
         }
     }
 }

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

@@ -4,19 +4,19 @@ import { Square } from '../../../../state/board/types/internal.js';
 import { ExtensionCleanAnimationContext, ExtensionPrepareAnimationContext, ExtensionRenderAnimationContext } from '../../../types/context/animation.js';
 import { ExtensionUpdateContext } from '../../../types/context/update.js';
 import { ExtensionRuntimeSurface } from '../../../types/surface/main.js';
-import type { PieceUrls } from '../types/internal.js';
+import type { PieceSymbolResolver } from '../piece-symbols.js';
 export interface MainRendererAnimationEntry {
     plan: AnimationPlan;
     nodes: PreparedNodeMap | null;
 }
 export interface MainRendererAnimationInternal {
-    readonly config: PieceUrls;
     readonly runtimeSurface: ExtensionRuntimeSurface;
+    readonly resolver: PieceSymbolResolver;
     readonly entries: Map<number, MainRendererAnimationEntry>;
 }
 export interface MainRendererAnimation {
     onUpdate(context: ExtensionUpdateContext): void;
-    prepareAnimation(context: ExtensionPrepareAnimationContext, layer: SVGElement): void;
+    prepareAnimation(context: ExtensionPrepareAnimationContext, slot: SVGGElement): void;
     renderAnimation(context: ExtensionRenderAnimationContext): void;
     cleanAnimation(context: ExtensionCleanAnimationContext): void;
     getSuppressedSquares(): ReadonlySet<Square>;