@mirasen/chessboard 1.1.5 → 1.2.1

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

@@ -0,0 +1,123 @@
+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 renderCommittedAnnotations(state, geometry) {
+    assert(state.slotRoots, 'Expected slotRoots to be initialized before rendering annotations');
+    renderCommittedCircles(state, geometry);
+    renderCommittedArrows(state, geometry);
+}
+function getSuppressedCircleKey(state) {
+    const gesture = state.activeDrawGesture;
+    const target = state.activeDrawPreviewTarget;
+    if (gesture === null || target === null)
+        return null;
+    if (target !== gesture.sourceSquare)
+        return null;
+    const existing = state.annotations.circles.get(target);
+    if (existing === undefined || existing.color !== gesture.color)
+        return null;
+    return target;
+}
+function getSuppressedArrowKey(state) {
+    const gesture = state.activeDrawGesture;
+    const target = state.activeDrawPreviewTarget;
+    if (gesture === null || target === null)
+        return null;
+    if (target === gesture.sourceSquare)
+        return null;
+    const key = arrowAnnotationKeyNormalized(gesture.sourceSquare, target);
+    const existing = state.annotations.arrows.get(key);
+    if (existing === undefined || existing.color !== gesture.color)
+        return null;
+    return key;
+}
+function renderCommittedCircles(state, geometry) {
+    const { committed } = VISUAL_CONFIG.circle;
+    const suppressedKey = getSuppressedCircleKey(state);
+    const seenKeys = new Set();
+    for (const [key, circle] of state.annotations.circles) {
+        if (key === suppressedKey)
+            continue;
+        seenKeys.add(key);
+        const params = {
+            parent: state.slotRoots.overPieces,
+            dataId: `annotation-circle-committed-${key}`,
+            square: circle.square,
+            color: circle.color,
+            radius: committed.radius,
+            strokeWidth: committed.strokeWidth,
+            opacity: committed.opacity,
+            geometry
+        };
+        const existing = state.svg.svgCircles.get(key);
+        if (existing) {
+            updateAnnotationCircleSvg(existing, params);
+        }
+        else {
+            const rendered = createAnnotationCircleSvg(params);
+            state.svg.svgCircles.set(key, rendered);
+        }
+    }
+    for (const [key, rendered] of state.svg.svgCircles) {
+        if (!seenKeys.has(key)) {
+            removeAnnotationCircleSvg(rendered);
+            state.svg.svgCircles.delete(key);
+        }
+    }
+}
+function renderCommittedArrows(state, geometry) {
+    const { committed } = VISUAL_CONFIG.arrow;
+    const suppressedKey = getSuppressedArrowKey(state);
+    const seenKeys = new Set();
+    for (const [key, arrow] of state.annotations.arrows) {
+        if (key === suppressedKey)
+            continue;
+        seenKeys.add(key);
+        const fromRect = geometry.getSquareRect(arrow.from);
+        const toRect = geometry.getSquareRect(arrow.to);
+        const fromCx = fromRect.x + fromRect.width / 2;
+        const fromCy = fromRect.y + fromRect.height / 2;
+        const toCx = toRect.x + toRect.width / 2;
+        const toCy = toRect.y + toRect.height / 2;
+        const dx = toCx - fromCx;
+        const dy = toCy - fromCy;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist === 0) {
+            seenKeys.delete(key);
+            continue;
+        }
+        const markerId = state.svgIds.makeId('annotations', `arrowhead-${key}`);
+        const markerHref = `url(${state.svgIds.makeHref('annotations', `arrowhead-${key}`)})`;
+        const params = {
+            defsRoot: state.slotRoots.defs,
+            visualRoot: state.slotRoots.overPieces,
+            markerDataId: `annotation-arrowhead-committed-${key}`,
+            markerPathDataId: `annotation-arrowhead-path-committed-${key}`,
+            lineDataId: `annotation-arrow-committed-${key}`,
+            markerId,
+            markerHref,
+            from: arrow.from,
+            to: arrow.to,
+            color: arrow.color,
+            opacity: committed.opacity,
+            visual: committed,
+            geometry
+        };
+        const existing = state.svg.svgArrows.get(key);
+        if (existing) {
+            updateAnnotationArrowSvg(existing, params);
+        }
+        else {
+            const rendered = createAnnotationArrowSvg(params);
+            state.svg.svgArrows.set(key, rendered);
+        }
+    }
+    for (const [key, rendered] of state.svg.svgArrows) {
+        if (!seenKeys.has(key)) {
+            removeAnnotationArrowSvg(rendered);
+            state.svg.svgArrows.delete(key);
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import type { SceneRenderGeometry } from '../../../../../layout/geometry/types.js';
+import type { Square } from '../../../../../state/board/types/internal.js';
+import type { RenderedAnnotationArrowSvg } from '../../types/main.js';
+export interface AnnotationArrowSvgVisualConfig {
+    readonly strokeWidth: number;
+    readonly startOffset: number;
+    readonly endOffset: number;
+    readonly opacity: number;
+    readonly markerWidth: number;
+    readonly markerHeight: number;
+    readonly markerRefX: number;
+    readonly markerRefY: number;
+    readonly markerViewBox: string;
+    readonly markerPathD: string;
+}
+export interface AnnotationArrowSvgParams {
+    readonly defsRoot: SVGDefsElement;
+    readonly visualRoot: SVGGElement;
+    readonly markerDataId: string;
+    readonly markerPathDataId: string;
+    readonly lineDataId: string;
+    readonly markerId: string;
+    readonly markerHref: string;
+    readonly from: Square;
+    readonly to: Square;
+    readonly color: string;
+    readonly opacity: number;
+    readonly visual: AnnotationArrowSvgVisualConfig;
+    readonly geometry: SceneRenderGeometry;
+}
+export declare function createAnnotationArrowSvg(params: AnnotationArrowSvgParams): RenderedAnnotationArrowSvg;
+export declare function updateAnnotationArrowSvg(rendered: RenderedAnnotationArrowSvg, params: AnnotationArrowSvgParams): void;
+export declare function removeAnnotationArrowSvg(rendered: RenderedAnnotationArrowSvg): void;

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

@@ -0,0 +1,93 @@
+import { createSvgElement, updateSvgElementAttributes } from '../../../../../render/svg/helpers.js';
+function computeArrowGeometry(params) {
+    const { from, to, visual, geometry } = params;
+    const squareSize = geometry.squareSize;
+    const fromRect = geometry.getSquareRect(from);
+    const toRect = geometry.getSquareRect(to);
+    const fromCx = fromRect.x + fromRect.width / 2;
+    const fromCy = fromRect.y + fromRect.height / 2;
+    const toCx = toRect.x + toRect.width / 2;
+    const toCy = toRect.y + toRect.height / 2;
+    const dx = toCx - fromCx;
+    const dy = toCy - fromCy;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const ux = dx / dist;
+    const uy = dy / dist;
+    const absoluteStartOffset = squareSize * visual.startOffset;
+    const absoluteEndOffset = squareSize * visual.endOffset;
+    return {
+        x1: (fromCx + ux * absoluteStartOffset).toString(),
+        y1: (fromCy + uy * absoluteStartOffset).toString(),
+        x2: (toCx - ux * absoluteEndOffset).toString(),
+        y2: (toCy - uy * absoluteEndOffset).toString(),
+        strokeWidth: (squareSize * visual.strokeWidth).toString()
+    };
+}
+export function createAnnotationArrowSvg(params) {
+    const { defsRoot, visualRoot, markerDataId, markerPathDataId, lineDataId, markerId, markerHref, color, opacity, visual } = params;
+    const geo = computeArrowGeometry(params);
+    const marker = createSvgElement(defsRoot, 'marker', {
+        'data-chessboard-id': markerDataId,
+        id: markerId,
+        markerUnits: 'strokeWidth',
+        markerWidth: visual.markerWidth.toString(),
+        markerHeight: visual.markerHeight.toString(),
+        refX: visual.markerRefX.toString(),
+        refY: visual.markerRefY.toString(),
+        orient: 'auto',
+        overflow: 'visible',
+        viewBox: visual.markerViewBox
+    });
+    const markerPath = createSvgElement(marker, 'path', {
+        'data-chessboard-id': markerPathDataId,
+        d: visual.markerPathD,
+        fill: color
+    });
+    const line = createSvgElement(visualRoot, 'line', {
+        'data-chessboard-id': lineDataId,
+        x1: geo.x1,
+        y1: geo.y1,
+        x2: geo.x2,
+        y2: geo.y2,
+        stroke: color,
+        'stroke-width': geo.strokeWidth,
+        'stroke-linecap': 'round',
+        opacity: opacity.toString(),
+        'marker-end': markerHref
+    });
+    return { line, marker, markerPath };
+}
+export function updateAnnotationArrowSvg(rendered, params) {
+    const { markerId, markerHref, color, opacity, visual } = params;
+    const geo = computeArrowGeometry(params);
+    updateSvgElementAttributes(rendered.marker, {
+        id: markerId,
+        markerUnits: 'strokeWidth',
+        markerWidth: visual.markerWidth.toString(),
+        markerHeight: visual.markerHeight.toString(),
+        refX: visual.markerRefX.toString(),
+        refY: visual.markerRefY.toString(),
+        orient: 'auto',
+        overflow: 'visible',
+        viewBox: visual.markerViewBox
+    });
+    updateSvgElementAttributes(rendered.markerPath, {
+        d: visual.markerPathD,
+        fill: color
+    });
+    updateSvgElementAttributes(rendered.line, {
+        x1: geo.x1,
+        y1: geo.y1,
+        x2: geo.x2,
+        y2: geo.y2,
+        stroke: color,
+        'stroke-width': geo.strokeWidth,
+        'stroke-linecap': 'round',
+        opacity: opacity.toString(),
+        'marker-end': markerHref
+    });
+}
+export function removeAnnotationArrowSvg(rendered) {
+    rendered.line.remove();
+    rendered.marker.remove();
+}

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

@@ -0,0 +1,18 @@
+import type { SceneRenderGeometry } from '../../../../../layout/geometry/types.js';
+import type { Square } from '../../../../../state/board/types/internal.js';
+import type { RenderedAnnotationCircleSvg } from '../../types/main.js';
+export interface AnnotationCircleSvgAttributeParams {
+    readonly square: Square;
+    readonly color: string;
+    readonly radius: number;
+    readonly strokeWidth: number;
+    readonly opacity: number;
+    readonly geometry: SceneRenderGeometry;
+}
+export interface AnnotationCircleSvgCreateParams extends AnnotationCircleSvgAttributeParams {
+    readonly parent: SVGGElement;
+    readonly dataId: string;
+}
+export declare function createAnnotationCircleSvg(params: AnnotationCircleSvgCreateParams): RenderedAnnotationCircleSvg;
+export declare function updateAnnotationCircleSvg(rendered: RenderedAnnotationCircleSvg, params: AnnotationCircleSvgAttributeParams): void;
+export declare function removeAnnotationCircleSvg(rendered: RenderedAnnotationCircleSvg): void;

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,