@yuzhouu/canvas-kit 0.1.2 → 0.1.3

package/_vendor/canvas-core/editor/commands.d.ts

@@ -0,0 +1,126 @@
+import type { Editor } from "./Editor";
+import type { ChangeSource } from "../../store/index";
+import type { AssetId, AssetRecord, AssetRecordBase, BindingId, BindingRecordBase, BindingRecord, Camera, PageId, PageRecord, ShapeId, ShapeParentId, ShapeRecordBase, ShapeRecord, ShapeEditingEntryMode } from "../schema/records";
+export interface EditorCommandOptions {
+    source?: ChangeSource;
+}
+export interface CreateShapeInput {
+    type: ShapeRecordBase["type"];
+    x: number;
+    y: number;
+    props?: Record<string, unknown>;
+    parentId?: ShapeParentId;
+    index?: string;
+    opacity?: number;
+    isHidden?: boolean;
+    rotation?: number;
+    scaleX?: number;
+    scaleY?: number;
+    isLocked?: boolean;
+    meta?: Record<string, unknown>;
+}
+export interface CreateAssetInput {
+    id?: AssetId;
+    type: AssetRecordBase["type"];
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface UpdateAssetInput {
+    id: AssetId;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface ShapeUpdate {
+    id: ShapeId;
+    x?: number;
+    y?: number;
+    rotation?: number;
+    scaleX?: number;
+    scaleY?: number;
+    isHidden?: boolean;
+    isLocked?: boolean;
+    parentId?: ShapeParentId;
+    index?: string;
+    props?: Record<string, unknown>;
+}
+export interface ReparentShapesInput {
+    ids: ShapeId[];
+    parentId: ShapeParentId;
+}
+export interface StartEditingShapeInput {
+    shapeId: ShapeId;
+    entryMode?: ShapeEditingEntryMode;
+    caretPagePoint?: {
+        x: number;
+        y: number;
+    };
+    markId?: string;
+    reuseExistingMark?: boolean;
+    preserveInteraction?: boolean;
+}
+export interface CreateBindingInput {
+    id?: BindingId;
+    type: BindingRecordBase["type"];
+    fromId: ShapeId;
+    toId: ShapeId;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface UpdateBindingInput {
+    id: BindingId;
+    fromId?: ShapeId;
+    toId?: ShapeId;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface CreatePageInput {
+    name?: string;
+    index?: string;
+    meta?: Record<string, unknown>;
+}
+export interface RenamePageInput {
+    id: PageId;
+    name: string;
+}
+export interface MovePageInput {
+    id: PageId;
+    toIndex: number;
+}
+export interface SetCameraInput {
+    pageId?: PageId;
+    camera: Partial<Camera>;
+}
+export interface EditorCommands {
+    createPage(input?: CreatePageInput, options?: EditorCommandOptions): PageRecord;
+    deletePage(id: PageId, options?: EditorCommandOptions): boolean;
+    renamePage(input: RenamePageInput, options?: EditorCommandOptions): void;
+    movePage(input: MovePageInput, options?: EditorCommandOptions): void;
+    createShapes(inputs: CreateShapeInput[], options?: EditorCommandOptions): ShapeRecord[];
+    /**
+     * Persist already-built shape records (with their existing ids) through the
+     * command pipeline. Used by paste/duplicate where ids must be assigned before
+     * parent/binding remapping. Prefer `createShapes` for fresh shapes.
+     */
+    createShapesFromRecords(records: ShapeRecord[], options?: EditorCommandOptions): ShapeRecord[];
+    updateShapes(updates: ShapeUpdate[], options?: EditorCommandOptions): void;
+    reparentShapes(input: ReparentShapesInput, options?: EditorCommandOptions): void;
+    deleteShapes(ids: ShapeId[], options?: EditorCommandOptions): void;
+    createAsset(input: CreateAssetInput, options?: EditorCommandOptions): AssetRecord;
+    /**
+     * Persist already-built asset records (with their existing ids) through the
+     * command pipeline. Used by paste/duplicate. Prefer `createAsset` otherwise.
+     */
+    createAssetsFromRecords(records: AssetRecord[], options?: EditorCommandOptions): AssetRecord[];
+    updateAsset(input: UpdateAssetInput, options?: EditorCommandOptions): AssetRecord | null;
+    deleteAsset(id: AssetId, options?: EditorCommandOptions): boolean;
+    createBinding(input: CreateBindingInput, options?: EditorCommandOptions): BindingRecord;
+    updateBinding(input: UpdateBindingInput, options?: EditorCommandOptions): BindingRecord | null;
+    deleteBinding(id: BindingId, options?: EditorCommandOptions): boolean;
+    setCurrentPageId(id: PageId, options?: EditorCommandOptions): void;
+    setCamera(input: SetCameraInput, options?: EditorCommandOptions): void;
+    setSelectedShapeIds(ids: ShapeId[], options?: EditorCommandOptions): void;
+    setActiveTool(toolId: string, options?: EditorCommandOptions): void;
+    setToolLocked(locked: boolean, options?: EditorCommandOptions): void;
+}
+export declare function createEditorCommands(editor: Editor): EditorCommands;
+export declare function reparentShapeToContainingParent(editor: Editor, shapeId: ShapeId, options?: EditorCommandOptions): void;

package/_vendor/canvas-core/editor/edgeScroll.d.ts

@@ -0,0 +1,5 @@
+import { Vec } from "../geometry/Vec";
+export declare function getEdgeScrollDelta(screenPoint: Vec, viewportSize: {
+    w: number;
+    h: number;
+}, elapsed: number): Vec;

package/_vendor/canvas-core/editor/editorComputedHelpers.d.ts

@@ -0,0 +1,21 @@
+import type { Box } from "../geometry/Box";
+import type { Vec } from "../geometry/Vec";
+import type { AssetId, PageId, ShapeId, ShapeRecord } from "../schema/records";
+import type { ArrowBindingPreviewState } from "./selection";
+import type { EditorOverlayDebugState, EditorRenderHostDebugState, RenderItem } from "./Editor";
+export declare function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean;
+export declare function areVecsEqual(a: Vec | null, b: Vec | null): boolean;
+export declare function areVecArraysEqual(a: readonly Vec[], b: readonly Vec[]): boolean;
+export declare function areBoxesEqual(a: Box | null, b: Box | null): boolean;
+export declare function isValidBox(box: Box): boolean;
+export declare function areRenderHostDebugStatesEqual(a: EditorRenderHostDebugState, b: EditorRenderHostDebugState): boolean;
+export declare function areOverlayDebugStatesEqual(a: EditorOverlayDebugState, b: EditorOverlayDebugState): boolean;
+export declare function getBoxDebugSummary(box: Box | null): string;
+export declare function getShapePageIdFromParentChain(shape: ShapeRecord, shapeById: ReadonlyMap<ShapeId, ShapeRecord>, pageIds: ReadonlySet<PageId>): PageId | null;
+export declare function areBindingPreviewStatesEqual(a: ArrowBindingPreviewState | null, b: ArrowBindingPreviewState | null): boolean;
+export declare function areRenderItemsEqual(a: RenderItem[], b: RenderItem[]): boolean;
+export declare function areShapeIdSetsEqual(a: Set<ShapeId>, b: Set<ShapeId>): boolean;
+export declare function getCommonShapeType(shapes: readonly ShapeRecord[]): ShapeRecord["type"] | null;
+export declare function getShapeAssetId(shape: ShapeRecord): AssetId | null;
+export declare function areSerializableValuesEqual(a: unknown, b: unknown): boolean;
+export declare function areShapePropsPatchesEqual(a: Readonly<Record<string, unknown>>, b: Readonly<Record<string, unknown>>): boolean;

package/_vendor/canvas-core/editor/editorSelectionTransforms.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeSource } from "../../store/index";
+import type { ShapeSelectionFlipAxis } from "../shapes/ShapeUtil";
+import type { ShapeUpdate } from "./commands";
+import type { Editor } from "./Editor";
+export declare function resetEditorSelectionRotation(editor: Editor, source?: ChangeSource): void;
+export declare function getEditorSelectionFlipUpdates(editor: Editor, axis: ShapeSelectionFlipAxis): ShapeUpdate[];

package/_vendor/canvas-core/editor/events.d.ts

@@ -0,0 +1,71 @@
+import type { Vec } from "../geometry/Vec";
+export type EditorPointerType = "mouse" | "touch" | "pen";
+export type EditorClickEventName = "double_click";
+export interface PointerEditorEvent {
+    type: "pointer";
+    name: "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel";
+    timestamp: number;
+    pointerId: number;
+    button: number;
+    buttons: number;
+    pointerType: EditorPointerType;
+    clickCount?: number;
+    screenPoint: Vec;
+    pagePoint: Vec;
+    pressure: number;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface ClickEditorEvent {
+    type: "click";
+    name: EditorClickEventName;
+    phase: "down" | "up";
+    timestamp: number;
+    pointerId: number;
+    button: number;
+    buttons: number;
+    pointerType: EditorPointerType;
+    screenPoint: Vec;
+    pagePoint: Vec;
+    pressure: number;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface KeyboardEditorEvent {
+    type: "keyboard";
+    name: "key_down" | "key_up";
+    key: string;
+    code: string;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface WheelEditorEvent {
+    type: "wheel";
+    screenPoint: Vec;
+    pagePoint: Vec;
+    delta: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export interface TickEditorEvent {
+    type: "tick";
+    timestamp: number;
+    elapsed: number;
+}
+export interface CancelEditorEvent {
+    type: "cancel";
+    reason: "escape" | "pointer_cancel" | "blur" | "page_switch" | "tool_switch" | "dispose" | "command" | "restore";
+}
+export type EditorEvent = PointerEditorEvent | ClickEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;

package/_vendor/canvas-core/editor/{index.ts → index.d.ts}

@@ -3,10 +3,6 @@ export { StateNode } from "./StateNode";
 export { HistoryManager } from "./HistoryManager";
 export { InputsManager } from "./managers/InputsManager";
 export { QueryManager } from "./managers/QueryManager";
-export {
-  SpatialIndexManager,
-  type ShapeAtPointOptions,
-  type SpatialQueryOptions,
-} from "./managers/SpatialIndexManager";
+export { SpatialIndexManager, type ShapeAtPointOptions, type SpatialQueryOptions, } from "./managers/SpatialIndexManager";
 export { ToolManager } from "./managers/ToolManager";
 export type { EditorEvent } from "./events";

package/_vendor/canvas-core/editor/interactions.d.ts

@@ -0,0 +1,51 @@
+import type { ChangeSource } from "../../store/index";
+import type { Vec } from "../geometry/Vec";
+import type { ShapeId, ShapeRecord } from "../schema/records";
+import type { Editor } from "./Editor";
+import type { EditorEvent } from "./events";
+import type { SelectionHandle } from "./selection";
+import type { HandleSnapContext, HandleSnapMode } from "./managers/snapTypes";
+export interface SelectionHandleInteractionInput {
+    handle: SelectionHandle;
+    shape: ShapeRecord;
+    originPagePoint: Vec;
+}
+export interface SelectionHandleInteractionSession {
+    readonly shapeId: ShapeId;
+    readonly historyMark: string;
+    readonly handleSnapMode?: HandleSnapMode;
+    readonly handleSnapContext?: HandleSnapContext;
+    readonly allowSelfSnap?: boolean;
+    readonly excludedSnapShapeIds?: readonly ShapeId[];
+    readonly shouldClearBindingPreviewOnExit?: boolean;
+    update(input: {
+        editor: Editor;
+        pagePoint: Vec;
+        accelKey: boolean;
+        source: ChangeSource;
+    }): "continue" | "stop" | SelectionHandleInteractionUpdateResult;
+}
+export interface SelectionHandleInteractionUpdateResult {
+    status: "continue" | "stop";
+    finalPagePoint?: Vec | null;
+}
+export interface SelectionHandleInteractionHandler {
+    createSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+}
+export type EditorEventInteractionDecision = "continue" | "handled";
+export interface EditorEventInteractionHandler {
+    handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
+}
+export interface LandInteractionHandler {
+    id: string;
+    editorEvent?: EditorEventInteractionHandler;
+    selectionHandle?: SelectionHandleInteractionHandler;
+}
+export declare class InteractionHandlerRegistry {
+    private readonly handlers;
+    private readonly registeredIds;
+    register(handler: LandInteractionHandler): void;
+    getHandlers(): readonly LandInteractionHandler[];
+    handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision;
+    createSelectionHandleSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+}

package/_vendor/canvas-core/editor/internal.d.ts

@@ -0,0 +1,7 @@
+import type { Editor } from "./Editor";
+import type { Store } from "../../store/index";
+import type { EditorRecord } from "../schema/records";
+declare const editorStoreSymbol: unique symbol;
+export declare function setEditorStore(editor: Editor, store: Store<EditorRecord>): void;
+export declare function getEditorStore(editor: Editor): Store<EditorRecord>;
+export { editorStoreSymbol };

package/_vendor/canvas-core/editor/managers/BindingManager.d.ts

@@ -0,0 +1,27 @@
+import type { ChangeSource } from "../../../store/index";
+import { type BindingId, type BindingRecord, type ShapeId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../Editor";
+export interface ShapeChangeEntry {
+    before: ShapeRecord;
+    after: ShapeRecord;
+}
+export declare class BindingManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
+    getConflictingBindings(binding: BindingRecord): BindingRecord[];
+    canBind(binding: BindingRecord): boolean;
+    syncCreatedBinding(binding: BindingRecord, source: ChangeSource): void;
+    syncUpdatedBinding(before: BindingRecord, after: BindingRecord, source: ChangeSource): void;
+    repairLoadedBindings(source: ChangeSource): void;
+    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource, options?: {
+        skipBindingIds?: ReadonlySet<BindingId>;
+    }): void;
+    cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
+    cleanupBindings(ids: BindingId[], source: ChangeSource): void;
+    private applyEffect;
+    private getAllBindings;
+    private getExclusiveBindingKey;
+}

package/_vendor/canvas-core/editor/managers/CameraManager.d.ts

@@ -0,0 +1,39 @@
+import { type Signal } from "../../../signals/index";
+import type { ChangeSource } from "../../../store/index";
+import { Vec } from "../../geometry/Vec";
+import { type Camera } from "../../schema/records";
+import type { PageId } from "../../schema/records";
+import type { Editor } from "../Editor";
+/**
+ * Camera and viewport-screen-size state for the editor. Owns the viewport size
+ * atom (viewport + camera together define the page<->screen transform) and the
+ * camera read/write/transform operations carved out of the Editor facade so the
+ * editor can stay a thinner delegating surface. The Editor exposes thin wrappers
+ * that forward here and re-publishes {@link viewportScreenSizeSignal}.
+ */
+export declare class CameraManager {
+    private readonly editor;
+    private readonly _viewportScreenSizeSignal;
+    readonly viewportScreenSizeSignal: Signal<{
+        w: number;
+        h: number;
+    }>;
+    constructor(editor: Editor);
+    getCurrentCamera(): Camera;
+    getCamera(pageId?: PageId): Camera;
+    pageToScreen(point: Vec, pageId?: PageId): Vec;
+    screenToPage(point: Vec, pageId?: PageId): Vec;
+    setCamera(partial: Partial<Camera>, options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    panCamera(delta: Vec, source?: ChangeSource): void;
+    zoomCameraAtScreenPoint(screenPoint: Vec, deltaY: number, source?: ChangeSource): void;
+    zoomCameraToScreenPoint(screenPoint: Vec, zoom: number, source?: ChangeSource): void;
+    zoomAtViewportCenter(deltaY: number, source?: ChangeSource): void;
+    resetZoom(source?: ChangeSource): void;
+    setViewportScreenSize(size: {
+        w: number;
+        h: number;
+    }): void;
+}

package/_vendor/canvas-core/editor/managers/ClipboardManager.d.ts

@@ -0,0 +1,14 @@
+import type { ShapeId } from "../../schema/records";
+import { type DuplicateSelectionInput, type EditorClipboardPayload, type PasteClipboardPayloadInput } from "../clipboard";
+import type { Editor } from "../Editor";
+/**
+ * Clipboard operations over editor selections. The Editor exposes thin wrappers
+ * that forward here.
+ */
+export declare class ClipboardManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    createPayloadFromSelection(): EditorClipboardPayload | null;
+    pastePayload(input: PasteClipboardPayloadInput): ShapeId[];
+    duplicateSelection(input?: DuplicateSelectionInput): ShapeId[];
+}

package/_vendor/canvas-core/editor/managers/DocumentSnapshotManager.d.ts

@@ -0,0 +1,28 @@
+import type { ChangeSource } from "../../../store/index";
+import { type EditorRecord } from "../../schema/records";
+import { type DocumentSnapshot, type SessionSnapshot } from "../../schema/snapshots";
+import type { Editor } from "../Editor";
+/**
+ * Document/session snapshot serialization, restore, and post-restore repair.
+ * The Editor exposes thin wrappers that forward here.
+ */
+export declare class DocumentSnapshotManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    buildInitialRecords(documentSnapshot: unknown, sessionSnapshot: unknown): EditorRecord[];
+    getDocumentSnapshot(): DocumentSnapshot;
+    getSessionSnapshot(): SessionSnapshot;
+    loadDocumentSnapshot(snapshot: unknown, options?: {
+        source?: ChangeSource;
+    }): void;
+    loadSessionSnapshot(snapshot: unknown, options?: {
+        source?: ChangeSource;
+    }): void;
+    syncAfterDocumentRestore(): void;
+    ensureSessionIntegrity(): void;
+    private syncAfterDocumentSnapshotLoad;
+    private repairCameraByPage;
+    private repairSelectionByPage;
+    private parseInitialDocumentSnapshot;
+    private parseInitialSessionSnapshot;
+}

package/_vendor/canvas-core/editor/managers/InputsManager.d.ts

@@ -0,0 +1,44 @@
+import type { EditorEvent, PointerEditorEvent } from "../events";
+import { Vec } from "../../geometry/Vec";
+export type InputDragPhase = "idle" | "pointing" | "dragging";
+export interface InputsState {
+    originPagePoint: Vec | null;
+    currentPagePoint: Vec | null;
+    previousPagePoint: Vec | null;
+    originScreenPoint: Vec | null;
+    currentScreenPoint: Vec | null;
+    previousScreenPoint: Vec | null;
+    currentTimestamp: number | null;
+    previousTimestamp: number | null;
+    pageVelocity: Vec;
+    screenVelocity: Vec;
+    pointerId: number | null;
+    pointerType: PointerEditorEvent["pointerType"] | null;
+    buttons: number;
+    isPointing: boolean;
+    isDragging: boolean;
+    dragPhase: InputDragPhase;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export declare class InputsManager {
+    readonly state: import("../../../signals/index").Atom<InputsState>;
+    setCurrentPointerPoint(input: {
+        timestamp: number;
+        pagePoint: Vec;
+        screenPoint: Vec;
+        shiftKey: boolean;
+        altKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        accelKey: boolean;
+    }): void;
+    handleEvent(event: EditorEvent): void;
+    resetPointer(): void;
+    private handlePointerEvent;
+    private handleKeyboardEvent;
+    private handleWheelEvent;
+}

package/_vendor/canvas-core/editor/managers/InteractionTransientManager.d.ts

@@ -0,0 +1,52 @@
+import { type Signal } from "../../../signals/index";
+import { type ArrowTerminalBindingResolver, type ArrowTerminalBindingResolverInput, type ResolvedArrowTerminalBinding } from "../../bindings/arrow/arrowBindingHelpers";
+import type { Box } from "../../geometry/Box";
+import type { Vec } from "../../geometry/Vec";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../Editor";
+import type { ArrowBindingPreviewState, SnapIndicatorState } from "../selection";
+export interface LaserTrailState {
+    sessionId: number;
+    phase: "active" | "ending";
+    points: Vec[];
+}
+export declare class InteractionTransientManager {
+    private readonly editor;
+    private readonly _brushBoxSignal;
+    readonly brushBoxSignal: Signal<Box | null>;
+    readonly brushBoxActiveSignal: import("../../../signals/index").Computed<boolean>;
+    private readonly _erasingShapeIdsSignal;
+    readonly erasingShapeIdsSignal: Signal<ShapeId[]>;
+    readonly erasingShapeIdsActiveSignal: import("../../../signals/index").Computed<boolean>;
+    private readonly _eraserTrailSignal;
+    readonly eraserTrailSignal: Signal<Vec[]>;
+    readonly eraserTrailActiveSignal: import("../../../signals/index").Computed<boolean>;
+    private readonly _laserTrailSignal;
+    readonly laserTrailSignal: Signal<LaserTrailState | null>;
+    readonly laserTrailActiveSignal: import("../../../signals/index").Computed<boolean>;
+    private nextLaserSessionId;
+    private readonly _bindingPreviewSignal;
+    readonly bindingPreviewSignal: Signal<ArrowBindingPreviewState | null>;
+    readonly bindingPreviewActiveSignal: import("../../../signals/index").Computed<boolean>;
+    private readonly _dropTargetShapeIdSignal;
+    readonly dropTargetShapeIdSignal: Signal<ShapeId | null>;
+    private arrowTerminalBindingResolver;
+    constructor(editor: Editor);
+    setBrushBox(brushBox: Box | null): void;
+    getErasingShapeIds(): ShapeId[];
+    setErasingShapeIds(shapeIds: readonly ShapeId[]): void;
+    clearErasingShapeIds(): void;
+    getEraserTrail(): Vec[];
+    setEraserTrail(points: readonly Vec[]): void;
+    clearEraserTrail(): void;
+    startLaserTrail(): number;
+    setLaserTrail(sessionId: number, points: readonly Vec[]): void;
+    finishLaserTrail(sessionId: number): void;
+    clearLaserTrail(sessionId: number): void;
+    setBindingPreview(preview: ArrowBindingPreviewState | null): void;
+    setDropTargetShapeId(shapeId: ShapeId | null): void;
+    setSnapIndicators(indicators: SnapIndicatorState[] | null): void;
+    setArrowTerminalBindingResolver(resolver: ArrowTerminalBindingResolver): void;
+    resolveArrowTerminalBinding(input: ArrowTerminalBindingResolverInput): ResolvedArrowTerminalBinding;
+    clearSelectionTransients(): void;
+}

package/_vendor/canvas-core/editor/managers/QueryManager.d.ts

@@ -0,0 +1,76 @@
+import { type Signal } from "../../../signals/index";
+import { Box } from "../../geometry/Box";
+import { Mat } from "../../geometry/Mat";
+import { Vec } from "../../geometry/Vec";
+import { type BindingId, type BindingRecord, type PageId, type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../Editor";
+import { type ShapeGeometry } from "../queries/shapeTransforms";
+import { type QueryState } from "./queryState";
+import { type SelectionGeometrySnapshot } from "./selectionGeometry";
+export type ShapeContainment = "inside" | "intersecting" | "outside";
+export declare class QueryManager {
+    private readonly editor;
+    readonly stateSignal: Signal<QueryState>;
+    readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
+    readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
+    readonly selectionGeometrySignal: Signal<SelectionGeometrySnapshot>;
+    readonly selectionPageOutlineVerticesSignal: Signal<Vec[]>;
+    readonly selectionPageBoundsSignal: Signal<Box | null>;
+    readonly selectionFrameBoundsSignal: Signal<Box | null>;
+    readonly selectionHasRotationSignal: Signal<boolean>;
+    readonly selectionRotationSignal: Signal<number>;
+    readonly selectionRotationCenterSignal: Signal<Vec | null>;
+    readonly selectionHasCompatibleRotationSignal: Signal<boolean>;
+    readonly selectionToolbarAnchorPagePointSignal: Signal<Vec | null>;
+    private readonly stateAtom;
+    private readonly shapeQuerySignals;
+    constructor(editor: Editor);
+    getShapeIdsForPage(pageId: PageId): ShapeId[];
+    getShapesForPage(pageId: PageId): ShapeRecord[];
+    getChildShapeIds(parentId: ShapeParentId): ShapeId[];
+    getChildShapes(parentId: ShapeParentId): ShapeRecord[];
+    getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
+    getPageIdForShape(shapeId: ShapeId): PageId | null;
+    getPageIdForShapeParent(parentId: ShapeParentId): PageId | null;
+    getDescendantPageBounds(parentId: ShapeParentId): Box | null;
+    getShapeSubtreePageBounds(shapeId: ShapeId): Box | null;
+    getShapeContainment(containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
+    getContainingShapeParentId(shapeIds: Iterable<ShapeId>): ShapeParentId | null;
+    getContainingParentIdForShapeRecord(shape: ShapeRecord): ShapeParentId | null;
+    getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[];
+    getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]>;
+    isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean;
+    getShapeClippedPageBounds(shapeId: ShapeId): Box | null;
+    private getShapeClipAncestors;
+    private getShapeClipAncestorsForShape;
+    private getShapeChildClipPageBounds;
+    private getShapeIdsForPageSnapshot;
+    private getChildShapeIdsSnapshot;
+    private handleStoreChange;
+    private getShapeQuerySignals;
+    private getShapeGeometrySnapshot;
+    getShapePageBoundsSignal(shapeId: ShapeId): Signal<Box | undefined>;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | undefined;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | undefined;
+    getShapePageBounds(shapeId: ShapeId): Box | undefined;
+    getShapeBounds(shapeId: ShapeId): Box | undefined;
+    getShapePageCenter(shapeId: ShapeId): Vec | undefined;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | undefined;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[] | undefined;
+    getSelectionPageOutlineVertices(): Vec[];
+    getSelectionPageBounds(): Box | null;
+    getSelectionFrameBounds(): Box | null;
+    getSelectionRotation(): number;
+    getSelectionHasRotation(): boolean;
+    getSelectionRotationCenter(): Vec | null;
+    getSelectionHasCompatibleRotation(): boolean;
+    getSelectionToolbarAnchorPagePoint(): Vec | null;
+    getBinding(id: BindingId): BindingRecord | undefined;
+    getBindings(): BindingRecord[];
+    getBindingIdsFromShape(shapeId: ShapeId): BindingId[];
+    getBindingIdsToShape(shapeId: ShapeId): BindingId[];
+    getBindingIdsForShape(shapeId: ShapeId): BindingId[];
+    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
+}

package/_vendor/canvas-core/editor/managers/RenderWindowManager.d.ts

@@ -0,0 +1,25 @@
+import { type Signal } from "../../../signals/index";
+import type { ShapeId } from "../../schema/records";
+import type { Editor, EditorRenderHostDebugState, RenderItem } from "../Editor";
+/**
+ * Render culling and retained-window signals for the editor render host. The
+ * Editor exposes thin signal aliases that forward here.
+ */
+export declare class RenderWindowManager {
+    private readonly editor;
+    readonly shapeRenderOrderByIdSignal: Signal<Map<ShapeId, number>>;
+    readonly culledShapeIdsSignal: Signal<ShapeId[]>;
+    readonly culledShapeIdSetSignal: Signal<Set<ShapeId>>;
+    readonly selectedShapeIdsOutsideCulledSignal: Signal<ShapeId[]>;
+    readonly selectedShapeIdsOutsideCulledSetSignal: Signal<Set<ShapeId>>;
+    readonly renderVisibleShapeIdsSignal: Signal<ShapeId[]>;
+    readonly retainedShapeIdsSignal: Signal<ShapeId[]>;
+    readonly renderVisibleShapeIdSetSignal: Signal<Set<ShapeId>>;
+    readonly renderItemsSignal: Signal<RenderItem[]>;
+    readonly renderHostDebugStateSignal: Signal<EditorRenderHostDebugState>;
+    private readonly retainedBaseShapeWindowSnapshotSignal;
+    private readonly retainedShapeWindowSnapshotSignal;
+    private readonly renderHostDebugStateSnapshotSignal;
+    constructor(editor: Editor);
+    private getPageIndexById;
+}

package/_vendor/canvas-core/editor/managers/SelectionLayoutManager.d.ts

@@ -0,0 +1,29 @@
+import type { ChangeSource } from "../../../store/index";
+import { Box } from "../../geometry/Box";
+import type { PageId } from "../../schema/records";
+import type { Editor } from "../Editor";
+export type AlignMode = "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom";
+export type DistributeAxis = "horizontal" | "vertical";
+export interface ZoomToBoundsOptions {
+    padding?: number;
+    maxZoom?: number;
+    source?: ChangeSource;
+}
+/**
+ * Selection alignment / distribution and viewport-fit camera moves. These are
+ * cohesive, page-space selection operations carved out of the Editor facade so
+ * the editor can stay a thinner delegating surface. The Editor exposes thin
+ * wrappers that forward here.
+ */
+export declare class SelectionLayoutManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    align(mode: AlignMode, source?: ChangeSource): boolean;
+    distribute(axis: DistributeAxis, source?: ChangeSource): boolean;
+    getCurrentPageBounds(pageId?: PageId): Box | null;
+    zoomToBounds(bounds: Box, options?: ZoomToBoundsOptions): boolean;
+    zoomToFit(options?: ZoomToBoundsOptions): boolean;
+    zoomToSelection(options?: ZoomToBoundsOptions): boolean;
+    private boundsOfShapeIds;
+    private getAlignableEntries;
+}