@mirasen/chessboard 0.1.0

package/dist/runtime/factory/ui-move.js

@@ -0,0 +1,84 @@
+function createMoveRequestContextInternal(sourceSquare, destination) {
+    return {
+        sourceSquare,
+        destination,
+        status: 'unresolved',
+        resolvedMoveRequest: null
+    };
+}
+function moveRequestContextCanBeAutoResolved(state) {
+    return (state.status === 'unresolved' &&
+        (state.destination.promotedTo === undefined || state.destination.promotedTo.length <= 1));
+}
+function assertCanBeDeferred(state) {
+    if (state.status !== 'unresolved') {
+        throw new Error('Only unresolved move requests can be deferred');
+    }
+}
+function assertCanBeResolved(state) {
+    if (state.status === 'resolved') {
+        throw new Error('Move request is already resolved');
+    }
+}
+function assertCanBeAutoResolved(state) {
+    if (!moveRequestContextCanBeAutoResolved(state)) {
+        throw new Error('Move request cannot be auto-resolved. Either it is already resolved or deferred, or it requires a promotion choice.');
+    }
+}
+function moveRequestContextAutoResolve(state) {
+    assertCanBeAutoResolved(state);
+    const promotedTo = state.destination.promotedTo?.length === 1 ? state.destination.promotedTo[0] : undefined;
+    state.status = 'resolved';
+    state.resolvedMoveRequest = {
+        from: state.sourceSquare,
+        to: state.destination.to,
+        ...(state.destination.capturedSquare !== undefined
+            ? { capturedSquare: state.destination.capturedSquare }
+            : {}),
+        ...(state.destination.secondary !== undefined
+            ? { secondary: state.destination.secondary }
+            : {}),
+        ...(promotedTo !== undefined ? { promotedTo } : {})
+    };
+}
+export function createUIMoveRequestContext(sourceSquare, destination) {
+    const internalState = createMoveRequestContextInternal(sourceSquare, destination);
+    return {
+        get status() {
+            return internalState.status;
+        },
+        get sourceSquare() {
+            return internalState.sourceSquare;
+        },
+        get destination() {
+            return internalState.destination;
+        },
+        get canBeAutoResolved() {
+            return moveRequestContextCanBeAutoResolved(internalState);
+        },
+        get resolvedMoveRequest() {
+            return internalState.resolvedMoveRequest;
+        },
+        defer() {
+            assertCanBeDeferred(internalState);
+            internalState.status = 'deferred';
+        },
+        resolve(request) {
+            assertCanBeResolved(internalState);
+            internalState.status = 'resolved';
+            internalState.resolvedMoveRequest = request;
+        },
+        autoresolve() {
+            moveRequestContextAutoResolve(internalState);
+        },
+        getSnapshot() {
+            return {
+                status: internalState.status,
+                sourceSquare: internalState.sourceSquare,
+                destination: internalState.destination,
+                canBeAutoResolved: moveRequestContextCanBeAutoResolved(internalState),
+                resolvedMoveRequest: internalState.resolvedMoveRequest
+            };
+        }
+    };
+}

package/dist/runtime/input/adapter/factory.d.ts

@@ -0,0 +1,2 @@
+import { InputAdapter, InputAdapterInitOptions } from './types';
+export declare function createInputAdapter(options: InputAdapterInitOptions): InputAdapter;

package/dist/runtime/input/adapter/factory.js

@@ -0,0 +1,55 @@
+import { isPointerRelevantEvent, onPointerCancel, onPointerDown, onPointerLeave, onPointerMove, onPointerUp, releaseCapture } from './pointer';
+function createInputAdapterInternal(options) {
+    return {
+        container: options.container,
+        getGeometry: options.getGeometry,
+        controller: options.controller,
+        activePointerId: null
+    };
+}
+export function createInputAdapter(options) {
+    const internalState = createInputAdapterInternal(options);
+    const onPointerDownHandler = (e) => {
+        if (!isPointerRelevantEvent(e))
+            return;
+        onPointerDown(internalState, e);
+    };
+    const onPointerMoveHandler = (e) => {
+        if (!isPointerRelevantEvent(e))
+            return;
+        onPointerMove(internalState, e);
+    };
+    const onPointerUpHandler = (e) => {
+        if (!isPointerRelevantEvent(e))
+            return;
+        onPointerUp(internalState, e);
+    };
+    const onPointerCancelHandler = (e) => {
+        if (!isPointerRelevantEvent(e))
+            return;
+        onPointerCancel(internalState, e);
+    };
+    const onPointerLeaveHandler = (e) => {
+        if (!isPointerRelevantEvent(e))
+            return;
+        onPointerLeave(internalState, e);
+    };
+    const inputAdapter = {
+        destroy() {
+            if (internalState.activePointerId !== null) {
+                releaseCapture(internalState);
+            }
+            internalState.container.removeEventListener('pointerdown', onPointerDownHandler);
+            internalState.container.removeEventListener('pointermove', onPointerMoveHandler);
+            internalState.container.removeEventListener('pointerup', onPointerUpHandler);
+            internalState.container.removeEventListener('pointercancel', onPointerCancelHandler);
+            internalState.container.removeEventListener('pointerleave', onPointerLeaveHandler);
+        }
+    };
+    internalState.container.addEventListener('pointerdown', onPointerDownHandler);
+    internalState.container.addEventListener('pointermove', onPointerMoveHandler);
+    internalState.container.addEventListener('pointerup', onPointerUpHandler);
+    internalState.container.addEventListener('pointercancel', onPointerCancelHandler);
+    internalState.container.addEventListener('pointerleave', onPointerLeaveHandler);
+    return inputAdapter;
+}

package/dist/runtime/input/adapter/helpers.d.ts

@@ -0,0 +1,5 @@
+import { ScenePoint } from '../../../extensions/types/basic/transient-visuals';
+import { RenderGeometry } from '../../../layout/geometry/types';
+import { Square } from '../../../state/board/types/internal';
+export declare function mapBoardPointToSquare(x: number, y: number, geometry: RenderGeometry): Square | null;
+export declare function clampBoardPoint(point: ScenePoint, geometry: RenderGeometry): ScenePoint;

package/dist/runtime/input/adapter/helpers.js

@@ -0,0 +1,23 @@
+export function mapBoardPointToSquare(x, y, geometry) {
+    if (!Number.isFinite(x) || !Number.isFinite(y))
+        return null;
+    const { boardSize, squareSize, orientation } = geometry;
+    if (x < 0 || x >= boardSize || y < 0 || y >= boardSize)
+        return null;
+    // Grid cell indices, each in [0, 7].
+    const xIndex = Math.floor(x / squareSize);
+    const yIndex = Math.floor(y / squareSize);
+    // Invert the orientation mapping used by geometry.squareRect:
+    //   white: xIndex = file,     yIndex = 7 - rank  →  file = xIndex,     rank = 7 - yIndex
+    //   black: xIndex = 7 - file, yIndex = rank       →  file = 7 - xIndex, rank = yIndex
+    const file = orientation === 0 /* ColorCode.White */ ? xIndex : 7 - xIndex;
+    const rank = orientation === 0 /* ColorCode.White */ ? 7 - yIndex : yIndex;
+    return (rank * 8 + file);
+}
+export function clampBoardPoint(point, geometry) {
+    const { boardSize } = geometry;
+    return {
+        x: Math.min(Math.max(point.x, 0), boardSize),
+        y: Math.min(Math.max(point.y, 0), boardSize)
+    };
+}

package/dist/runtime/input/adapter/pointer.d.ts

@@ -0,0 +1,13 @@
+import { ScenePointerEventType } from '../../../extensions/types/basic/events';
+import { InputAdapterInternal } from './types';
+export type PointerRelevantEvent = PointerEvent & {
+    type: ScenePointerEventType;
+};
+export declare function isPointerRelevantEvent(e: PointerEvent): e is PointerRelevantEvent;
+/** Release capture for the currently tracked pointer and clear tracking state. */
+export declare function releaseCapture(state: InputAdapterInternal): void;
+export declare function onPointerDown(state: InputAdapterInternal, e: PointerRelevantEvent): void;
+export declare function onPointerMove(state: InputAdapterInternal, e: PointerRelevantEvent): void;
+export declare function onPointerUp(state: InputAdapterInternal, e: PointerRelevantEvent): void;
+export declare function onPointerCancel(state: InputAdapterInternal, e: PointerRelevantEvent): void;
+export declare function onPointerLeave(state: InputAdapterInternal, e: PointerRelevantEvent): void;

package/dist/runtime/input/adapter/pointer.js

@@ -0,0 +1,97 @@
+import assert from '@ktarmyshov/assert';
+import { SCENE_POINTER_EVENT_TYPES } from '../../../extensions/types/basic/events';
+import { clampBoardPoint, mapBoardPointToSquare } from './helpers';
+const validPointerEventTypes = new Set(SCENE_POINTER_EVENT_TYPES);
+export function isPointerRelevantEvent(e) {
+    return e instanceof PointerEvent && validPointerEventTypes.has(e.type);
+}
+/** Release capture for the currently tracked pointer and clear tracking state. */
+export function releaseCapture(state) {
+    if (state.activePointerId === null)
+        return;
+    if (state.container.hasPointerCapture(state.activePointerId)) {
+        state.container.releasePointerCapture(state.activePointerId);
+    }
+    state.activePointerId = null;
+}
+function resolvePointerTarget(state, e) {
+    const geometry = state.getGeometry();
+    if (!geometry)
+        return { target: null, rawPoint: null, clampedPoint: null };
+    const rect = state.container.getBoundingClientRect();
+    const x = e.clientX - rect.left;
+    const y = e.clientY - rect.top;
+    const target = mapBoardPointToSquare(x, y, geometry);
+    const point = { x, y };
+    return { target, rawPoint: point, clampedPoint: clampBoardPoint(point, geometry) };
+}
+function makeBoardPointerEvent(e, pointerTarget) {
+    assert(e.defaultPrevented === false, 'Expected event to be unhandled before making BoardPointerEvent');
+    let defaultPrevented = false;
+    return {
+        type: e.type,
+        // DOM part
+        pointerId: e.pointerId,
+        isPrimary: e.isPrimary,
+        button: e.button,
+        buttons: e.buttons,
+        ctrlKey: e.ctrlKey,
+        altKey: e.altKey,
+        shiftKey: e.shiftKey,
+        metaKey: e.metaKey,
+        // Board part
+        rawPoint: pointerTarget.rawPoint,
+        clampedPoint: pointerTarget.clampedPoint,
+        target: pointerTarget.target,
+        // Mechanics
+        get defaultPrevented() {
+            return defaultPrevented;
+        },
+        preventDefault() {
+            defaultPrevented = true;
+        }
+    };
+}
+export function onPointerDown(state, e) {
+    if (!e.isPrimary)
+        return; // ignore non-primary pointers
+    if (state.activePointerId !== null)
+        return; // already tracking
+    state.activePointerId = e.pointerId;
+    state.container.setPointerCapture(e.pointerId);
+    const pointerTarget = resolvePointerTarget(state, e);
+    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
+    e.preventDefault(); // prevent native text selection during drag
+    state.controller.onEvent(boardEvent);
+}
+export function onPointerMove(state, e) {
+    if (e.pointerId !== state.activePointerId)
+        return;
+    const pointerTarget = resolvePointerTarget(state, e);
+    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
+    e.preventDefault(); // prevent native text selection during drag
+    state.controller.onEvent(boardEvent);
+}
+export function onPointerUp(state, e) {
+    if (e.pointerId !== state.activePointerId)
+        return;
+    const pointerTarget = resolvePointerTarget(state, e); // resolve before releasing capture
+    releaseCapture(state);
+    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
+    state.controller.onEvent(boardEvent);
+}
+export function onPointerCancel(state, e) {
+    if (e.pointerId !== state.activePointerId)
+        return;
+    const pointerTarget = resolvePointerTarget(state, e); // resolve before releasing capture
+    releaseCapture(state);
+    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
+    state.controller.onEvent(boardEvent);
+}
+export function onPointerLeave(state, e) {
+    if (e.pointerId !== state.activePointerId)
+        return;
+    const pointerTarget = resolvePointerTarget(state, e);
+    const boardEvent = makeBoardPointerEvent(e, pointerTarget);
+    state.controller.onEvent(boardEvent);
+}

package/dist/runtime/input/adapter/types.d.ts

@@ -0,0 +1,16 @@
+import { RenderGeometry } from '../../../layout/geometry/types';
+import { InteractionController } from '../controller/types';
+export interface InputAdapterInitOptions {
+    container: HTMLElement;
+    getGeometry: () => RenderGeometry | null;
+    controller: InteractionController;
+}
+export interface InputAdapterInternal {
+    readonly container: HTMLElement;
+    readonly getGeometry: () => RenderGeometry | null;
+    readonly controller: InteractionController;
+    activePointerId: number | null;
+}
+export interface InputAdapter {
+    destroy(): void;
+}

package/dist/runtime/input/adapter/types.js

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

package/dist/runtime/input/controller/factory.d.ts

@@ -0,0 +1,2 @@
+import { InteractionController, InteractionControllerInitOptions } from './types';
+export declare function createInteractionController(options: InteractionControllerInitOptions): InteractionController;

package/dist/runtime/input/controller/factory.js

@@ -0,0 +1,32 @@
+import { handlePointerCancel, handlePointerDown, handlePointerLeave, handlePointerMove, handlePointerUp } from './pointer';
+import { transmitTransientInput } from './transient-visuals';
+function createInteractionControllerInternal(options) {
+    return {
+        surface: options.surface
+    };
+}
+export function createInteractionController(options) {
+    const internalState = createInteractionControllerInternal(options);
+    return {
+        onEvent(event) {
+            switch (event.type) {
+                case 'pointerdown':
+                    handlePointerDown(internalState, event);
+                    break;
+                case 'pointermove':
+                    handlePointerMove(internalState, event);
+                    break;
+                case 'pointerup':
+                    handlePointerUp(internalState, event);
+                    break;
+                case 'pointercancel':
+                    handlePointerCancel(internalState, event);
+                    break;
+                case 'pointerleave':
+                    handlePointerLeave(internalState, event);
+                    break;
+            }
+            transmitTransientInput(internalState, event);
+        }
+    };
+}

package/dist/runtime/input/controller/helpers.d.ts

@@ -0,0 +1,3 @@
+import type { Square } from '../../../state/board/types/internal';
+import { InteractionStateSnapshot } from '../../../state/interaction/types/main';
+export declare function canMoveTo(snapshot: InteractionStateSnapshot, target: Square): boolean;

package/dist/runtime/input/controller/helpers.js

@@ -0,0 +1,12 @@
+export function canMoveTo(snapshot, target) {
+    const { movability } = snapshot;
+    if (movability.mode === 0 /* MovabilityModeCode.Disabled */) {
+        return false;
+    }
+    if (movability.mode === 1 /* MovabilityModeCode.Free */) {
+        // Any square except the currently selected/source square is a valid drop target
+        return target !== snapshot.selected?.square;
+    }
+    // strict: target must be in the computed active destinations
+    return snapshot.activeDestinations.has(target);
+}

package/dist/runtime/input/controller/pointer.d.ts

@@ -0,0 +1,7 @@
+import { ScenePointerEvent } from '../../../extensions/types/basic/events';
+import { InteractionControllerInternal } from './types';
+export declare function handlePointerDown(state: InteractionControllerInternal, event: ScenePointerEvent): void;
+export declare function handlePointerMove(state: InteractionControllerInternal, event: ScenePointerEvent): void;
+export declare function handlePointerUp(state: InteractionControllerInternal, event: ScenePointerEvent): void;
+export declare function handlePointerCancel(state: InteractionControllerInternal, event: ScenePointerEvent): void;
+export declare function handlePointerLeave(state: InteractionControllerInternal, event: ScenePointerEvent): void;

package/dist/runtime/input/controller/pointer.js

@@ -0,0 +1,104 @@
+import assert from '@ktarmyshov/assert';
+import { isEmptyPieceCode, isNonEmptyPieceCode } from '../../../state/board/check';
+import { fromPieceCode } from '../../../state/board/piece';
+import { canMoveTo } from './helpers';
+export function handlePointerDown(state, event) {
+    assert(event.type === 'pointerdown', 'handlePointerDown should only be called for pointerdown events');
+    if (event.button !== 0) {
+        // Only handle left-click for now
+        return;
+    }
+    const interaction = state.surface.getInteractionStateSnapshot();
+    if (interaction.dragSession) {
+        // Ignore pointer down events if there's already an active drag session
+        return;
+    }
+    if (event.target !== null) {
+        /**
+         * If piece is already selected, and we have a valid target square event.target
+         * AND it's a different square AND (it's empty OR (has an opponent piece AND is a legal move target))
+         * THEN start a release-targeting drag session
+         */
+        if (interaction.selected && event.target !== interaction.selected.square) {
+            const selectedPieceCode = interaction.selected.pieceCode;
+            assert(isNonEmptyPieceCode(selectedPieceCode), 'Selected piece code must be non-zero');
+            const targetPieceCode = state.surface.getPieceCodeAt(event.target);
+            if (isEmptyPieceCode(targetPieceCode)) {
+                state.surface.startReleaseTargetingDrag(interaction.selected.square, event.target);
+                return;
+            }
+            const isLegalMoveTarget = interaction.movability.mode === 1 /* MovabilityModeCode.Free */ ||
+                (interaction.movability.mode === 2 /* MovabilityModeCode.Strict */ &&
+                    interaction.activeDestinations.has(event.target));
+            if (fromPieceCode(targetPieceCode).color !== fromPieceCode(selectedPieceCode).color &&
+                isLegalMoveTarget) {
+                state.surface.startReleaseTargetingDrag(interaction.selected.square, event.target);
+                return;
+            }
+        }
+        /**
+         * If we are here, then it's not release-targeting.
+         * So it's either a new lift or re-lift of the same piece. In either case, we can just start a lifted drag session if the target is valid.
+         */
+        const pieceCode = state.surface.getPieceCodeAt(event.target);
+        if (!isEmptyPieceCode(pieceCode)) {
+            state.surface.startLiftedDrag(event.target, event.target);
+        }
+    }
+}
+export function handlePointerMove(state, event) {
+    assert(event.type === 'pointermove', 'handlePointerMove should only be called for pointermove events');
+    const interaction = state.surface.getInteractionStateSnapshot();
+    if (interaction.dragSession) {
+        state.surface.updateDragSessionCurrentTarget(event.target);
+    }
+}
+export function handlePointerUp(state, event) {
+    assert(event.type === 'pointerup', 'handlePointerUp should only be called for pointerup events');
+    const interaction = state.surface.getInteractionStateSnapshot();
+    if (!interaction.dragSession) {
+        // No active drag session, so nothing to do on pointer up
+        return;
+    }
+    // Check if the square is the same as the source square of the drag session.
+    // If it is, then we can end the drag session without making a move.
+    if (event.target === interaction.dragSession.sourceSquare) {
+        state.surface.cancelActiveInteraction();
+        return;
+    }
+    // Check if the target square is a valid destination for the selected piece.
+    if (event.target !== null && canMoveTo(interaction, event.target)) {
+        if (interaction.dragSession.type === 'lifted-piece-drag') {
+            state.surface.dropTo(event.target);
+        }
+        else {
+            state.surface.releaseTo(event.target);
+        }
+        return;
+    }
+    // Invalid target: piece returns to source for lifted drag (selection preserved),
+    // or selection is cleared for release targeting.
+    if (interaction.dragSession.type === 'lifted-piece-drag') {
+        state.surface.cancelActiveInteraction();
+    }
+    else {
+        state.surface.cancelInteraction();
+    }
+}
+export function handlePointerCancel(state, event) {
+    assert(event.type === 'pointercancel', 'handlePointerCancel should only be called for pointercancel events');
+    const interaction = state.surface.getInteractionStateSnapshot();
+    if (!interaction.dragSession) {
+        // No active drag session, so nothing to do on pointer cancel
+        return;
+    }
+    // Cancel the active interaction on pointer cancel
+    state.surface.cancelActiveInteraction();
+}
+export function handlePointerLeave(state, event) {
+    assert(event.type === 'pointerleave', 'handlePointerLeave should only be called for pointerleave events');
+    const interaction = state.surface.getInteractionStateSnapshot();
+    if (interaction.dragSession) {
+        state.surface.updateDragSessionCurrentTarget(event.target);
+    }
+}

package/dist/runtime/input/controller/transient-visuals.d.ts

@@ -0,0 +1,3 @@
+import { SceneEvent } from '../../../extensions/types/basic/events';
+import { InteractionControllerInternal } from './types';
+export declare function transmitTransientInput(state: InteractionControllerInternal, event: SceneEvent): void;

package/dist/runtime/input/controller/transient-visuals.js

@@ -0,0 +1,12 @@
+function isPointerEvent(event) {
+    return event.type.startsWith('pointer');
+}
+export function transmitTransientInput(state, event) {
+    if (isPointerEvent(event) && event.rawPoint && event.clampedPoint) {
+        state.surface.transientInput({
+            target: event.target,
+            rawPoint: event.rawPoint,
+            clampedPoint: event.clampedPoint
+        });
+    }
+}

package/dist/runtime/input/controller/types.d.ts

@@ -0,0 +1,25 @@
+import { SceneEvent } from '../../../extensions/types/basic/events';
+import { TransientInput } from '../../../extensions/types/basic/transient-visuals';
+import { PieceCode, Square } from '../../../state/board/types/internal';
+import { InteractionStateSnapshot } from '../../../state/interaction/types/main';
+export interface RuntimeInteractionSurface {
+    getInteractionStateSnapshot(): InteractionStateSnapshot;
+    getPieceCodeAt(square: Square): PieceCode;
+    startLiftedDrag(source: Square, target: Square): void;
+    dropTo(target: Square): void;
+    startReleaseTargetingDrag(source: Square, target: Square): void;
+    releaseTo(target: Square): void;
+    updateDragSessionCurrentTarget(target: Square | null): void;
+    cancelActiveInteraction(): void;
+    cancelInteraction(): void;
+    transientInput(input: TransientInput): void;
+}
+export interface InteractionControllerInternal {
+    readonly surface: RuntimeInteractionSurface;
+}
+export interface InteractionControllerInitOptions {
+    surface: RuntimeInteractionSurface;
+}
+export interface InteractionController {
+    onEvent(event: SceneEvent): void;
+}

package/dist/runtime/input/controller/types.js

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

package/dist/runtime/layout.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeInternal } from './types/main';
+export declare function runtimeRefreshGeometry(state: RuntimeInternal): void;

package/dist/runtime/layout.js

@@ -0,0 +1,10 @@
+import { runtimeValidateIsMounted } from './lifecycle';
+import { runtimeRunMutationPipeline } from './mutation/run';
+export function runtimeRefreshGeometry(state) {
+    runtimeValidateIsMounted(state);
+    state.layout.refreshGeometry({
+        orientation: state.state.view.orientation,
+        container: state.renderSystem.container
+    }, state.mutation.getSession());
+    runtimeRunMutationPipeline(state);
+}

package/dist/runtime/lifecycle.d.ts

@@ -0,0 +1,12 @@
+import { RenderSystem } from '../render/types';
+import { RuntimeInternal } from './types/main';
+export declare function runtimeIsMounted(state: RuntimeInternal): boolean;
+export declare function runtimeValidateIsMounted(state: RuntimeInternal): asserts state is RuntimeInternal & {
+    readonly renderSystem: RuntimeInternal['renderSystem'] & {
+        readonly container: NonNullable<RenderSystem['container']>;
+    };
+};
+export declare function runtimeValidateIsNotMounted(state: RuntimeInternal): void;
+export declare function runtimeMount(state: RuntimeInternal, container: HTMLElement): void;
+export declare function runtimeUnmount(state: RuntimeInternal): void;
+export declare function runtimeDestroy(state: RuntimeInternal): void;

package/dist/runtime/lifecycle.js

@@ -0,0 +1,49 @@
+import assert from '@ktarmyshov/assert';
+import { createInputAdapter } from './input/adapter/factory';
+import { runtimeRefreshGeometry } from './layout';
+export function runtimeIsMounted(state) {
+    return state.renderSystem.isMounted;
+}
+export function runtimeValidateIsMounted(state) {
+    if (!runtimeIsMounted(state)) {
+        throw new Error('Runtime is not mounted. Please call mount() before performing this action.');
+    }
+}
+export function runtimeValidateIsNotMounted(state) {
+    if (runtimeIsMounted(state)) {
+        throw new Error('Runtime is already mounted. This action cannot be performed after mounting.');
+    }
+}
+export function runtimeMount(state, container) {
+    runtimeValidateIsNotMounted(state);
+    state.renderSystem.mount(container);
+    state.resizeObserver = new ResizeObserver(() => {
+        runtimeRefreshGeometry(state);
+    });
+    // Observe will cause immediate first callback!
+    state.resizeObserver.observe(container);
+    assert(state.inputAdapter === null, 'Input adapter should not be initialized before mounting');
+    state.inputAdapter = createInputAdapter({
+        container,
+        getGeometry: () => state.layout.geometry,
+        controller: state.interactionController
+    });
+}
+export function runtimeUnmount(state) {
+    runtimeValidateIsMounted(state);
+    assert(state.inputAdapter !== null, 'Input adapter should be initialized when mounted');
+    state.inputAdapter.destroy();
+    state.inputAdapter = null;
+    if (state.resizeObserver) {
+        state.resizeObserver.disconnect();
+        state.resizeObserver = null;
+    }
+    state.renderSystem.unmount();
+    state.extensionSystem.onUnmount();
+}
+export function runtimeDestroy(state) {
+    if (runtimeIsMounted(state)) {
+        runtimeUnmount(state);
+    }
+    state.extensionSystem.onDestroy();
+}

package/dist/runtime/mutation/extension-update.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeMutationPipe } from './pipeline';
+export declare const extensionSystemUpdatePipe: RuntimeMutationPipe;

package/dist/runtime/mutation/extension-update.js

@@ -0,0 +1,26 @@
+export const extensionSystemUpdatePipe = (context, mutationSession) => {
+    const { current } = context;
+    const hasMutation = mutationSession.hasMutation({
+        prefixes: ['state.', 'layout.']
+    });
+    if (hasMutation) {
+        const stateSnapshot = current.state.getSnapshot();
+        current.extensionSystem.onUpdate({
+            state: current.renderSystem.isMounted
+                ? {
+                    isMounted: true,
+                    state: stateSnapshot,
+                    layout: current.layout.getSnapshot()
+                }
+                : {
+                    isMounted: false,
+                    state: stateSnapshot
+                },
+            mutation: mutationSession
+        });
+        // check if extension system has submitted animations and we need to request an animation pass
+        if (current.extensionSystem.hasSubmittedAnimations) {
+            current.renderSystem.requestRenderAnimation();
+        }
+    }
+};

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

@@ -0,0 +1,2 @@
+import { RuntimeMutationPipeline } from './pipeline';
+export declare function createRuntimeMutationPipeline(): RuntimeMutationPipeline;