@mirasen/chessboard 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createBoard } from './wrapper/factory';
+export type { Chessboard, ChessboardExtensionInput, ChessboardInitOptions, ChessboardRuntimeSurface } from './wrapper/types';
+export type { MoveRequestInput, PiecePositionRecordString } from './state/board/types/input';
+export type { RuntimeStateInitOptions } from './state/types';

package/dist/index.js

@@ -0,0 +1 @@
+export { createBoard } from './wrapper/factory';

package/dist/layout/factory.d.ts

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

package/dist/layout/factory.js

@@ -0,0 +1,33 @@
+import { cloneDeep } from 'es-toolkit/object';
+import { layoutRefreshGeometry } from './reducers';
+function createLayoutInternal() {
+    return {
+        boardSize: 0,
+        orientation: 0 /* ColorCode.White */,
+        geometry: null,
+        layoutEpoch: 0
+    };
+}
+export function createLayout() {
+    const internalState = createLayoutInternal();
+    return {
+        get boardSize() {
+            return internalState.boardSize;
+        },
+        get orientation() {
+            return internalState.orientation;
+        },
+        get geometry() {
+            return internalState.geometry;
+        },
+        get layoutEpoch() {
+            return internalState.layoutEpoch;
+        },
+        refreshGeometry(options, mutationSession) {
+            return mutationSession.addMutation('layout.refreshGeometry', layoutRefreshGeometry(internalState, options));
+        },
+        getSnapshot() {
+            return cloneDeep(internalState);
+        }
+    };
+}

package/dist/layout/geometry/factory.d.ts

@@ -0,0 +1,12 @@
+import { ColorCode } from '../../state/board/types/internal';
+import { RenderGeometry } from './types';
+/**
+ * Create RenderGeometry for a given board size (in px) and orientation.
+ * - Geometry uses an SVG-local coordinate system with origin at top-left.
+ * - Orientation mapping:
+ *   - 'white': files increase left→right (a..h), ranks increase bottom→top (1..8).
+ *              yIndex = 7 - rank, xIndex = file
+ *   - 'black': files increase right→left (a..h), ranks increase top→bottom (1..8).
+ *              yIndex = rank, xIndex = 7 - file
+ */
+export declare function createRenderGeometry(boardSize: number, orientation: ColorCode): RenderGeometry;

package/dist/layout/geometry/factory.js

@@ -0,0 +1,33 @@
+import { fileOf, rankOf } from '../../state/board/coords';
+/**
+ * Create RenderGeometry for a given board size (in px) and orientation.
+ * - Geometry uses an SVG-local coordinate system with origin at top-left.
+ * - Orientation mapping:
+ *   - 'white': files increase left→right (a..h), ranks increase bottom→top (1..8).
+ *              yIndex = 7 - rank, xIndex = file
+ *   - 'black': files increase right→left (a..h), ranks increase top→bottom (1..8).
+ *              yIndex = rank, xIndex = 7 - file
+ */
+export function createRenderGeometry(boardSize, orientation) {
+    if (!(boardSize > 0 && Number.isFinite(boardSize))) {
+        throw new RangeError(`Invalid boardSize: ${boardSize}`);
+    }
+    const squareSize = boardSize / 8;
+    const white = orientation === 0 /* ColorCode.White */;
+    return {
+        boardSize,
+        squareSize,
+        orientation,
+        squareRect(sq) {
+            const f = fileOf(sq);
+            const r = rankOf(sq);
+            const xIndex = white ? f : 7 - f;
+            const yIndex = white ? 7 - r : r;
+            return {
+                x: xIndex * squareSize,
+                y: yIndex * squareSize,
+                size: squareSize
+            };
+        }
+    };
+}

package/dist/layout/geometry/types.d.ts

@@ -0,0 +1,20 @@
+import { ReadonlyDeep } from 'type-fest';
+import { ColorCode, Square } from '../../state/board/types/internal';
+export interface SquareRect {
+    x: number;
+    y: number;
+    size: number;
+}
+export type SquareRectSnapshot = ReadonlyDeep<SquareRect>;
+/**
+ * RenderGeometry represents the derived geometry of the rendered chessboard.
+ * It includes the board size, square size, orientation, and square rectangle mapping.
+ *
+ * It is computed from layout inputs and used by rendering and interaction code.
+ */
+export interface RenderGeometry {
+    readonly boardSize: number;
+    readonly squareSize: number;
+    readonly orientation: ColorCode;
+    squareRect(sq: Square): SquareRectSnapshot;
+}

package/dist/layout/geometry/types.js

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

package/dist/layout/helpers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Measure board size from container (square board fits within host).
+ */
+export declare function measureBoardSize(container: HTMLElement): number;

package/dist/layout/helpers.js

@@ -0,0 +1,6 @@
+/**
+ * Measure board size from container (square board fits within host).
+ */
+export function measureBoardSize(container) {
+    return Math.min(container.clientWidth, container.clientHeight);
+}

package/dist/layout/mutation.d.ts

@@ -0,0 +1,6 @@
+import type { MutationSession } from '../mutation/types';
+export type LayoutMutationPayloadByCause = {
+    'layout.refreshGeometry': undefined;
+};
+export type LayoutMutationCause = keyof LayoutMutationPayloadByCause;
+export type LayoutMutationSession = MutationSession<LayoutMutationPayloadByCause>;

package/dist/layout/mutation.js

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

package/dist/layout/reducers.d.ts

@@ -0,0 +1,2 @@
+import { LayoutInternal, LayoutRefreshOptions } from './types';
+export declare function layoutRefreshGeometry(state: LayoutInternal, options: LayoutRefreshOptions): boolean;

package/dist/layout/reducers.js

@@ -0,0 +1,30 @@
+import { createRenderGeometry } from './geometry/factory';
+import { measureBoardSize } from './helpers';
+export function layoutRefreshGeometry(state, options) {
+    const orientation = options.orientation ?? state.orientation;
+    if (orientation === null) {
+        // At this point we should decide if the geometry is invalid or we throw because we expect that the first pass must deliver the orientation?
+        // For now we throw
+        throw new Error('Orientation is expected to be provided on the first pass of layout.refreshGeometry');
+    }
+    let boardSize = options.container ? measureBoardSize(options.container) : state.boardSize;
+    if (boardSize !== null && boardSize <= 0)
+        boardSize = null;
+    const changed = boardSize !== state.boardSize || orientation !== state.orientation;
+    if (!changed) {
+        return false; // no-op, no relevant changes
+    }
+    // Update the state
+    state.boardSize = boardSize;
+    state.orientation = orientation;
+    if (boardSize === null || orientation === null) {
+        // General invalid-geometry rule. Orientation is currently guarded above,
+        // but this branch stays explicit in case null orientation is allowed later.
+        state.geometry = null;
+    }
+    else {
+        state.geometry = createRenderGeometry(boardSize, orientation);
+    }
+    state.layoutEpoch++;
+    return true;
+}

package/dist/layout/types.d.ts

@@ -0,0 +1,23 @@
+import { ReadonlyDeep } from 'type-fest';
+import { ColorCode } from '../state/board/types/internal';
+import { RenderGeometry } from './geometry/types';
+import { LayoutMutationSession } from './mutation';
+export interface LayoutInternal {
+    boardSize: number | null;
+    orientation: ColorCode | null;
+    geometry: RenderGeometry | null;
+    layoutEpoch: number;
+}
+export type LayoutSnapshot = ReadonlyDeep<LayoutInternal>;
+export interface LayoutRefreshOptions {
+    container?: HTMLElement;
+    orientation?: ColorCode;
+}
+export interface Layout {
+    readonly boardSize: number | null;
+    readonly orientation: ColorCode | null;
+    readonly geometry: RenderGeometry | null;
+    readonly layoutEpoch: number;
+    refreshGeometry(options: LayoutRefreshOptions, mutationSession: LayoutMutationSession): boolean;
+    getSnapshot(): LayoutSnapshot;
+}

package/dist/layout/types.js

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

package/dist/mutation/pipeline.d.ts

@@ -0,0 +1,2 @@
+import type { MutationPipe, MutationPipeline } from './types';
+export declare function createMutationPipeline<PayloadByCause extends Record<string, unknown>, Context>(pipes: readonly MutationPipe<PayloadByCause, Context>[]): MutationPipeline<PayloadByCause, Context>;

package/dist/mutation/pipeline.js

@@ -0,0 +1,36 @@
+import { createMutationSession } from './session';
+export function createMutationPipeline(pipes) {
+    const registeredPipes = [...pipes];
+    const session = createMutationSession();
+    let isRunning = false;
+    return {
+        getSession() {
+            return session;
+        },
+        addMutation(cause, changed, ...payload) {
+            return session.addMutation(cause, changed, ...payload);
+        },
+        run(ctx) {
+            if (isRunning) {
+                throw new Error('Cannot run mutation pipeline recursively');
+            }
+            isRunning = true;
+            // no-op if no mutations recorded
+            if (!session.hasMutation()) {
+                isRunning = false;
+                return false;
+            }
+            try {
+                for (const pipe of registeredPipes) {
+                    pipe(ctx, session);
+                }
+            }
+            finally {
+                // Clear session even if a pipe throws
+                session.clear();
+                isRunning = false;
+            }
+            return true;
+        }
+    };
+}

package/dist/mutation/session.d.ts

@@ -0,0 +1,3 @@
+import type { MutationCause, MutationSession, ReadonlyMutationSession } from './types';
+export declare function createReadonlyMutationSession<PayloadByCause extends Record<string, unknown>>(payloads: ReadonlyMap<MutationCause<PayloadByCause>, PayloadByCause[MutationCause<PayloadByCause>][] | undefined>, clone?: boolean): ReadonlyMutationSession<PayloadByCause>;
+export declare function createMutationSession<PayloadByCause extends Record<string, unknown>>(): MutationSession<PayloadByCause>;

package/dist/mutation/session.js

@@ -0,0 +1,66 @@
+export function createReadonlyMutationSession(payloads, clone = false) {
+    const internalPayloads = clone ? new Map(payloads) : payloads;
+    return {
+        hasMutation(match) {
+            if (!match) {
+                return internalPayloads.size > 0;
+            }
+            const { causes, prefixes } = match;
+            if (causes) {
+                for (const cause of causes) {
+                    if (internalPayloads.has(cause)) {
+                        return true;
+                    }
+                }
+            }
+            if (prefixes) {
+                for (const prefix of prefixes) {
+                    for (const cause of internalPayloads.keys()) {
+                        if (cause.toString().startsWith(prefix.toString())) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        },
+        getPayloads(cause) {
+            return internalPayloads.get(cause);
+        },
+        getAll() {
+            return new Map(internalPayloads);
+        }
+    };
+}
+export function createMutationSession() {
+    const payloads = new Map();
+    const readonlySnapshot = createReadonlyMutationSession(payloads);
+    return {
+        ...readonlySnapshot,
+        addMutation(cause, changed, ...payload) {
+            if (!changed) {
+                return false;
+            }
+            const hasPayload = payload.length > 0;
+            if (payloads.has(cause)) {
+                // We already have this cause recorded, just append payload if provided
+                if (!hasPayload)
+                    return true;
+                // We already have some payloads for this cause
+                const existingPayloads = payloads.get(cause);
+                if (existingPayloads) {
+                    existingPayloads.push(payload[0]);
+                    return true;
+                }
+                payloads.set(cause, [payload[0]]);
+                return true;
+            }
+            // No existing entry for this cause, add new one
+            payloads.set(cause, hasPayload ? [payload[0]] : undefined);
+            return true;
+        },
+        clear() {
+            payloads.clear();
+        }
+    };
+}

package/dist/mutation/types.d.ts

@@ -0,0 +1,26 @@
+export type MutationCause<PayloadByCause extends Record<string, unknown>> = Extract<keyof PayloadByCause, string>;
+export type MutationPayload<PayloadByCause extends Record<string, unknown>> = PayloadByCause[MutationCause<PayloadByCause>];
+type Prefixes<S extends string> = S extends `${infer Head}.${infer Tail}` ? Head | `${Head}.${Prefixes<Tail>}` : never;
+type DotSuffix<T extends string> = `${T}.`;
+type DottedPrefixes<S extends string> = DotSuffix<Prefixes<S>>;
+export type MutationCausePrefixes<PayloadByCause extends Record<string, unknown>> = DottedPrefixes<MutationCause<PayloadByCause>>;
+export interface MutationCauseMatchFilter<PayloadByCause extends Record<string, unknown>> {
+    causes?: Iterable<MutationCause<PayloadByCause>>;
+    prefixes?: Iterable<MutationCausePrefixes<PayloadByCause>>;
+}
+export interface ReadonlyMutationSession<PayloadByCause extends Record<string, unknown>> {
+    hasMutation(match?: MutationCauseMatchFilter<PayloadByCause>): boolean;
+    getPayloads<Cause extends MutationCause<PayloadByCause>>(cause: Cause): PayloadByCause[Cause][] | undefined;
+    getAll<TargetPayloadByCause extends PayloadByCause>(): ReadonlyMap<MutationCause<TargetPayloadByCause>, TargetPayloadByCause[MutationCause<TargetPayloadByCause>][] | undefined>;
+}
+export interface MutationSession<PayloadByCause extends Record<string, unknown>> extends ReadonlyMutationSession<PayloadByCause> {
+    addMutation<Cause extends MutationCause<PayloadByCause>>(cause: Cause, changed: boolean, ...payload: PayloadByCause[Cause] extends undefined ? [] : [payload: PayloadByCause[Cause]]): boolean;
+    clear(): void;
+}
+export type MutationPipe<PayloadByCause extends Record<string, unknown>, Context> = (ctx: Context, mutationSession: MutationSession<PayloadByCause>) => void;
+export interface MutationPipeline<PayloadByCause extends Record<string, unknown>, Context> {
+    getSession(): MutationSession<PayloadByCause>;
+    addMutation<Cause extends MutationCause<PayloadByCause>>(cause: Cause, changed: boolean, ...payload: PayloadByCause[Cause] extends undefined ? [] : [payload: PayloadByCause[Cause]]): boolean;
+    run(ctx: Context): boolean;
+}
+export {};

package/dist/mutation/types.js

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

package/dist/render/factory.d.ts

@@ -0,0 +1,2 @@
+import { RenderSystem, RenderSystemInitOptions } from './types';
+export declare function createRenderSystem(options: RenderSystemInitOptions): RenderSystem;

package/dist/render/factory.js

@@ -0,0 +1,117 @@
+import { renderMount, renderUnmount } from './mount';
+import { performAnimationCleanup, performAnimationPass } from './rendering/animation';
+import { validateIsMounted } from './rendering/helpers';
+import { performRenderPass } from './rendering/state';
+import { performRenderTransientVisualsPass } from './rendering/visuals';
+import { createScheduler } from './scheduler/scheduler';
+import { allocateExtensionSlotRoots, createSvgRoots } from './svg/factory';
+function createRenderInternal(options) {
+    const svgRoots = createSvgRoots(options);
+    const scheduler = createScheduler({
+        render: options.performRender
+    });
+    const extensions = new Map();
+    for (const extensionSystemExt of options.sharedDataFromExtensionSystem.extensions.values()) {
+        const extensionInternal = {
+            id: extensionSystemExt.id,
+            extension: extensionSystemExt,
+            render: {
+                slots: allocateExtensionSlotRoots(svgRoots, extensionSystemExt.id, extensionSystemExt.definition.slots)
+            }
+        };
+        extensions.set(extensionInternal.id, extensionInternal);
+    }
+    return {
+        container: null,
+        currentFrame: null,
+        svgRoots,
+        scheduler,
+        extensions,
+        transientVisualsSubscribers: options.sharedDataFromExtensionSystem.transientVisualsSubscribers
+    };
+}
+function performRender(state, options) {
+    // First we check and run renderPass, then deferred animation cleanup.
+    if (options.stateRequest) {
+        performRenderPass(state, options.stateRequest);
+        performAnimationCleanup(state);
+    }
+    // Then we check and run renderAnimation,
+    if (options.animationRequest) {
+        const nextRequest = performAnimationPass(state);
+        if (nextRequest.requestRenderAnimation) {
+            options.requestRenderAnimation();
+        }
+        if (nextRequest.requestRender) {
+            options.requestRender();
+        }
+    }
+    // Finally we run renderVisuals.
+    if (options.visualsRequest) {
+        performRenderTransientVisualsPass(state, options.visualsRequest);
+    }
+}
+export function createRenderSystem(options) {
+    let pendingStateRequest = null;
+    let pendingAnimationRequest = null;
+    let pendingVisualsRequest = null;
+    function performRenderClosure() {
+        const stateRequest = pendingStateRequest;
+        pendingStateRequest = null;
+        const animationRequest = pendingAnimationRequest;
+        pendingAnimationRequest = null;
+        const visualsRequest = pendingVisualsRequest;
+        pendingVisualsRequest = null;
+        performRender(internalState, {
+            stateRequest: stateRequest,
+            animationRequest: animationRequest,
+            requestRenderAnimation: () => {
+                pendingAnimationRequest = pendingAnimationRequest ?? true;
+                internalState.scheduler.schedule();
+            },
+            requestRender: () => {
+                pendingStateRequest = pendingStateRequest ?? internalState.currentFrame;
+                internalState.scheduler.schedule();
+            },
+            visualsRequest: visualsRequest
+        });
+    }
+    const internalState = createRenderInternal({
+        ...options,
+        performRender: performRenderClosure
+    });
+    return {
+        extensions: internalState.extensions,
+        requestRender(request) {
+            validateIsMounted(internalState);
+            pendingStateRequest = request ?? internalState.currentFrame;
+            internalState.scheduler.schedule();
+        },
+        requestRenderAnimation() {
+            validateIsMounted(internalState);
+            pendingAnimationRequest = true;
+            internalState.scheduler.schedule();
+        },
+        requestRenderVisuals(request) {
+            validateIsMounted(internalState);
+            pendingVisualsRequest = request;
+            internalState.scheduler.schedule();
+        },
+        mount(element) {
+            renderMount(internalState, element);
+        },
+        unmount() {
+            renderUnmount(internalState);
+            internalState.scheduler.cancel();
+            pendingStateRequest = null;
+            pendingAnimationRequest = null;
+            pendingVisualsRequest = null;
+        },
+        get isMounted() {
+            return internalState.container !== null;
+        },
+        get container() {
+            return internalState.container;
+        }
+    };
+}

package/dist/render/mount.d.ts

@@ -0,0 +1,3 @@
+import { RenderSystemInternal } from './types';
+export declare function renderMount(state: RenderSystemInternal, element: HTMLElement): void;
+export declare function renderUnmount(state: RenderSystemInternal): void;

package/dist/render/mount.js

@@ -0,0 +1,28 @@
+import { validateIsMounted, validateIsNotMounted } from './rendering/helpers';
+import { clearElementChildren } from './svg/helpers';
+export function renderMount(state, element) {
+    validateIsNotMounted(state);
+    state.container = element;
+    // mount our svg root to the container
+    element.appendChild(state.svgRoots.svgRoot);
+    // Now call onMount for all extensions with their slot roots
+    for (const extensionRec of state.extensions.values()) {
+        const slotRoots = extensionRec.render.slots;
+        extensionRec.extension.instance.mount({ slotRoots });
+    }
+}
+export function renderUnmount(state) {
+    validateIsMounted(state);
+    for (const extensionRec of state.extensions.values()) {
+        extensionRec.extension.instance.unmount();
+        // clear the slot roots
+        for (const slotRoot of Object.values(extensionRec.render.slots)) {
+            clearElementChildren(slotRoot);
+        }
+    }
+    // remove our svg root from the container
+    state.svgRoots.svgRoot.remove();
+    state.container = null;
+    // Now cleanup the render state
+    state.currentFrame = null;
+}

package/dist/render/rendering/animation.d.ts

@@ -0,0 +1,13 @@
+import { RenderSystemInternal } from '../types';
+export interface RenderAnimationResult {
+    requestRenderAnimation: boolean;
+    requestRender: boolean;
+}
+/**
+ * Runs deferred physical cleanup for all sessions that were marked pendingCleanup
+ * in a previous animation pass. Called at the end of performRenderPass (after stable
+ * base ownership has been rendered) so that animation SVG is never removed before
+ * the unsuppressed base piece layer is rendered.
+ */
+export declare function performAnimationCleanup(state: RenderSystemInternal): void;
+export declare function performAnimationPass(state: RenderSystemInternal): RenderAnimationResult;

package/dist/render/rendering/animation.js

@@ -0,0 +1,92 @@
+import { validateIsMounted } from './helpers';
+/**
+ * Runs deferred physical cleanup for all sessions that were marked pendingCleanup
+ * in a previous animation pass. Called at the end of performRenderPass (after stable
+ * base ownership has been rendered) so that animation SVG is never removed before
+ * the unsuppressed base piece layer is rendered.
+ */
+export function performAnimationCleanup(state) {
+    const currentFrame = state.currentFrame;
+    if (!currentFrame) {
+        throw new Error('performAnimationCleanup() called but no current render frame found. render() must be called before performAnimationCleanup().');
+    }
+    for (const extensionRec of state.extensions.values()) {
+        const pendingSessions = extensionRec.extension.animation
+            .getAll(['ended', 'cancelled'])
+            .filter((s) => s.pendingCleanup);
+        if (pendingSessions.length === 0)
+            continue;
+        const context = {
+            currentFrame,
+            invalidation: extensionRec.extension.invalidation,
+            finishedSessions: pendingSessions
+        };
+        extensionRec.extension.instance.cleanAnimation?.(context);
+        extensionRec.extension.animation.remove(pendingSessions.map((s) => s.id));
+    }
+}
+export function performAnimationPass(state) {
+    validateIsMounted(state);
+    let requestRenderAnimation = false;
+    let requestRender = false;
+    const currentFrame = state.currentFrame;
+    if (!currentFrame) {
+        throw new Error('renderAnimation() called but no current render frame found. render() must be called before renderAnimation().');
+    }
+    for (const extensionRec of state.extensions.values()) {
+        // Prepare submitted sessions
+        const submittedSessions = extensionRec.extension.animation.getAll('submitted');
+        if (submittedSessions.length > 0) {
+            const context = {
+                currentFrame: currentFrame,
+                invalidation: extensionRec.extension.invalidation,
+                submittedSessions: submittedSessions
+            };
+            extensionRec.extension.instance.prepareAnimation?.(context);
+            submittedSessions.forEach((session) => {
+                session.setStatus('active');
+            });
+        }
+        // Render active sessions
+        const activeSessions = extensionRec.extension.animation.getAll('active');
+        if (activeSessions.length > 0) {
+            const context = {
+                currentFrame: currentFrame,
+                invalidation: extensionRec.extension.invalidation,
+                activeSessions: activeSessions
+            };
+            extensionRec.extension.instance.renderAnimation?.(context);
+        }
+        // Detect newly terminal sessions: active sessions that have elapsed their duration
+        const currentTime = performance.now();
+        const newlyEndedSessions = activeSessions.filter((session) => session.startTime + session.duration <= currentTime);
+        newlyEndedSessions.forEach((session) => {
+            session.setStatus('ended');
+        });
+        // Also collect cancelled sessions not yet marked pendingCleanup
+        const cancelledSessions = extensionRec.extension.animation
+            .getAll('cancelled')
+            .filter((s) => !s.pendingCleanup);
+        const terminalSessions = [...newlyEndedSessions, ...cancelledSessions];
+        if (terminalSessions.length > 0) {
+            // Mark for deferred physical cleanup — actual removal happens in performAnimationCleanup,
+            // which runs after performRenderPass so stable base ownership is rendered first.
+            terminalSessions.forEach((session) => session.markPendingCleanup());
+            const context = {
+                currentFrame,
+                invalidation: extensionRec.extension.invalidation,
+                finishedSessions: terminalSessions
+            };
+            extensionRec.extension.instance.onAnimationFinished?.(context);
+            // Invariant B: guarantee a state render is requested so performAnimationCleanup will run.
+            requestRender = true;
+        }
+        requestRenderAnimation =
+            requestRenderAnimation || extensionRec.extension.animation.getAll('active').length > 0;
+        requestRender = requestRender || extensionRec.extension.invalidation.dirtyLayers !== 0;
+    }
+    return {
+        requestRenderAnimation,
+        requestRender
+    };
+}

package/dist/render/rendering/helpers.d.ts

@@ -0,0 +1,3 @@
+import { RenderSystemInternal } from '../types';
+export declare function validateIsMounted(state: RenderSystemInternal): void;
+export declare function validateIsNotMounted(state: RenderSystemInternal): void;

package/dist/render/rendering/helpers.js

@@ -0,0 +1,10 @@
+export function validateIsMounted(state) {
+    if (!state.container) {
+        throw new Error('Render is not mounted to any container. Please mount before requesting renders.');
+    }
+}
+export function validateIsNotMounted(state) {
+    if (state.container) {
+        throw new Error('Render is already mounted to a container. Please unmount before performing this action.');
+    }
+}

package/dist/render/rendering/state.d.ts

@@ -0,0 +1,4 @@
+import { RenderFrameSnapshot } from '../../extensions/types/basic/render';
+import { RenderSystemInternal } from '../types';
+export declare function checkNeedsRender(state: RenderSystemInternal): boolean;
+export declare function performRenderPass(state: RenderSystemInternal, request: RenderFrameSnapshot | null): void;