@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

@@ -0,0 +1,18 @@
+import { type StoreHistoryEntry, type StoreHistoryState } from "../../store/index";
+import { type DocumentRecord } from "../schema/records";
+import type { Editor } from "./editor";
+export type HistoryState = StoreHistoryState;
+export declare class HistoryManager {
+    private readonly editor;
+    private readonly buffer;
+    readonly state: import("../../signals/index").Signal<StoreHistoryState>;
+    constructor(editor: Editor);
+    clear(): void;
+    mark(id: string): void;
+    bailToMark(id: string): void;
+    squashToMark(id: string, label?: string): void;
+    undo(): boolean;
+    redo(): boolean;
+    getEntries(): readonly StoreHistoryEntry<DocumentRecord>[];
+    private handleStoreChange;
+}

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

@@ -0,0 +1,11 @@
+export { Editor } from "./editor";
+export { createEditorWithPlugins, type CreateEditorWithPluginsOptions, } from "./createEditorWithPlugins";
+export { StateNode } from "./stateNode";
+export { HistoryManager } from "./historyManager";
+export { InputsManager } from "./managers/inputsManager";
+export { QueryManager } from "./managers/queryManager";
+export { ShortcutManager, formatKeyboardShortcut, normalizeKeyboardShortcut, } from "./managers/shortcutManager";
+export type { EditorKeyboardShortcutCommand, KeyboardShortcutBinding, KeyboardShortcutChord, KeyboardShortcutEventLike, KeyboardShortcutInput, KeyboardShortcutTarget, } from "./managers/shortcutManager";
+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,55 @@
+import { type Signal } from "../../../signals/index";
+import { type TerminalBindingResolver, type TerminalBindingResolverInput, type ResolvedTerminalBinding } from "../../bindings/terminalBinding";
+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 { BindingPreviewState, 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<BindingPreviewState | null>;
+    readonly bindingPreviewActiveSignal: import("../../../signals/index").Computed<boolean>;
+    private readonly _dropTargetShapeIdSignal;
+    readonly dropTargetShapeIdSignal: Signal<ShapeId | null>;
+    private readonly _selectionTranslationActiveSignal;
+    readonly selectionTranslationActiveSignal: Signal<boolean>;
+    private terminalBindingResolver;
+    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: BindingPreviewState | null): void;
+    setDropTargetShapeId(shapeId: ShapeId | null): void;
+    setSelectionTranslationActive(active: boolean): void;
+    setSnapIndicators(indicators: SnapIndicatorState[] | null): void;
+    setTerminalBindingResolver(resolver: TerminalBindingResolver): void;
+    resolveTerminalBinding(input: TerminalBindingResolverInput): ResolvedTerminalBinding;
+    clearSelectionTransients(): void;
+}

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

@@ -0,0 +1,77 @@
+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 selectionAnchorPagePointSignal: 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;
+    getContainingShapeParentIdAtPoint(shapeIds: Iterable<ShapeId>, point: Vec): 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;
+    getSelectionAnchorPagePoint(): 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/queryState.d.ts

@@ -0,0 +1,18 @@
+import type { StoreChange } from "../../../store/index";
+import { type BindingId, type BindingRecord, type EditorRecord, type PageId, type ShapeId, type ShapeParentId } from "../../schema/records";
+export interface QueryState {
+    pageShapeIdsByPage: Map<PageId, ShapeId[]>;
+    childShapeIdsByParent: Map<ShapeParentId, ShapeId[]>;
+    pageIdByShape: Map<ShapeId, PageId>;
+    bindingById: Map<BindingId, BindingRecord>;
+    bindingIdsByFromShape: Map<ShapeId, BindingId[]>;
+    bindingIdsByToShape: Map<ShapeId, BindingId[]>;
+    relatedBindingIdsByShape: Map<ShapeId, BindingId[]>;
+}
+type ReadEditorRecord = (id: string) => EditorRecord | undefined;
+export declare function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean;
+export declare function compareBindings(left: BindingRecord, right: BindingRecord): number;
+export declare function buildQueryState(records: EditorRecord[]): QueryState;
+export declare function getRemovedShapeIdsFromQueryStateChange(change: StoreChange<EditorRecord>): ShapeId[];
+export declare function updateQueryStateFromStoreChange(previous: QueryState, change: StoreChange<EditorRecord>, getRecord: ReadEditorRecord): QueryState;
+export {};

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/selectionGeometry.d.ts

@@ -0,0 +1,28 @@
+import { type Signal } from "../../../signals/index";
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { ShapeGeometry } from "../queries/shapeTransforms";
+export interface SelectionGeometrySnapshot {
+    outlineVertices: Vec[];
+    pageBounds: Box | null;
+    frameBounds: Box | null;
+    rotation: number;
+    rotationCenter: Vec | null;
+    selectionAnchorPagePoint: Vec | null;
+    hasRotation: boolean;
+    hasCompatibleRotation: boolean;
+}
+export interface SelectionGeometrySignals {
+    geometry: Signal<SelectionGeometrySnapshot>;
+    pageOutlineVertices: Signal<Vec[]>;
+    pageBounds: Signal<Box | null>;
+    frameBounds: Signal<Box | null>;
+    hasRotation: Signal<boolean>;
+    rotation: Signal<number>;
+    rotationCenter: Signal<Vec | null>;
+    hasCompatibleRotation: Signal<boolean>;
+    selectionAnchorPagePoint: Signal<Vec | null>;
+}
+export declare function createSelectionGeometrySignals(editor: Editor, getShapeGeometrySnapshot: (shapeId: ShapeId) => ShapeGeometry | undefined): SelectionGeometrySignals;

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;
+}

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

@@ -0,0 +1,21 @@
+import type { ChangeSource } from "../../../store/index";
+import type { PageId, ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+/**
+ * Selection-set writes for the editor: which shapes are selected per page. These
+ * are cohesive session-state mutations carved out of the Editor facade so the
+ * editor can stay a thinner delegating surface. Selection geometry and the
+ * rotation/flip transforms live elsewhere (selection.ts /
+ * editorSelectionTransforms.ts); this manager only owns the selected-id sets.
+ * The Editor exposes thin wrappers that forward here.
+ */
+export declare class SelectionManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    setSelectedShapeIds(ids: ShapeId[], options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    removeShapeIdsFromSelection(ids: ShapeId[], source?: ChangeSource): void;
+    selectAllCurrentPage(source?: ChangeSource): void;
+}

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

@@ -0,0 +1,24 @@
+import { type Signal } from "../../../signals/index";
+import type { Editor, EditorOverlayDebugState } from "../editor";
+import type { SelectionBindingSegment, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState } from "../selection";
+/**
+ * Selection overlay derived state: frame geometry/style, handles, combined
+ * overlay state, companion frames, and debug metrics. The Editor exposes thin
+ * signal aliases that forward here.
+ */
+export declare class SelectionOverlayManager {
+    private readonly editor;
+    readonly frameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly companionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly pathSignal: Signal<string | null>;
+    readonly bindingSegmentsSignal: Signal<SelectionBindingSegment[]>;
+    readonly frameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
+    readonly frameSignal: Signal<SelectionOverlayFrameState | null>;
+    readonly handleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly handlesSignal: Signal<SelectionOverlayHandlesState | null>;
+    readonly handleCountsSignal: Signal<SelectionOverlayHandleCountsState | null>;
+    readonly overlaySignal: Signal<SelectionOverlayState | null>;
+    readonly debugStateSignal: Signal<EditorOverlayDebugState>;
+    private readonly debugStateSnapshotSignal;
+    constructor(editor: Editor);
+}

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

@@ -0,0 +1,29 @@
+import { type Signal } from "../../../signals/index";
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeEditingEntryRequest, ShapeEditingSession, ShapeId, ShapeRecord } from "../../schema/records";
+import type { StartEditingShapeInput } from "../commands";
+import type { Editor } from "../editor";
+/**
+ * Shape editing lifecycle for the editor: edit-session entry, completion,
+ * cancellation, composition state, and focus-entry requests. The Editor exposes
+ * thin wrappers that forward here.
+ */
+export declare class ShapeEditingManager {
+    private readonly editor;
+    private readonly entryRequestAtom;
+    readonly entryRequestSignal: Signal<ShapeEditingEntryRequest | null>;
+    private nextEntryRequestId;
+    constructor(editor: Editor);
+    canEditShape(shapeOrId: ShapeRecord | ShapeId | null | undefined): boolean;
+    start(input: StartEditingShapeInput, source?: ChangeSource): ShapeEditingSession | null;
+    complete(source?: ChangeSource): boolean;
+    cancel(source?: ChangeSource): boolean;
+    setComposition(isComposing: boolean, source?: ChangeSource): void;
+    consumeEntryRequest(requestId: number): void;
+    removeShapeIds(ids: ShapeId[], source?: ChangeSource): void;
+    end(options: {
+        runEditEnd: boolean;
+        source: ChangeSource;
+    }): void;
+    private publishEntryRequest;
+}

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

@@ -0,0 +1,42 @@
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type ShapeGeometry } from "../queries/shapeTransforms";
+import type { SelectionFrame } from "../selection";
+/**
+ * Shape and selection geometry facade helpers. Query-backed methods read the
+ * current editor state; compute methods operate on the provided shape snapshot.
+ */
+export declare class ShapeGeometryManager {
+    private readonly editor;
+    constructor(editor: Editor);
+    computeShapeBounds(shape: ShapeRecord): Box;
+    computeShapeLocalBounds(shape: ShapeRecord): Box;
+    computeShapeRenderBounds(shape: ShapeRecord): Box;
+    computeShapeExportBounds(shape: ShapeRecord): Box;
+    computeShapeLocalToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeRenderToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeExportToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageBounds(shape: ShapeRecord): Box;
+    computeShapeExportPageBounds(shape: ShapeRecord): Box;
+    computeShapeGeometry(shape: ShapeRecord): ShapeGeometry;
+    computeShapePositionedToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageCenter(shape: ShapeRecord): Vec;
+    computeShapePageCorners(shape: ShapeRecord): Vec[];
+    computeShapePageOutlineVertices(shape: ShapeRecord): Vec[];
+    getShapeBounds(shapeId: ShapeId): Box | null;
+    getShapePageBounds(shapeId: ShapeId): Box | null;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | null;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | null;
+    getShapePageCenter(shapeId: ShapeId): Vec | null;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | null;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[];
+    getSelectionPageBounds(): Box | null;
+    getSelectionFrame(): SelectionFrame | null;
+    isPointInSelectionBounds(point: Vec): boolean;
+    getSelectionFrameLocalBoundsPoint(point: Vec): Vec | null;
+    getSelectionPageOutlineVertices(): Vec[];
+    getSelectionAnchorPagePoint(): Vec | null;
+}