@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/resizeSnap.d.ts

@@ -0,0 +1,11 @@
+import type { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { SelectionResizeHandleId } from "../selection/selection";
+import type { ResizeSnapInput } from "./snapTypes";
+export declare function getResizeSnapPointsForHandle(handleId: SelectionResizeHandleId | "any", bounds: Box): Vec[];
+export declare function getResizeResultAfterNudge(input: ResizeSnapInput, nudge: Vec): {
+    bounds: Box;
+    scaleX: number;
+    scaleY: number;
+};
+export declare function getResizeBoundsAfterNudge(input: ResizeSnapInput, nudge: Vec): Box;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapDecision.d.ts

@@ -0,0 +1,2 @@
+import type { AxisSnap, AxisSnapOptions, GapAxisSnap, PointAxisSnap } from "./snapResults";
+export declare function chooseAxisSnap(pointSnap: PointAxisSnap | null, gapSnap: GapAxisSnap | null, options?: AxisSnapOptions): AxisSnap | null;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapGeometry.d.ts

@@ -0,0 +1,26 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { SnapAxis, SnapPointKind } from "./snapTypes";
+export declare const EPSILON = 1e-8;
+export declare const BOX_SNAP_POINT_KINDS: readonly SnapPointKind[];
+export declare function getBoxSnapPoints(bounds: Box): Vec[];
+export declare function getAxisValue(point: Vec, axis: SnapAxis): number;
+export declare function getAxisMin(bounds: Box, axis: SnapAxis): number;
+export declare function getAxisMax(bounds: Box, axis: SnapAxis): number;
+export declare function getAxisSize(bounds: Box, axis: SnapAxis): number;
+export declare function getBreadthRange(bounds: Box, axis: SnapAxis): [number, number];
+export declare function getRangeIntersection(first: [number, number], second: [number, number]): [number, number] | null;
+export declare function rangesOverlap(first: [number, number], second: [number, number]): boolean;
+export declare function translateBounds(bounds: Box, delta: Vec): Box;
+export declare function getAxisDelta(axis: SnapAxis, value: number): Vec;
+export declare function translateBoundsOnAxis(bounds: Box, axis: SnapAxis, value: number): Box;
+export declare function translatePoints(points: Vec[], delta: Vec): Vec[];
+export declare function getBoxPagePoints(bounds: Box): Vec[];
+export declare function getBoxLocalOutline(bounds: Box): Vec[];
+export declare function getDistanceToSegmentSquared(point: Vec, segmentStart: Vec, segmentEnd: Vec): number;
+export declare function getNearestPointOnSegment(point: Vec, segmentStart: Vec, segmentEnd: Vec): Vec;
+export declare function getNearestPointOnOutline(point: Vec, outline: readonly Vec[]): {
+    point: Vec;
+    distanceSquared: number;
+} | null;
+export declare function dedupePoints(points: Vec[]): Vec[];

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapIndicators.d.ts

@@ -0,0 +1,22 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState } from "../selection/selection";
+import type { Gap, GapAxisSnap, PointAxisSnap } from "./snapResults";
+import type { SnapAxis, SnapCoordinateSpace, SnapNode } from "./snapTypes";
+export declare function arePointIndicatorsEqual(left: PointSnapIndicatorState, right: PointSnapIndicatorState): boolean;
+export declare function areGapEdgesEqual(left: GapSnapIndicatorGapState, right: GapSnapIndicatorGapState): boolean;
+export declare function areGapIndicatorsEqual(left: GapSnapIndicatorState, right: GapSnapIndicatorState): boolean;
+export declare function areIndicatorsEqual(left: SnapIndicatorState[], right: SnapIndicatorState[]): boolean;
+export declare function getGapEdges(gap: Gap): GapSnapIndicatorGapState;
+export declare function getPointIndicator(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace): PointSnapIndicatorState;
+export declare function getPointIndicators(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace): PointSnapIndicatorState[];
+export declare function getPointSnapGroups(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec): PointAxisSnap[];
+export declare function getAxisExtentPoints(axis: SnapAxis, axisValue: number, bounds: Box): Vec[];
+export declare function getPointIndicatorLine(axis: SnapAxis, points: readonly Vec[]): [Vec, Vec];
+export declare function getPointIndicatorId(axis: SnapAxis, line: readonly [Vec, Vec], points: readonly Vec[]): string;
+export declare function getPointIndicatorWithBoundsExtent(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace, bounds: Box, candidateNodes: readonly SnapNode[]): PointSnapIndicatorState;
+export declare function getPointIndicatorsWithBoundsExtent(axis: SnapAxis, snap: PointAxisSnap, finalNudge: Vec, coordinateSpace: SnapCoordinateSpace, bounds: Box, candidateNodes: readonly SnapNode[]): PointSnapIndicatorState[];
+export declare function getHandlePointIndicator(snappedPagePoint: Vec): PointSnapIndicatorState;
+export declare function getHandleAlignIndicator(axis: SnapAxis, snappedPagePoint: Vec, targetPoint: Vec): PointSnapIndicatorState;
+export declare function getGapIndicator(snap: GapAxisSnap, coordinateSpace: SnapCoordinateSpace, finalNudge: Vec): SnapIndicatorState;
+export declare function cloneIndicator(indicator: SnapIndicatorState): SnapIndicatorState;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapManager.d.ts

@@ -0,0 +1,54 @@
+import type { Signal } from "../../../signals/index";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { SnapIndicatorState } from "../selection/selection";
+import type { HandleSnapInput, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapCoordinateSpace, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot } from "./snapTypes";
+export interface SnapDiagnosticsState {
+    operation: "translate" | "resize" | "handle";
+    durationMs: number;
+    pointCount: number;
+    nodeCount: number;
+    outlineCount?: number;
+    candidatePointCount?: number;
+    candidateGapCount?: number;
+    matchedPointCount?: number;
+    xSnapId?: string | null;
+    ySnapId?: string | null;
+    indicatorCount: number;
+}
+export interface SnapDiagnostics {
+    now?(): number;
+    onEvaluation?(state: SnapDiagnosticsState): void;
+}
+export declare class SnapManager {
+    private readonly diagnostics;
+    private readonly gapCache;
+    private readonly _indicatorsSignal;
+    readonly indicatorsSignal: Signal<SnapIndicatorState[]>;
+    readonly activeSignal: Signal<boolean>;
+    private readonly snapshots;
+    private readonly axisSnapMemory;
+    constructor(editor: Editor, diagnostics?: SnapDiagnostics);
+    setIndicators(indicators: SnapIndicatorState[]): void;
+    clearIndicators(): void;
+    private clearAxisSnapMemory;
+    private getSwitchDistance;
+    private getReleaseThreshold;
+    private updateAxisSnapMemory;
+    private reportDiagnostics;
+    private getNow;
+    createTranslateSnapshot({ movingShapeIds, coordinateSpace, }: {
+        movingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): TranslateSnapSnapshot;
+    createResizeSnapshot({ resizingShapeIds, coordinateSpace, }: {
+        resizingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): ResizeSnapSnapshot;
+    createHandleSnapshot(input: HandleSnapSnapshotInput): HandleSnapSnapshot;
+    snapTranslate(input: TranslateSnapInput): TranslateSnapResult;
+    snapResize(input: ResizeSnapInput): ResizeSnapResult;
+    snapHandle(input: HandleSnapInput): HandleSnapResult | null;
+    private snapHandlePoint;
+    private snapHandleAlign;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapResults.d.ts

@@ -0,0 +1,58 @@
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId } from "../../schema/records";
+import type { SnapNode, SnapPointKind } from "./snapTypes";
+export interface PointSnapPair {
+    selectionPoint: Vec;
+    selectionPointKind?: SnapPointKind;
+    candidatePoint: Vec;
+    candidatePointKind?: SnapPointKind;
+    candidatePointId: string;
+    candidateNodeId: ShapeId;
+}
+export interface PointAxisSnap {
+    type: "points";
+    id: string;
+    nudge: number;
+    distance: number;
+    weight: number;
+    candidatePointIds: string[];
+    pairs: PointSnapPair[];
+}
+export interface Gap {
+    direction: "horizontal" | "vertical";
+    startNode: SnapNode;
+    endNode: SnapNode;
+    length: number;
+    breadthIntersection: [number, number];
+}
+export interface GapAxisSnap {
+    type: "gaps";
+    id: string;
+    nudge: number;
+    distance: number;
+    gaps: Gap[];
+}
+export type AxisSnap = PointAxisSnap | GapAxisSnap;
+export interface PointSnapOptions {
+    previousCandidatePointIds?: ReadonlySet<string>;
+    releaseThreshold?: number;
+    selectionPointKinds?: readonly (SnapPointKind | undefined)[];
+    switchDistance?: number;
+    stats?: PointSnapStats;
+}
+export interface GapSnapOptions {
+    previousSnapId?: string | null;
+    releaseThreshold?: number;
+    switchDistance?: number;
+}
+export interface AxisSnapOptions {
+    previousSnap?: {
+        type: AxisSnap["type"];
+        id: string;
+    } | null;
+    switchDistance?: number;
+}
+export interface PointSnapStats {
+    candidatePointCount: number;
+    matchedPointCount: number;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapSnapshotBuilder.d.ts

@@ -0,0 +1,22 @@
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapSnapshot, SnapCoordinateSpace, TranslateSnapSnapshot } from "./snapTypes";
+export declare class SnapSnapshotBuilder {
+    private readonly editor;
+    constructor(editor: Editor);
+    createTranslateSnapshot({ movingShapeIds, coordinateSpace, }: {
+        movingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): TranslateSnapSnapshot;
+    createResizeSnapshot({ resizingShapeIds, coordinateSpace, }: {
+        resizingShapeIds: Iterable<ShapeId>;
+        coordinateSpace: SnapCoordinateSpace;
+    }): ResizeSnapSnapshot;
+    createHandleSnapshot({ context, currentPagePoint, allowSelfSnap, excludedShapeIds, }: HandleSnapSnapshotInput): HandleSnapSnapshot;
+    private collectHandleSnapGeometry;
+    private collectSelfHandleSnapGeometry;
+    private createBoundsSnapSnapshot;
+    private collectBindingDrivenExcludedShapeIds;
+    private getSnapScopeParentId;
+    private getCandidateShapeIds;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/snapping/snapTypes.d.ts

@@ -0,0 +1,114 @@
+import type { Box } from "../../geometry/box";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+import type { SelectionHandle, SelectionResizeHandleId, SnapIndicatorState } from "../selection/selection";
+export type SnapAxis = "x" | "y";
+export type HandleSnapMode = "none" | "point" | "align";
+export type SnapPointKind = "corner" | "edge_midpoint" | "center" | "custom";
+export interface SnapCoordinateSpace {
+    rotation: number;
+    rotationCenter: Vec;
+}
+export interface SnapPoint {
+    id: string;
+    nodeId: ShapeId;
+    point: Vec;
+    kind?: SnapPointKind;
+    weight?: number;
+}
+export interface SnapPointIndexEntry {
+    value: number;
+    point: SnapPoint;
+}
+export interface SnapPointIndex {
+    x: SnapPointIndexEntry[];
+    y: SnapPointIndexEntry[];
+}
+export interface SnapNode {
+    id: string;
+    bounds: Box;
+}
+export interface HandleSnapContext {
+    shapeId: ShapeId;
+    handle: SelectionHandle;
+}
+export interface HandleSnapPoint {
+    id: string;
+    nodeId: ShapeId;
+    point: Vec;
+    kind?: SnapPointKind;
+    weight?: number;
+}
+export interface HandleSnapOutline {
+    id: ShapeId;
+    points: Vec[];
+}
+export interface HandleSnapSnapshot {
+    points: HandleSnapPoint[];
+    outlines: HandleSnapOutline[];
+    scopeParentId?: ShapeParentId | null;
+    candidateShapeIds?: ShapeId[];
+}
+export interface TranslateSnapSnapshot {
+    points: SnapPoint[];
+    pointIndex: SnapPointIndex;
+    nodes: SnapNode[];
+    coordinateSpace: SnapCoordinateSpace;
+    scopeParentId?: ShapeParentId | null;
+    candidateShapeIds?: ShapeId[];
+}
+export interface TranslateSnapInput {
+    lockedAxis: SnapAxis | null;
+    initialSelectionBounds: Box;
+    dragDelta: Vec;
+    snapshot: TranslateSnapSnapshot;
+    threshold: number;
+}
+export interface TranslateSnapResult {
+    nudge: Vec;
+    indicators: SnapIndicatorState[];
+}
+export interface ResizeSnapSnapshot {
+    points: SnapPoint[];
+    pointIndex: SnapPointIndex;
+    nodes: SnapNode[];
+    coordinateSpace: SnapCoordinateSpace;
+    scopeParentId?: ShapeParentId | null;
+    candidateShapeIds?: ShapeId[];
+}
+export interface ResizeSnapInput {
+    handleId: SelectionResizeHandleId;
+    initialSelectionBounds: Box;
+    resizedSelectionBounds: Box;
+    scaleX: number;
+    scaleY: number;
+    snapshot: ResizeSnapSnapshot;
+    threshold: number;
+    isAspectRatioLocked: boolean;
+    isResizingFromCenter: boolean;
+}
+export interface ResizeSnapResult {
+    nudge: Vec;
+    bounds: Box;
+    scaleX: number;
+    scaleY: number;
+    indicators: SnapIndicatorState[];
+}
+export interface HandleSnapSnapshotInput {
+    context: HandleSnapContext;
+    currentPagePoint: Vec;
+    allowSelfSnap?: boolean;
+    excludedShapeIds?: Iterable<ShapeId>;
+}
+export interface HandleSnapInput {
+    mode: HandleSnapMode;
+    pagePoint: Vec;
+    sourcePointOffsets?: readonly Vec[];
+    snapshot: HandleSnapSnapshot;
+    threshold: number;
+}
+export interface HandleSnapResult {
+    snappedPagePoint: Vec;
+    nudge: Vec;
+    indicators: SnapIndicatorState[];
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/state/editorReadModels.d.ts

@@ -0,0 +1,34 @@
+import type { Box } from "../../geometry/box";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeEditingSession, ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
+export interface ShapeTreeSnapshotEntry {
+    id: ShapeId;
+    parentId: ShapeParentId;
+    type: ShapeRecord["type"];
+}
+export interface EditorToolState {
+    activeToolId: string;
+    isToolLocked: boolean;
+}
+export interface EditorShapeEditingState {
+    editingShapeId: ShapeId | null;
+    session: ShapeEditingSession | null;
+}
+export interface EditorSelectionState {
+    count: number;
+    singleShapeType: ShapeRecord["type"] | null;
+    commonShapeType: ShapeRecord["type"] | null;
+    canFlipSelection: boolean;
+    hasPointHandleSelection: boolean;
+    hasFrameSelection: boolean;
+    isMixedFrameAndPointHandleSelection: boolean;
+    canDragPointHandles: boolean;
+    hasSelectionRotation: boolean;
+    hasMixedSelectionRotation: boolean;
+    canResetSelectionRotation: boolean;
+    frameBounds: Box | null;
+    frameRotation: number;
+    frameRotationCenter: Vec | null;
+    selectionAnchorPagePoint: Vec | null;
+}
+export type EditorSelectionMetadata = Omit<EditorSelectionState, "frameBounds" | "frameRotation" | "frameRotationCenter" | "selectionAnchorPagePoint">;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/state/editorSignals.d.ts

@@ -0,0 +1,82 @@
+import type { Signal } from "../../../signals/index";
+import type { Box } from "../../geometry/box";
+import type { Mat } from "../../geometry/mat";
+import type { Vec } from "../../geometry/vec";
+import type { Camera, PageId, PageRecord, SessionRecord, ShapeEditingEntryRequest, ShapeEditingSession, ShapeId, ShapeRecord } from "../../schema/records";
+import type { HistoryState } from "../history/historyManager";
+import type { BindingPreviewState, SelectionBindingSegment, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandlesState, SnapIndicatorState, TerminalBindingGuideState } from "../selection/selection";
+import type { SelectedShapeOverlayItem } from "../selection/selectionOverlay";
+import type { RenderItem } from "../viewport/renderWindow";
+import type { EditorSelectionMetadata, EditorSelectionState, EditorShapeEditingState, EditorToolState, ShapeTreeSnapshotEntry } from "./editorReadModels";
+export interface EditorStateSignals {
+    readonly readonly: Signal<boolean>;
+    readonly session: Signal<SessionRecord>;
+    readonly pages: Signal<PageRecord[]>;
+    readonly currentPageId: Signal<PageId>;
+    readonly currentPageShapeIds: Signal<ShapeId[]>;
+    readonly currentPageShapes: Signal<ShapeRecord[]>;
+    readonly currentPageShapeTree: Signal<ShapeTreeSnapshotEntry[]>;
+    readonly tool: Signal<EditorToolState>;
+    readonly editingShapeId: Signal<ShapeId | null>;
+    readonly shapeEditingSession: Signal<ShapeEditingSession | null>;
+    readonly shapeEditing: Signal<EditorShapeEditingState>;
+    readonly shapeEditingEntryRequest: Signal<ShapeEditingEntryRequest | null>;
+    readonly selectedShapeIds: Signal<ShapeId[]>;
+    readonly selectedShapeIdSet: Signal<Set<ShapeId>>;
+    readonly selectedShapes: Signal<ShapeRecord[]>;
+    readonly selectionCount: Signal<number>;
+    readonly selection: Signal<EditorSelectionState>;
+    readonly selectionMetadata: Signal<EditorSelectionMetadata>;
+    readonly selectionPageBounds: Signal<Box | null>;
+    readonly selectionFrameBounds: Signal<Box | null>;
+    readonly selectionAnchorPagePoint: Signal<Vec | null>;
+    readonly camera: Signal<Camera>;
+    readonly cameraZoom: Signal<number>;
+    readonly pageTransform: Signal<Mat>;
+    readonly viewportScreenSize: Signal<{
+        w: number;
+        h: number;
+    }>;
+    readonly viewportPageBounds: Signal<Box | null>;
+    readonly history: Signal<HistoryState>;
+}
+export interface EditorRenderViewportSignals {
+    readonly pageBounds: Signal<Box | null>;
+    readonly items: Signal<RenderItem[]>;
+    readonly shapeOrderById: Signal<Map<ShapeId, number>>;
+    readonly culledShapeIds: Signal<ShapeId[]>;
+    readonly culledShapeIdSet: Signal<Set<ShapeId>>;
+    readonly selectedShapeIdsOutsideCulled: Signal<ShapeId[]>;
+    readonly selectedShapeIdsOutsideCulledSet: Signal<Set<ShapeId>>;
+    readonly visibleShapeIds: Signal<ShapeId[]>;
+    readonly visibleShapeIdSet: Signal<Set<ShapeId>>;
+    readonly retainedShapeIds: Signal<ShapeId[]>;
+}
+export interface EditorRenderOverlaySignals {
+    readonly selectedShapeItems: Signal<SelectedShapeOverlayItem[]>;
+    readonly frameGeometry: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly companionFrameGeometries: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly path: Signal<string | null>;
+    readonly pageClipPath: Signal<string | null>;
+    readonly bindingSegments: Signal<SelectionBindingSegment[]>;
+    readonly frameStyle: Signal<SelectionOverlayFrameStyleState>;
+    readonly handleAnchors: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly handles: Signal<SelectionOverlayHandlesState | null>;
+}
+export interface EditorRenderInteractionSignals {
+    readonly brushBox: Signal<Box | null>;
+    readonly brushBoxActive: Signal<boolean>;
+    readonly bindingPreview: Signal<BindingPreviewState | null>;
+    readonly bindingPreviewActive: Signal<boolean>;
+    readonly terminalBindingGuides: Signal<TerminalBindingGuideState[]>;
+    readonly dropTargetShapeId: Signal<ShapeId | null>;
+    readonly hoveredShapeId: Signal<ShapeId | null>;
+    readonly selectionTranslationActive: Signal<boolean>;
+    readonly snapIndicators: Signal<SnapIndicatorState[]>;
+    readonly snapIndicatorsActive: Signal<boolean>;
+}
+export interface EditorRenderSignals {
+    readonly viewport: EditorRenderViewportSignals;
+    readonly overlay: EditorRenderOverlaySignals;
+    readonly interaction: EditorRenderInteractionSignals;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/state/editorStateUtils.d.ts

@@ -0,0 +1,9 @@
+import type { ShapeRecord } from "../../schema/records";
+import type { BindingPreviewState } from "../selection/selection";
+import type { RenderItem } from "../viewport/renderWindow";
+import type { EditorSelectionMetadata } from "./editorReadModels";
+export declare function areEditorSelectionMetadataEqual(left: EditorSelectionMetadata, right: EditorSelectionMetadata): boolean;
+export declare function areBindingPreviewStatesEqual(left: BindingPreviewState | null, right: BindingPreviewState | null): boolean;
+export declare function areRenderItemsEqual(left: readonly RenderItem[], right: readonly RenderItem[]): boolean;
+export declare function getCommonShapeType(shapes: readonly ShapeRecord[]): ShapeRecord["type"] | null;
+export declare function areShapePropsPatchesEqual(left: Readonly<Record<string, unknown>>, right: Readonly<Record<string, unknown>>): boolean;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/state/interactionTransientManager.d.ts

@@ -0,0 +1,35 @@
+import type { Signal } from "../../../signals/index";
+import { type TerminalBindingResolver, type TerminalBindingResolverInput, type ResolvedTerminalBinding } from "../../bindings/terminalBinding";
+import type { Box } from "../../geometry/box";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { BindingPreviewState, SnapIndicatorState, TerminalBindingGuideState } from "../selection/selection";
+export declare class InteractionTransientManager {
+    private readonly editor;
+    private readonly _brushBoxSignal;
+    readonly brushBoxSignal: Signal<Box | null>;
+    readonly brushBoxActiveSignal: Signal<boolean>;
+    private readonly _bindingPreviewSignal;
+    readonly bindingPreviewSignal: Signal<BindingPreviewState | null>;
+    readonly bindingPreviewActiveSignal: Signal<boolean>;
+    private readonly _terminalBindingGuidesSignal;
+    readonly terminalBindingGuidesSignal: Signal<TerminalBindingGuideState[]>;
+    private readonly _dropTargetShapeIdSignal;
+    readonly dropTargetShapeIdSignal: Signal<ShapeId | null>;
+    private readonly _hoveredShapeIdSignal;
+    readonly hoveredShapeIdSignal: Signal<ShapeId | null>;
+    private readonly _selectionTranslationActiveSignal;
+    readonly selectionTranslationActiveSignal: Signal<boolean>;
+    private terminalBindingResolver;
+    constructor(editor: Editor);
+    setBrushBox(brushBox: Box | null): void;
+    setBindingPreview(preview: BindingPreviewState | null): void;
+    setTerminalBindingGuides(guides: readonly TerminalBindingGuideState[] | null): void;
+    setDropTargetShapeId(shapeId: ShapeId | null): void;
+    setHoveredShapeId(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/plugin-arrow/_vendor/canvas-core/editor/viewport/camera.d.ts

@@ -0,0 +1,3 @@
+export declare const CAMERA_MIN_ZOOM = 0.1;
+export declare const CAMERA_MAX_ZOOM = 8;
+export declare function clampCameraZoom(zoom: number): number;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/viewport/cameraManager.d.ts

@@ -0,0 +1,56 @@
+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";
+export interface CameraAnimationScheduler {
+    requestFrame(callback: (timestamp: number) => void): unknown;
+    cancelFrame(handle: unknown): void;
+    prefersReducedMotion?(): boolean;
+}
+export interface CameraAnimationOptions {
+    durationMs: number;
+    pageId?: PageId;
+    source?: ChangeSource;
+}
+/**
+ * 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. Editor publishes the owned
+ * viewport signal through its grouped state facade.
+ */
+export declare class CameraManager {
+    private readonly editor;
+    private readonly animationScheduler?;
+    private readonly _viewportScreenSizeSignal;
+    readonly viewportScreenSizeSignal: Signal<{
+        w: number;
+        h: number;
+    }>;
+    private animationFrame;
+    private animationGeneration;
+    constructor(editor: Editor, animationScheduler?: CameraAnimationScheduler | undefined);
+    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;
+    animateCameraTo(target: Camera, options: CameraAnimationOptions): void;
+    cancelAnimation(): void;
+    dispose(): void;
+    private writeCamera;
+    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/plugin-arrow/_vendor/canvas-core/editor/viewport/cameraPanSession.d.ts

@@ -0,0 +1,9 @@
+import type { Vec } from "../../geometry/vec";
+import type { Camera } from "../../schema/records";
+import type { Editor } from "../editor";
+export interface CameraPanSession {
+    originScreenPoint: Vec;
+    originCamera: Camera;
+}
+export declare function createCameraPanSession(editor: Editor, originScreenPoint: Vec): CameraPanSession;
+export declare function updateCameraPanSession(editor: Editor, session: CameraPanSession, screenPoint: Vec): void;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/viewport/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/plugin-arrow/_vendor/canvas-core/editor/viewport/renderWindow.d.ts

@@ -0,0 +1,30 @@
+import { Box } from "../../geometry/box";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+export interface RenderItem {
+    id: ShapeId;
+    shape: ShapeRecord;
+    bounds: Box;
+    isSelected: boolean;
+}
+export declare const RENDER_CULLING_OVERSCAN_SCREEN = 160;
+export interface ShapeIndexRange {
+    start: number;
+    end: number;
+}
+export interface ShapeWindowSnapshot {
+    viewportReady: boolean;
+    ranges: ShapeIndexRange[];
+    shapeIds: ShapeId[];
+}
+export declare function doesBoxContainBox(outer: Box, inner: Box): boolean;
+export declare function getRetainedRenderWindowExtraShapeBudget(culledShapeCount: number): number;
+export declare function mergeShapeIndexRanges(ranges: ShapeIndexRange[], gapAllowance?: number): ShapeIndexRange[];
+export declare function doRangesContainRanges(outerRanges: ShapeIndexRange[], innerRanges: ShapeIndexRange[]): boolean;
+export declare function getShapeIndexRangeSpan(ranges: ShapeIndexRange[]): number;
+export declare function getExpandedRetainedShapeRanges(previousRanges: ShapeIndexRange[], nextRanges: ShapeIndexRange[], extraShapeBudget: number): ShapeIndexRange[] | null;
+export declare function getExpandedRetainedBaseShapeRanges(previousRanges: ShapeIndexRange[], nextRanges: ShapeIndexRange[]): ShapeIndexRange[] | null;
+export declare function getShapeIndexRangesForShapeIds(shapeIds: ShapeId[], pageIndexById: Map<ShapeId, number>, gapAllowance?: number): ShapeIndexRange[];
+export declare function getShapeWindowSnapshot(pageShapeIds: ShapeId[], ranges: ShapeIndexRange[], options?: {
+    viewportReady?: boolean;
+}): ShapeWindowSnapshot;
+export declare function collectRetainedShapeRanges(pageShapeIds: ShapeId[], culledShapeIds: ShapeId[], selectedIds: Set<ShapeId>, extraShapeBudget: number): ShapeIndexRange[];

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/viewport/renderWindowManager.d.ts

@@ -0,0 +1,33 @@
+import { type Signal } from "../../../signals/index";
+import type { Box } from "../../geometry/box";
+import type { PageId, ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+import { type RenderItem } from "./renderWindow";
+interface RenderWindowSignals {
+    currentPageId: Signal<PageId>;
+    currentPageShapeIds: Signal<ShapeId[]>;
+    selectedShapeIds: Signal<ShapeId[]>;
+    selectedShapeIdSet: Signal<Set<ShapeId>>;
+    viewportPageBounds: Signal<Box | null>;
+    renderViewportPageBounds: Signal<Box | null>;
+}
+/**
+ * Render culling and retained-window signals for the editor render host. The
+ * Editor exposes thin signal aliases that forward here.
+ */
+export declare class RenderWindowManager {
+    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[]>;
+    private readonly retainedBaseShapeWindowSnapshotSignal;
+    private readonly retainedShapeWindowSnapshotSignal;
+    constructor(editor: Editor, signals: RenderWindowSignals);
+    private getPageIndexById;
+}
+export {};