@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/canvas-core/tools/select/selectToolHelpers.d.ts

@@ -0,0 +1,161 @@
+import { Box } from "../../geometry/box";
+import { Vec } from "../../geometry/vec";
+import type { ShapeUpdate } from "../../editor/commands";
+import type { Editor } from "../../editor/editor";
+import type { PointerEditorEvent, TickEditorEvent } from "../../editor/events";
+import type { SelectionResizeHandleId, SelectionResizePointShapeSnapshot, SelectionResizeShapeSnapshot, SelectionRotationTransform, SelectionRotatePointShapeSnapshot, SelectionRotateShapeSnapshot } from "../../editor/selection";
+import type { HandleSnapSnapshot, ResizeSnapSnapshot, TranslateSnapSnapshot } from "../../editor/managers/snapTypes";
+import type { SelectionHandleInteractionSession } from "../../editor/selectionHandleInteractions";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+export declare const DRAG_START_DISTANCE = 3;
+export declare const DRAG_START_DISTANCE_SQUARED: number;
+export declare const ROTATION_SNAP_STEP: number;
+export declare const ROTATION_SOFT_SNAP_STEP: number;
+export declare const ROTATION_SOFT_SNAP_THRESHOLD: number;
+export declare const ROTATION_SOFT_SNAP_MAX_SCREEN_VELOCITY = 0.5;
+export declare const GROUP_CHILD_QUICK_SELECT_DURATION_MS = 250;
+export declare const TRANSLATE_SNAP_DISTANCE_SCREEN = 8;
+export declare const TRANSLATE_SNAP_MAX_SCREEN_VELOCITY = 0.5;
+export declare const RESIZE_SNAP_DISTANCE_SCREEN = 8;
+export declare const HANDLE_SNAP_DISTANCE_SCREEN = 8;
+export declare const TRANSLATE_HISTORY_MARK = "select.translate";
+export declare const RESIZE_HISTORY_MARK = "select.resize";
+export declare const ROTATE_HISTORY_MARK = "select.rotate";
+export type TranslateAxis = "x" | "y";
+export interface PointingCanvasInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+}
+export interface PointingShapeInfo {
+    shapeId: ShapeId;
+    translateTargetId: ShapeId;
+    originPagePoint: Vec;
+    originTimestamp: number;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+    wasSelected: boolean;
+    fromSelectionBounds: boolean;
+    quickClickSelectionTargetId: ShapeId | null;
+}
+export interface TranslatingShapeSnapshot {
+    id: ShapeId;
+    x: number;
+    y: number;
+}
+export interface TranslatingInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    selectedShapeIds: ShapeId[];
+    startBounds: Box | null;
+    snapSnapshot: TranslateSnapSnapshot;
+    snapRotation: number;
+    selectedShapes: TranslatingShapeSnapshot[];
+    updates: ShapeUpdate[];
+    lockedAxis: TranslateAxis | null;
+    lastDeltaX: number;
+    lastDeltaY: number;
+}
+export interface BrushInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+}
+export interface PointingResizeHandleInfo {
+    handleId: SelectionResizeHandleId;
+    originPagePoint: Vec;
+    cursorHandleOffset: Vec;
+    previousSelection: ShapeId[];
+}
+export interface ResizingInfo extends PointingResizeHandleInfo {
+    startBounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+    aspectRatio: number;
+    snapSnapshot: ResizeSnapSnapshot;
+    shapes: SelectionResizeShapeSnapshot[];
+    pointShapes: SelectionResizePointShapeSnapshot[];
+    updates: ShapeUpdate[];
+    aspectRatioLockOverride: boolean | null;
+    lastPagePointX: number;
+    lastPagePointY: number;
+    lastShiftKey: boolean;
+    lastAltKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface PointingRotateHandleInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+}
+export interface RotatingInfo extends PointingRotateHandleInfo {
+    center: Vec;
+    startAngle: number;
+    initialSelectionRotation: number;
+    shapes: SelectionRotateShapeSnapshot[];
+    pointShapes: SelectionRotatePointShapeSnapshot[];
+    updates: ShapeUpdate[];
+    lastPointerX: number;
+    lastPointerY: number;
+    lastShiftKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface PointingSelectionHandleInteractionInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    session: SelectionHandleInteractionSession;
+    snapSnapshot: HandleSnapSnapshot | null;
+}
+export interface DraggingSelectionHandleInteractionInfo extends PointingSelectionHandleInteractionInfo {
+    lastPagePointX: number;
+    lastPagePointY: number;
+    lastAccelKey: boolean;
+}
+export interface SelectionDragInput {
+    pagePoint: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    accelKey: boolean;
+    ctrlKey: boolean;
+}
+export type EdgeScrollTickMode = "always_apply" | "apply_after_scroll_or_without_screen_point" | "apply_after_scroll";
+export declare function getSelectionDragInputFromCurrentInputs(editor: Editor): SelectionDragInput | null;
+export declare function getSelectionDragInputForTick(editor: Editor, event: TickEditorEvent, mode: EdgeScrollTickMode): SelectionDragInput | null;
+export declare function applySelectionDragFromCurrentInputs(editor: Editor, apply: (input: SelectionDragInput) => void): void;
+export declare function createBrushBounds(origin: Vec, current: Vec): Box;
+export declare function hasExceededDragThreshold(origin: Vec, point: Vec): boolean;
+export declare function arePagePointsApproximatelyEqual(left: Vec, right: Vec): boolean;
+export declare function toggleIds(base: ShapeId[], toggled: ShapeId[]): ShapeId[];
+export declare function getOutermostSelectableShapeIds(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getSelectableShapeIdForHit(editor: Editor, shapeId: ShapeId, selectedShapeIds: readonly ShapeId[]): ShapeId;
+export declare function getSelectedTransformAncestorIdForHit(editor: Editor, shapeId: ShapeId, selectedShapeIds: readonly ShapeId[]): ShapeId | null;
+export interface TransformDescendantAncestorPathEntry {
+    ancestorId: ShapeId;
+    childId: ShapeId;
+}
+export declare function getNearestTransformDescendantAncestorId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTransformDescendantAncestorPath(editor: Editor, shapeId: ShapeId): TransformDescendantAncestorPathEntry[];
+export declare function isAdditiveSelectionActive({ shiftKey, accelKey, }: {
+    shiftKey: boolean;
+    accelKey: boolean;
+}): boolean;
+export declare function isBrushWrappingSelection({ ctrlKey }: {
+    ctrlKey: boolean;
+}): boolean;
+export declare function isQuickClick(info: PointingShapeInfo, event: PointerEditorEvent): boolean;
+export declare function normalizeAngle(angle: number): number;
+export declare function snapAngle(angle: number, step: number): number;
+export declare function getBoxCorners(bounds: Box): Vec[];
+export declare function getShapeSelectionResizePageOutlineVertices(editor: Editor, shape: ShapeRecord): Vec[];
+export declare function getResizedShapeUpdate(editor: Editor, shape: SelectionResizeShapeSnapshot, startBounds: Box, nextBounds: Box, scaleX: number, scaleY: number, handleId: SelectionResizeHandleId, isResizingFromCenter: boolean, rotationCenter: Vec, selectionRotation: number, update: ShapeUpdate): void;
+export declare function getSelectionTransform(rotationCenter: Vec, selectionRotation: number): SelectionRotationTransform;
+export declare function getResizedPagePointsUpdate(editor: Editor, shape: SelectionResizePointShapeSnapshot, startBounds: Box, nextBounds: Box, scaleX: number, scaleY: number, handleId: SelectionResizeHandleId, isResizingFromCenter: boolean, rotationCenter: Vec, selectionRotation: number, update: ShapeUpdate): void;
+export declare function getSelectionResizeAspectRatioLockOverride(editor: Editor, shapes: readonly ShapeRecord[], handleId: SelectionResizeHandleId): boolean | null;
+export declare function getRotatedShapeUpdate(shape: SelectionRotateShapeSnapshot, center: Vec, delta: number, update: ShapeUpdate): void;
+export declare function getRotatedPagePointsUpdate(editor: Editor, shape: SelectionRotatePointShapeSnapshot, center: Vec, delta: number, update: ShapeUpdate): void;
+export declare function createTranslatingUpdates(shapes: TranslatingShapeSnapshot[]): ShapeUpdate[];
+export declare function getTranslateShapeSnapshots(editor: Editor, selectedShapeIds: ShapeId[]): TranslatingShapeSnapshot[];
+export declare function isShapeWrappedByBrush(editor: Editor, brushBounds: Box, shapeId: ShapeId): boolean;
+export declare function shouldSelectShapeWithBrush(editor: Editor, brushBounds: Box, shapeId: ShapeId, isWrapping: boolean): boolean;
+export declare function isBrushSelectableShapeId(editor: Editor, shapeId: ShapeId): boolean;
+export declare function createResizingUpdates(shapes: SelectionResizeShapeSnapshot[], pointShapes: SelectionResizePointShapeSnapshot[]): ShapeUpdate[];
+export declare function createRotatingUpdates(shapes: SelectionRotateShapeSnapshot[], pointShapes: SelectionRotatePointShapeSnapshot[]): ShapeUpdate[];

package/_vendor/canvas-core/tools/select/states/brushingState.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events";
+import { type BrushInfo } from "../selectToolHelpers";
+import { InfoStateNode } from "./selectStateNode";
+export declare class BrushingState extends InfoStateNode<BrushInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onInfoEnter(): void;
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected onTick(event: TickEditorEvent): void;
+    protected onKeyDown(): void;
+    protected onKeyUp(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    private updateBrush;
+    private updateBrushFromInputs;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-core/tools/select/states/draggingSelectionHandleInteractionState.d.ts

@@ -0,0 +1,15 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { type DraggingSelectionHandleInteractionInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class DraggingSelectionHandleInteractionState extends DraggingStateNode<DraggingSelectionHandleInteractionInfo> {
+    protected readonly tickMode: "apply_after_scroll";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(info: DraggingSelectionHandleInteractionInfo): string;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, accelKey }: DragApplyInput): void;
+    private complete;
+}

package/_vendor/canvas-core/tools/select/states/idleState.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+export declare class IdleState extends StateNode {
+    constructor(editor: Editor, parent: StateNode);
+    protected onEnter(): void;
+    protected onPointerDown(event: PointerEditorEvent): void;
+}

package/_vendor/canvas-core/tools/select/states/index.d.ts

@@ -0,0 +1,11 @@
+export { BrushingState } from "./brushingState";
+export { DraggingSelectionHandleInteractionState } from "./draggingSelectionHandleInteractionState";
+export { IdleState } from "./idleState";
+export { PointingCanvasState } from "./pointingCanvasState";
+export { PointingResizeHandleState } from "./pointingResizeHandleState";
+export { PointingRotateHandleState } from "./pointingRotateHandleState";
+export { PointingSelectionHandleInteractionState } from "./pointingSelectionHandleInteractionState";
+export { PointingShapeState } from "./pointingShapeState";
+export { ResizingState } from "./resizingState";
+export { RotatingState } from "./rotatingState";
+export { TranslatingState } from "./translatingState";

package/_vendor/canvas-core/tools/select/states/pointingCanvasState.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { type PointingCanvasInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingCanvasState extends PointingStateNode<PointingCanvasInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(event: PointerEditorEvent): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/pointingResizeHandleState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import { type PointingResizeHandleInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingResizeHandleState extends PointingStateNode<PointingResizeHandleInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/pointingRotateHandleState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import { type PointingRotateHandleInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingRotateHandleState extends PointingStateNode<PointingRotateHandleInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/pointingSelectionHandleInteractionState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import { type PointingSelectionHandleInteractionInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingSelectionHandleInteractionState extends PointingStateNode<PointingSelectionHandleInteractionInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/pointingShapeState.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { type PointingShapeInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingShapeState extends PointingStateNode<PointingShapeInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onInfoEnter(): void;
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/resizingState.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import { type ResizingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class ResizingState extends DraggingStateNode<ResizingInfo> {
+    protected readonly tickMode: "apply_after_scroll_or_without_screen_point";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(): string;
+    protected onDragStart(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, shiftKey, altKey, accelKey, }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-core/tools/select/states/rotatingState.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../../editor/stateNode";
+import { type RotatingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class RotatingState extends DraggingStateNode<RotatingInfo> {
+    protected readonly tickMode: "apply_after_scroll";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(): string;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+    protected apply({ pagePoint, shiftKey, accelKey }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-core/tools/select/states/selectStateNode.d.ts

@@ -0,0 +1,60 @@
+import type { Vec } from "../../../geometry/vec";
+import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events";
+import { type EdgeScrollTickMode } from "../selectToolHelpers";
+/**
+ * Base for every select-tool state that carries a transient `info` payload.
+ * Centralises the identical `info` lifecycle (assign on enter, clear on exit)
+ * so concrete states only express their behaviour. Cleanup that must run while
+ * `info` is still readable belongs in {@link onInfoExit}.
+ */
+export declare abstract class InfoStateNode<T> extends StateNode {
+    protected info: T | null;
+    protected onEnter(info?: unknown): void;
+    protected onExit(): void;
+    /** Runs after `info` is assigned. */
+    protected onInfoEnter(): void;
+    /** Runs before `info` is cleared. */
+    protected onInfoExit(): void;
+}
+/**
+ * Base for the "pointing_*" states. They all wait for the pointer to exceed the
+ * drag threshold before committing to a gesture; subclasses only implement what
+ * happens once that threshold is crossed.
+ */
+export declare abstract class PointingStateNode<T extends {
+    originPagePoint: Vec;
+}> extends InfoStateNode<T> {
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected abstract onDragThresholdExceeded(event: PointerEditorEvent): void;
+}
+/** Pointer/keyboard fields shared by pointer events and synthesized drag inputs. */
+export interface DragApplyInput {
+    pagePoint: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    accelKey: boolean;
+}
+/**
+ * Base for the active drag states (translate / resize / rotate / handle
+ * interaction). Centralises the identical event wiring: mark history on enter,
+ * apply on pointer-move, apply edge-scroll-aware input on tick, and re-apply the
+ * current input on key changes. Subclasses implement {@link apply} plus their own
+ * completion/cancellation and any extra cleanup.
+ */
+export declare abstract class DraggingStateNode<T> extends InfoStateNode<T> {
+    /** Edge-scroll behaviour for this gesture's tick handling. */
+    protected abstract readonly tickMode: EdgeScrollTickMode;
+    /** History mark to open on enter (constant or derived from `info`). */
+    protected abstract getHistoryMark(info: T): string;
+    /** Apply one drag sample. Implementations must guard on `this.info`. */
+    protected abstract apply(input: DragApplyInput): void;
+    protected onInfoEnter(): void;
+    /** Extra setup after the history mark is opened (e.g. clearing indicators). */
+    protected onDragStart(): void;
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected onTick(event: TickEditorEvent): void;
+    protected onKeyDown(): void;
+    protected onKeyUp(): void;
+    protected applyFromInputs(): void;
+}

package/_vendor/canvas-core/tools/select/states/translatingState.d.ts

@@ -0,0 +1,17 @@
+import type { Editor } from "../../../editor/editor";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { StateNode } from "../../../editor/stateNode";
+import { type TranslatingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class TranslatingState extends DraggingStateNode<TranslatingInfo> {
+    protected readonly tickMode: "always_apply";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(): string;
+    protected onDragStart(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, shiftKey, accelKey }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-react/components/CanvasView.d.ts

@@ -0,0 +1,14 @@
+import { type ActiveContextMenu } from "../../canvas-core/index";
+import type { CanvasPluginComponent, CanvasPluginProvider } from "../host/canvasPlugin";
+import { type CanvasRendererRegistry } from "../host/rendererRegistry";
+import { type CanvasOverlayRegistry } from "../host/overlayRegistry";
+import { type CanvasDomEventGuardRegistry } from "../host/domEventGuards";
+export declare function Canvas({ canvasComponents, canvasProviders, domEventGuardRegistry, onContextMenuRequest, overlayRegistry, rendererRegistry, showGrid, }?: {
+    canvasComponents?: readonly CanvasPluginComponent[];
+    canvasProviders?: readonly CanvasPluginProvider[];
+    domEventGuardRegistry?: CanvasDomEventGuardRegistry;
+    onContextMenuRequest?: (activeContextMenu: ActiveContextMenu) => void;
+    overlayRegistry?: CanvasOverlayRegistry;
+    rendererRegistry?: CanvasRendererRegistry;
+    showGrid?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/OverlayLayer.d.ts

@@ -0,0 +1 @@
+export declare function OverlayLayer(): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/PageSpace.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from "react";
+export declare function PageSpace({ children, className, dataUi, }: {
+    children: ReactNode;
+    className?: string;
+    dataUi: string;
+}): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/ShapeLayer.d.ts

@@ -0,0 +1,4 @@
+import { type ShapeId } from "../../canvas-core/index";
+export declare function ShapeLayer({ hoveredShapeId, }: {
+    hoveredShapeId?: ShapeId | null;
+}): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/index.d.ts

@@ -0,0 +1,2 @@
+export { Canvas } from "./CanvasView";
+export { PageSpace } from "./PageSpace";

package/_vendor/canvas-react/components/overlays/BindingGuide.d.ts

@@ -0,0 +1,24 @@
+export interface PagePointLike {
+    x: number;
+    y: number;
+}
+export type DashedGuideSegmentKind = "binding-preview" | "selection-binding";
+export declare function DashedGuideSegment({ start, end, startInset, endInset, strokeWidth, dashSize, gapSize, kind, terminal, }: {
+    start: PagePointLike;
+    end: PagePointLike;
+    startInset: number;
+    endInset: number;
+    strokeWidth: number;
+    dashSize: number;
+    gapSize: number;
+    kind: DashedGuideSegmentKind;
+    terminal: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function DashedGuidePath({ path, strokeWidth, dashSize, gapSize, kind, terminal, }: {
+    path: string;
+    strokeWidth: number;
+    dashSize: number;
+    gapSize: number;
+    kind: DashedGuideSegmentKind;
+    terminal: string;
+}): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/overlays/BindingPreviewOverlay.d.ts

@@ -0,0 +1 @@
+export declare const BindingPreviewOverlay: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/BrushBoxOverlay.d.ts

@@ -0,0 +1 @@
+export declare const BrushBoxOverlay: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/OverlaySvgRoot.d.ts

@@ -0,0 +1 @@
+export declare const OverlaySvgRoot: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/SelectionFrameOverlay.d.ts

@@ -0,0 +1 @@
+export declare const SelectionFrameOverlay: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/SelectionHandlesOverlay.d.ts

@@ -0,0 +1 @@
+export declare const SelectionHandlesOverlay: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/SelectionOverlaySvg.d.ts

@@ -0,0 +1 @@
+export declare const SelectionOverlaySvg: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/SelectionPathOverlay.d.ts

@@ -0,0 +1 @@
+export declare const SelectionPathOverlay: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/overlays/ShapeOutlineOverlay.d.ts

@@ -0,0 +1,8 @@
+import { type Editor, type ShapeRecord } from "../../../canvas-core/index";
+export declare function ShapeOutlineOverlay({ editor, shape, stroke, fill, strokeWidth, }: {
+    editor: Editor;
+    shape: ShapeRecord;
+    stroke: string;
+    fill: string;
+    strokeWidth: number;
+}): import("react/jsx-runtime").JSX.Element | null;

package/_vendor/canvas-react/components/overlays/SnapIndicatorsOverlay.d.ts

@@ -0,0 +1 @@
+export declare const SnapIndicatorsOverlay: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/useCanvasDomEvents.d.ts

@@ -0,0 +1,21 @@
+import { type MouseEvent as ReactMouseEvent, type PointerEvent as ReactPointerEvent, type RefObject } from "react";
+import { type ActiveContextMenu, type Editor, type ShapeEditingSession, type ShapeId } from "../../canvas-core/index";
+import type { CanvasDomEventGuardRegistry } from "../host/domEventGuards";
+export interface CanvasDomEventHandlers {
+    onPointerDown: (event: ReactPointerEvent<HTMLDivElement>) => void;
+    onContextMenu: (event: ReactMouseEvent<HTMLDivElement>) => void;
+}
+export interface CanvasDomEventState {
+    containerRef: RefObject<HTMLDivElement | null>;
+    handlers: CanvasDomEventHandlers;
+    hoveredShapeId: ShapeId | null;
+    isPointerActive: boolean;
+    surfaceCursor: string | undefined;
+}
+export declare function useCanvasDomEvents({ activeDomEventGuards, activeToolId, editor, onContextMenuRequest, shapeEditingSession, }: {
+    activeDomEventGuards: CanvasDomEventGuardRegistry;
+    activeToolId: string;
+    editor: Editor;
+    onContextMenuRequest?: (activeContextMenu: ActiveContextMenu) => void;
+    shapeEditingSession: ShapeEditingSession | null;
+}): CanvasDomEventState;

package/_vendor/canvas-react/dom.d.ts

@@ -0,0 +1,10 @@
+import { Vec, type Editor } from "../canvas-core/index";
+export declare const CANVAS_SURFACE_DATA_UI = "canvas-surface";
+export declare const CANVAS_SURFACE_SELECTOR = "[data-ui=\"canvas-surface\"]";
+export declare function getEditableEventTarget(target: EventTarget | null): HTMLElement | null;
+export declare function isEditableEventTarget(target: EventTarget | null): boolean;
+export declare function getCanvasSurfaceElement(root?: ParentNode): HTMLElement | null;
+export declare function getCanvasSurfaceElementForNode(node: Node | null | undefined): HTMLElement | null;
+export declare function forwardWheelEventToCanvasSurface(event: WheelEvent, source: Node): boolean;
+export declare function getCanvasSurfaceScreenPoint(point: Pick<MouseEvent, "clientX" | "clientY">, surface?: HTMLElement | null): Vec;
+export declare function getCanvasSurfacePagePoint(editor: Editor, point: Pick<MouseEvent, "clientX" | "clientY">, surface?: HTMLElement | null): Vec;

package/_vendor/canvas-react/hooks/useEditor.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "../../canvas-core/index";
+export declare const EditorContext: import("react").Context<Editor | null>;
+export declare function useEditor(): Editor;

package/_vendor/canvas-react/hooks/useValue.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyValue } from "../../canvas-core/index";
+export declare function useValue<T>(signal: ReadonlyValue<T>): T;

package/_vendor/canvas-react/host/canvasOverlayRegistryContext.d.ts

@@ -0,0 +1,3 @@
+import { type CanvasOverlayRegistry } from "./overlayRegistry";
+export declare const CanvasOverlayRegistryContext: import("react").Context<CanvasOverlayRegistry>;
+export declare function useCanvasOverlayRegistry(): CanvasOverlayRegistry;

package/_vendor/canvas-react/host/canvasPlugin.d.ts

@@ -0,0 +1,73 @@
+import type { ComponentType, ReactNode } from "react";
+import type { Editor, SelectionCustomHandle, ShapeColor, ShapeEditingSession, ShapeRecordBase } from "../../canvas-core/index";
+export interface ShapeRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    isSelected: boolean;
+    isHovered: boolean;
+    shapeEditingSession: ShapeEditingSession | null;
+}
+export declare const SHAPE_HOVER_STROKE = "var(--land-selection, #2563eb)";
+export declare function getShapeStrokeForHover(stroke: ShapeColor, isHovered: boolean): string;
+export interface RegisteredShapeRenderer<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    component: ComponentType<ShapeRendererProps<S>>;
+}
+export type AnyRegisteredShapeRenderer = RegisteredShapeRenderer<any>;
+export interface SelectionCustomHandleRendererProps<H extends SelectionCustomHandle = SelectionCustomHandle> {
+    handle: H;
+    strokeWidth: number;
+}
+export interface RegisteredSelectionCustomHandleRenderer<H extends SelectionCustomHandle = SelectionCustomHandle> {
+    type: H["type"];
+    component: ComponentType<SelectionCustomHandleRendererProps<H>>;
+}
+export type AnyRegisteredSelectionCustomHandleRenderer = RegisteredSelectionCustomHandleRenderer<any>;
+export type CanvasOverlayLayer = "below-host" | "above-host";
+export interface CanvasOverlayContribution {
+    id: string;
+    component: ComponentType;
+    layer?: CanvasOverlayLayer;
+    order?: number;
+}
+export interface CanvasPluginComponent {
+    id: string;
+    component: ComponentType;
+}
+export interface CanvasPluginProvider {
+    id: string;
+    component: ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export type CanvasDomEventGuardName = "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel" | "wheel" | "key_down" | "key_up";
+export type CanvasDomEventGuardDecision = "continue" | "handled";
+export interface CanvasDomEventGuardInput {
+    name: CanvasDomEventGuardName;
+    event: Event;
+    editor: Editor;
+    container: HTMLElement;
+}
+export interface CanvasDomEventGuardCursorInput {
+    element: Element | null;
+    editor: Editor;
+    container: HTMLElement;
+    clientPoint: {
+        x: number;
+        y: number;
+    } | null;
+}
+export interface CanvasDomEventGuard {
+    id: string;
+    handle(input: CanvasDomEventGuardInput): CanvasDomEventGuardDecision;
+    getCursor?(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export interface LandCanvasPlugin {
+    id: string;
+    shapeRenderers?: readonly AnyRegisteredShapeRenderer[];
+    canvasOverlays?: readonly CanvasOverlayContribution[];
+    selectionCustomHandleRenderers?: readonly AnyRegisteredSelectionCustomHandleRenderer[];
+    domEventGuards?: readonly CanvasDomEventGuard[];
+    canvasProviders?: readonly CanvasPluginProvider[];
+    canvasComponents?: readonly CanvasPluginComponent[];
+}

package/_vendor/canvas-react/host/canvasRendererRegistryContext.d.ts

@@ -0,0 +1,3 @@
+import { type CanvasRendererRegistry } from "./rendererRegistry";
+export declare const CanvasRendererRegistryContext: import("react").Context<CanvasRendererRegistry>;
+export declare function useCanvasRendererRegistry(): CanvasRendererRegistry;

package/_vendor/canvas-react/host/contextMenuRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { ContextMenuContext, ContextMenuContribution, ContextMenuContributionTarget, ContextMenuSection, LandEditorPlugin } from "../../canvas-core/index";
+export declare class CanvasContextMenuRegistry {
+    private readonly contributions;
+    private readonly duplicateContributionIds;
+    registerContribution(contribution: ContextMenuContribution, options?: {
+        replace?: boolean;
+    }): void;
+    registerEditorPlugins(plugins: readonly LandEditorPlugin[]): void;
+    getDuplicateContributionIds(): string[];
+    getSections(target: ContextMenuContributionTarget, context: ContextMenuContext): ContextMenuSection[];
+}
+export declare function createCanvasContextMenuRegistry(plugins?: readonly LandEditorPlugin[]): CanvasContextMenuRegistry;