@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,60 @@
+import type { Vec } from "../../../geometry/vec";
+import { StateNode } from "../../stateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events/events";
+import type { EditorOperation } from "../../../editor/history/operationManager";
+/**
+ * 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: open an operation on
+ * enter, apply the latest input once per animation 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> {
+    protected operation: EditorOperation | null;
+    /** Stable operation kind for this gesture. */
+    protected abstract getOperationKind(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 operation is opened (e.g. clearing indicators). */
+    protected onDragStart(): void;
+    protected onTick(event: TickEditorEvent): void;
+    protected onKeyDown(): void;
+    protected onKeyUp(): void;
+    protected applyFromInputs(): void;
+    protected commitOperation(): void;
+    protected cancelOperation(): void;
+}

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

@@ -0,0 +1,16 @@
+import type { Editor } from "../../../editor/editor";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../stateNode";
+import { type TranslatingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class TranslatingState extends DraggingStateNode<TranslatingInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected getOperationKind(): 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/plugin-flow/_vendor/canvas-core/tools/stateNode.d.ts

@@ -0,0 +1,30 @@
+import type { Editor } from "../editor/editor";
+import type { CancelEditorEvent, EditorEventContext, EditorEventRoutingEffect, KeyboardEditorEvent, PointerEditorEvent, TickEditorEvent, WheelEditorEvent } from "../editor/events/events";
+export type StateNodeEvent = PointerEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;
+export declare abstract class StateNode {
+    readonly editor: Editor;
+    readonly id: string;
+    readonly parent?: StateNode | undefined;
+    protected readonly children: Map<string, StateNode>;
+    protected currentChild: StateNode | null;
+    protected initial: string | null;
+    constructor(editor: Editor, id: string, parent?: StateNode | undefined);
+    protected addChild(child: StateNode): void;
+    enter(info?: unknown): void;
+    exit(info?: unknown): void;
+    transition(id: string, info?: unknown): void;
+    isInInitialState(): boolean;
+    dispatch(event: StateNodeEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onEnter(_info?: unknown): void;
+    protected onExit(_info?: unknown): void;
+    protected onPointerDown(_event: PointerEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onPointerMove(_event: PointerEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onPointerUp(_event: PointerEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onCancel(_event: CancelEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onKeyDown(_event: KeyboardEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onKeyUp(_event: KeyboardEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onWheel(_event: WheelEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onTick(_event: TickEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    private handlePointerEvent;
+    private handleKeyboardEvent;
+}

package/_vendor/plugin-flow/_vendor/canvas-core/tools/toolManager.d.ts

@@ -0,0 +1,24 @@
+import type { Atom } from "../../signals/index";
+import type { ChangeSource } from "../../store/index";
+import type { Editor } from "../editor/editor";
+import type { CancelEditorEvent, EditorEventContext, EditorEventRoutingEffect } from "../editor/events/events";
+import type { StateNode, StateNodeEvent } from "./stateNode";
+type ToolFactory = (editor: Editor) => StateNode;
+export declare class ToolManager {
+    private readonly editor;
+    readonly activeToolId: Atom<string>;
+    readonly isToolLocked: Atom<boolean>;
+    private readonly registry;
+    private activeTool;
+    constructor(editor: Editor);
+    register(id: string, factory: ToolFactory): void;
+    hasTool(id: string): boolean;
+    select(id: string, source?: ChangeSource): void;
+    setLocked(locked: boolean, source?: ChangeSource): void;
+    toggleLocked(source?: ChangeSource): void;
+    syncActiveTool(id: string, reason?: CancelEditorEvent["reason"]): void;
+    dispatch(event: StateNodeEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+    syncLockedState(locked: boolean): void;
+    isInInitialState(): boolean;
+}
+export {};

package/_vendor/plugin-flow/_vendor/canvas-core/utils/equality.d.ts

@@ -0,0 +1,9 @@
+import type { Box } from "../geometry/box";
+import type { Vec } from "../geometry/vec";
+export declare function areArraysEqual<T>(left: readonly T[], right: readonly T[], isEqual?: (left: T, right: T) => boolean): boolean;
+export declare function areSetsEqual<T>(left: ReadonlySet<T>, right: ReadonlySet<T>): boolean;
+export declare function areVecsEqual(left: Vec | null | undefined, right: Vec | null | undefined): boolean;
+export declare function areVecArraysEqual(left: readonly Vec[], right: readonly Vec[]): boolean;
+export declare function areVecPolygonArraysEqual(left: readonly (readonly Vec[])[], right: readonly (readonly Vec[])[]): boolean;
+export declare function areBoxesEqual(left: Box | null | undefined, right: Box | null | undefined): boolean;
+export declare function areSerializableValuesEqual(left: unknown, right: unknown): boolean;

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/contributions.d.ts

@@ -0,0 +1,92 @@
+import type { Editor, ShapeId, ShapeRecord, Vec } from "../canvas-core/index";
+import type { CanvasContextMenuRequest } from "../canvas-react/index";
+export type CanvasImportSource = "clipboard" | "drop" | "file-picker";
+export interface CanvasImportRequest {
+    readonly source: CanvasImportSource;
+    readonly files: readonly File[];
+    readonly text?: string;
+    readonly html?: string;
+    readonly urls?: readonly string[];
+    readonly pagePoint?: Vec;
+}
+export interface CanvasImportPreview {
+    readonly source: "drop";
+    readonly dataTypes: readonly string[];
+    readonly fileTypes: readonly string[];
+}
+export type CanvasImportResult = "handled" | "ignored";
+export interface CanvasImportContribution {
+    readonly id: string;
+    readonly order?: number;
+    acceptsPreview?(preview: CanvasImportPreview): boolean;
+    accepts(request: CanvasImportRequest): boolean;
+    import(request: CanvasImportRequest): CanvasImportResult | Promise<CanvasImportResult>;
+}
+export interface CanvasExportFormat {
+    readonly format: string;
+    readonly label: string;
+    readonly mimeType: string;
+    readonly fileExtension: string;
+}
+export interface CanvasExportProviderInput {
+    readonly editor: Editor;
+    readonly shapeIds: readonly ShapeId[];
+    readonly options?: unknown;
+}
+export interface CanvasExportPayload {
+    readonly data: Blob | string | Uint8Array | null;
+    readonly result?: unknown;
+    readonly status?: unknown;
+}
+export interface CanvasExportArtifact extends CanvasExportFormat, CanvasExportPayload {
+}
+export interface CanvasExportFormatProvider extends CanvasExportFormat {
+    readonly kind: "provider";
+    readonly id: string;
+    export(input: CanvasExportProviderInput, context: {
+        readonly signal: AbortSignal;
+        inlineSvg(input: CanvasSvgInlineInput): Promise<string>;
+    }): CanvasExportPayload | Promise<CanvasExportPayload>;
+}
+export interface SvgResourceInliner {
+    readonly kind: "svg-inliner";
+    readonly id: string;
+    prepare?(input: {
+        readonly editor: Editor;
+        readonly requestedShapeIds: readonly ShapeId[];
+        readonly signal: AbortSignal;
+    }): void | Promise<void>;
+    inline(input: {
+        readonly editor: Editor;
+        readonly exportedShapes: readonly ShapeRecord[];
+        readonly exportedShapeIds: readonly ShapeId[];
+        readonly svg: string;
+        readonly signal: AbortSignal;
+    }): string | Promise<string>;
+}
+export type CanvasExportContribution = CanvasExportFormatProvider | SvgResourceInliner;
+export interface CanvasSvgInlineInput {
+    readonly editor: Editor;
+    readonly exportedShapes: readonly ShapeRecord[];
+    readonly exportedShapeIds: readonly ShapeId[];
+    readonly requestedShapeIds: readonly ShapeId[];
+    readonly svg: string;
+}
+export interface CanvasAssetResolverContribution {
+    readonly id: string;
+    resolve(assetId: string): string | null;
+    preload?(input: {
+        readonly editor: Editor;
+        readonly signal: AbortSignal;
+    }): void | Promise<void>;
+    cleanupAfterRestore?(input: {
+        readonly editor: Editor;
+        readonly signal: AbortSignal;
+    }): void | Promise<void>;
+}
+export interface CanvasStartupResult {
+    readonly documentSource: "restored" | "initial" | "empty";
+    readonly sessionRestored: boolean;
+    readonly warnings: readonly unknown[];
+}
+export type ActiveCanvasContextMenu = CanvasContextMenuRequest;

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./contributions";
+export * from "./operations";
+export * from "./persistence";
+export * from "./plugin";
+export * from "./shape";
+export * from "./tokens";

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/operations.d.ts

@@ -0,0 +1,131 @@
+import type { AssetId, Camera, ShapeId } from "../canvas-core/index";
+import type { CanvasExportArtifact, CanvasExportFormat } from "./contributions";
+export type CanvasProductExportTarget = {
+    readonly scope: "page" | "selection";
+    readonly shapeIds?: never;
+} | {
+    readonly scope?: never;
+    readonly shapeIds: readonly ShapeId[];
+};
+export type CanvasProductExportInput = CanvasProductExportTarget & {
+    readonly options?: unknown;
+};
+export type CanvasProductExportStatus = {
+    readonly state: "idle";
+} | {
+    readonly state: "exporting";
+    readonly format: string;
+};
+export interface CanvasProductExportController {
+    getFormats(): readonly CanvasExportFormat[];
+    getStatus(): CanvasProductExportStatus;
+    export(format: string, input: CanvasProductExportInput): Promise<CanvasExportArtifact>;
+}
+export interface CanvasProductShapeData {
+    readonly id: ShapeId;
+    readonly type: string;
+    readonly parentId: string;
+    readonly pageId: string | null;
+    readonly index: string;
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly opacity: number;
+    readonly isHidden: boolean;
+    readonly isLocked: boolean;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductAssetData {
+    readonly id: AssetId;
+    readonly type: string;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductDocumentRef {
+    readonly id: string;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductPageRef {
+    readonly id: string;
+    readonly name: string;
+    readonly index: string;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductSessionPageState {
+    readonly pageId: string;
+    readonly selectedShapeIds: readonly ShapeId[];
+    readonly camera: Readonly<Camera>;
+}
+export interface CanvasProductSessionSnapshot<TToolId extends string = string> {
+    readonly currentPageId: string;
+    readonly activeToolId: TToolId;
+    readonly isToolLocked: boolean;
+    readonly meta: Readonly<Record<string, unknown>>;
+    readonly pages: readonly CanvasProductSessionPageState[];
+}
+export interface CanvasProductSnapshot<TToolId extends string = string> {
+    readonly productId: string;
+    readonly document: CanvasProductDocumentRef;
+    readonly pageId: string;
+    readonly activeToolId: TToolId;
+    readonly selectedShapeIds: readonly ShapeId[];
+    readonly shapeCount: number;
+    readonly session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface CanvasProductShapeUpdate {
+    readonly id: ShapeId;
+    readonly x?: number;
+    readonly y?: number;
+    readonly rotation?: number;
+    readonly scaleX?: number;
+    readonly scaleY?: number;
+    readonly opacity?: number;
+    readonly isHidden?: boolean;
+    readonly isLocked?: boolean;
+    readonly parentId?: string;
+    readonly index?: string;
+    readonly props?: Readonly<Record<string, unknown>>;
+    readonly meta?: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductCreatePageInput {
+    readonly name?: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductLayerPlacement {
+    readonly parentId: string;
+    readonly beforeId?: ShapeId | null;
+}
+export type CanvasProductLayerPlacementFailureReason = "empty-selection" | "invalid-parent" | "invalid-before" | "locked" | "cycle" | "mixed-parent";
+export type CanvasProductLayerPlacementResult = {
+    readonly ok: true;
+    readonly ids: readonly ShapeId[];
+} | {
+    readonly ok: false;
+    readonly reason: CanvasProductLayerPlacementFailureReason;
+};
+export interface CanvasProductLayerNode {
+    readonly id: ShapeId;
+    readonly parentId: string;
+    readonly pageId: string;
+    readonly type: string;
+    readonly companionIds: readonly ShapeId[];
+    readonly childIds: readonly ShapeId[];
+    readonly siblingIndex: number;
+    readonly depth: number;
+    readonly canReceiveChildren: boolean;
+    readonly isHidden: boolean;
+    readonly isLocked: boolean;
+    readonly isEffectivelyHidden: boolean;
+    readonly isEffectivelyLocked: boolean;
+}
+export interface CanvasProductLayerActionState {
+    readonly canGroup: boolean;
+    readonly canUngroup: boolean;
+    readonly canMoveBackward: boolean;
+    readonly canMoveForward: boolean;
+}
+export type CanvasSelectionAlignMode = "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom";
+export type CanvasSelectionDistributeAxis = "horizontal" | "vertical";

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/persistence.d.ts

@@ -0,0 +1,16 @@
+export interface ProductPersistenceLoadResult {
+    /** `null` means that persistence has no stored document. */
+    readonly documentSnapshot: unknown | null;
+    /** Ignored when `documentSnapshot` is `null`. */
+    readonly sessionSnapshot: unknown | null;
+}
+export interface ProductPersistenceAdapter {
+    /** Load and validation failures must reject; they are not missing documents. */
+    load?(input: {
+        readonly signal: AbortSignal;
+    }): ProductPersistenceLoadResult | Promise<ProductPersistenceLoadResult>;
+    saveDocument?(snapshot: unknown): void | Promise<void>;
+    saveSession?(snapshot: unknown): void | Promise<void>;
+    flush?(): void | Promise<void>;
+    dispose?(): void | Promise<void>;
+}

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/plugin.d.ts

@@ -0,0 +1,37 @@
+import type { Editor, EditorPlugin } from "../canvas-core/index";
+import type { CanvasRenderPlugin } from "../canvas-react/host/index";
+import type { CanvasAssetResolverContribution, CanvasExportContribution, CanvasImportContribution } from "./contributions";
+import type { CanvasApiToken, ScopedProductApiRegistryView } from "./tokens";
+export interface CanvasPluginReference {
+    readonly id: string;
+    readonly __canvasPluginReferenceBrand: "CanvasPluginReference";
+}
+export type CanvasPluginRequirement = CanvasPluginReference;
+export interface CanvasTaskRunner {
+    run<TResult>(operation: (signal: AbortSignal) => Promise<TResult>): Promise<TResult>;
+}
+export interface CanvasPluginSetupContext {
+    readonly editor: Editor;
+    readonly productId: string;
+    readonly apis: ScopedProductApiRegistryView;
+    readonly tasks: CanvasTaskRunner;
+}
+export interface CanvasPluginInstance<TApi = never> {
+    readonly api?: TApi;
+    readonly imports?: readonly CanvasImportContribution[];
+    readonly exports?: readonly CanvasExportContribution[];
+    readonly assetResolvers?: readonly CanvasAssetResolverContribution[];
+    dispose?(): void | Promise<void>;
+}
+export interface CanvasPluginDefinition<TApi = never> {
+    readonly id: string;
+    readonly requires?: readonly CanvasPluginReference[];
+    readonly editor?: EditorPlugin;
+    readonly render?: CanvasRenderPlugin;
+    readonly api?: CanvasApiToken<TApi>;
+    setup?(context: CanvasPluginSetupContext): CanvasPluginInstance<TApi> | void;
+}
+export interface CanvasPlugin<TApi = never> extends CanvasPluginDefinition<TApi>, CanvasPluginReference {
+}
+export type CanvasPluginInput = CanvasPlugin<unknown> | readonly CanvasPluginInput[];
+export declare function defineCanvasPlugin<TApi = never>(plugin: CanvasPluginDefinition<TApi>): CanvasPlugin<TApi>;

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/shape.d.ts

@@ -0,0 +1,5 @@
+import type { ShapeId } from "../canvas-core/index";
+export interface CanvasShapeRef<TType extends string = string> {
+    readonly id: ShapeId;
+    readonly type: TType;
+}

package/_vendor/plugin-flow/_vendor/canvas-extension-contracts/tokens.d.ts

@@ -0,0 +1,12 @@
+export interface CanvasApiToken<TApi> {
+    readonly id: string;
+    readonly kind: "api";
+    readonly __api?: TApi;
+}
+export declare function createCanvasApiToken<TApi>(id: string): CanvasApiToken<TApi>;
+export declare function isCanvasApiToken(value: unknown): value is CanvasApiToken<unknown>;
+export interface ScopedProductApiRegistryView {
+    get<TApi>(token: CanvasApiToken<TApi>): TApi | null;
+    require<TApi>(token: CanvasApiToken<TApi>): TApi;
+}
+export declare function requireApi<TApi>(apis: ScopedProductApiRegistryView, token: CanvasApiToken<TApi>): TApi;

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

@@ -0,0 +1,7 @@
+import type { CanvasContextMenuRequest } from "../contextMenuRequest";
+import type { CanvasRenderBindings } from "../host/canvasRenderBindings";
+export declare function Canvas({ onContextMenuRequest, renderBindings, showGrid, }: {
+    onContextMenuRequest?: (request: CanvasContextMenuRequest) => void;
+    renderBindings: CanvasRenderBindings;
+    showGrid?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/_vendor/plugin-flow/_vendor/canvas-react/components/DefaultGrid.d.ts

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

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

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

package/_vendor/plugin-flow/_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/plugin-flow/_vendor/canvas-react/components/ShapeLayer.d.ts

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

package/_vendor/plugin-flow/_vendor/canvas-react/components/canvasKeyboardEvents.d.ts

@@ -0,0 +1,13 @@
+import type { Editor, EditorEventResult, KeyboardEditorEvent } from "../../canvas-core/index";
+export declare function createKeyboardEvent(name: KeyboardEditorEvent["name"], event: KeyboardEvent): KeyboardEditorEvent;
+export declare function routeCanvasKeyUp(editor: Editor, event: KeyboardEvent, isEditableTarget: boolean): EditorEventResult | null;
+export declare function getKeyboardShortcutEvent(event: KeyboardEvent): {
+    key: string;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+};
+export declare function isCanvasPanKey(event: Pick<KeyboardEvent, "code">): boolean;
+export declare function isCanvasPanKeyEventTarget(target: EventTarget | null, container: HTMLElement): boolean;

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

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

package/_vendor/plugin-flow/_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" | "terminal-binding-guide";
+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/plugin-flow/_vendor/canvas-react/components/overlays/BindingPreviewOverlay.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { type SelectionBindingSegment } from "../../../canvas-core/index";
+import { type DashedGuideSegmentKind } from "./BindingGuide";
+export declare const SelectionPathOverlay: import("react").NamedExoticComponent<object>;
+export declare const BindingSegmentsOverlay: import("react").NamedExoticComponent<{
+    bindingSegments: readonly SelectionBindingSegment[];
+    kind?: DashedGuideSegmentKind;
+    strokeWidth: number;
+}>;

package/_vendor/plugin-flow/_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/plugin-flow/_vendor/canvas-react/components/overlays/SnapIndicatorsOverlay.d.ts

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

package/_vendor/plugin-flow/_vendor/canvas-react/components/overlays/TerminalBindingGuidesOverlay.d.ts

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

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/ShapeClipStack.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+import { type Mat, type ShapeId } from "../../../canvas-core/index";
+/**
+ * Shape DOM 节点在页面空间中平铺渲染，并未嵌套在父级 Shape 节点内，
+ * 因此需要在这里重建逻辑上的祖先裁剪层级。
+ */
+export declare function ShapeClipStack({ children, clipAncestorIds, shapeElementToPage, }: {
+    children: ReactNode;
+    clipAncestorIds: readonly ShapeId[];
+    shapeElementToPage: Mat;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/ShapeDecorations.d.ts

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

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/ShapeForegroundItem.d.ts

@@ -0,0 +1,5 @@
+import type { ShapeId } from "../../../canvas-core/index";
+export declare const ShapeForegroundItem: import("react").NamedExoticComponent<{
+    shapeId: ShapeId;
+    stackingOrder: number;
+}>;

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/ShapeItem.d.ts

@@ -0,0 +1,5 @@
+import type { ShapeId } from "../../../canvas-core/index";
+export declare const ShapeItem: import("react").NamedExoticComponent<{
+    shapeId: ShapeId;
+    stackingOrder: number;
+}>;

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/ShapeRenderList.d.ts

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

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/ShapeRenderer.d.ts

@@ -0,0 +1,12 @@
+import type { Editor, ShapeRecord } from "../../../canvas-core/index";
+import { type AnyRegisteredShapeRenderer, type ShapeRendererProps } from "../../host/canvasRenderPlugin";
+interface MemoizedShapeRendererProps extends ShapeRendererProps {
+    Component: AnyRegisteredShapeRenderer["component"];
+}
+export declare const MemoizedShapeRenderer: import("react").NamedExoticComponent<MemoizedShapeRendererProps>;
+export declare function ShapeHoverDecoration({ Component, editor, shape, }: {
+    Component: NonNullable<AnyRegisteredShapeRenderer["hoverComponent"]>;
+    editor: Editor;
+    shape: ShapeRecord;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/_vendor/plugin-flow/_vendor/canvas-react/components/shape-layer/shapeFrame.d.ts

@@ -0,0 +1,11 @@
+import { Mat, type Editor, type ShapeRecord } from "../../../canvas-core/index";
+export interface ShapeFrame {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    transform: string;
+    transformOrigin: string;
+    elementToPage: Mat;
+}
+export declare function getShapeFrame(editor: Editor, shape: ShapeRecord, renderToPage: Mat): ShapeFrame;