@yuzhouu/canvas-standard 0.1.0

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

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

package/_vendor/plugin-flow/_vendor/canvas-react/contextMenuRequest.d.ts

@@ -0,0 +1,19 @@
+import type { ShapeId, ShapeRecordBase, Vec } from "../canvas-core/index";
+export type CanvasContextMenuTarget = {
+    type: "canvas";
+} | {
+    type: "shape";
+    shapeId: ShapeId;
+    shapeType: ShapeRecordBase["type"];
+    selected: boolean;
+} | {
+    type: "selection";
+    selectedShapeIds: readonly ShapeId[];
+};
+export interface CanvasContextMenuRequest {
+    anchor: {
+        screenPoint: Vec;
+        pagePoint: Vec;
+    };
+    target: CanvasContextMenuTarget;
+}

package/_vendor/plugin-flow/_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, root?: ParentNode): 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/plugin-flow/_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/plugin-flow/_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/plugin-flow/_vendor/canvas-react/host/canvasRenderBindings.d.ts

@@ -0,0 +1,21 @@
+import type { Editor, ReadonlyValue, SelectionCustomHandle, ShapeId, ShapeRecordBase } from "../../canvas-core/index";
+import type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasDomEventGuardCursorInput, CanvasDomEventGuardInput, CanvasOverlayContribution, CanvasRenderPlugin, CanvasRenderPluginComponent } from "./canvasRenderPlugin";
+export interface CanvasRendererLookup {
+    getShapeRenderer(type: ShapeRecordBase["type"]): AnyRegisteredShapeRenderer | null;
+    getShapeOpacityValue(editor: Editor, shapeId: ShapeId): ReadonlyValue<number>;
+}
+export interface CanvasOverlayLookup {
+    getCanvasOverlays(): readonly CanvasOverlayContribution[];
+    getSelectionCustomHandleRenderer(type: SelectionCustomHandle["type"]): AnyRegisteredSelectionCustomHandleRenderer | null;
+}
+export interface CanvasDomEventGuards {
+    handle(input: CanvasDomEventGuardInput): "continue" | "handled";
+    getCursor(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export interface CanvasRenderBindings {
+    readonly canvasComponents: readonly CanvasRenderPluginComponent[];
+    readonly renderers: CanvasRendererLookup;
+    readonly overlays: CanvasOverlayLookup;
+    readonly domEventGuards: CanvasDomEventGuards;
+}
+export declare function createCanvasRenderBindings(plugins: readonly CanvasRenderPlugin[]): CanvasRenderBindings;

package/_vendor/plugin-flow/_vendor/canvas-react/host/canvasRenderBindingsContext.d.ts

@@ -0,0 +1,5 @@
+import { type CanvasOverlayLookup, type CanvasRenderBindings, type CanvasRendererLookup } from "./canvasRenderBindings";
+export declare const CanvasRenderBindingsContext: import("react").Context<CanvasRenderBindings>;
+export declare function useCanvasRenderBindings(): CanvasRenderBindings;
+export declare function useCanvasRenderers(): CanvasRendererLookup;
+export declare function useCanvasOverlays(): CanvasOverlayLookup;

package/_vendor/plugin-flow/_vendor/canvas-react/host/canvasRenderPlugin.d.ts

@@ -0,0 +1,81 @@
+import type { ComponentType } from "react";
+import type { Editor, ReadonlyValue, SelectionCustomHandle, ShapeEditingSession, ShapeRecordBase } from "../../canvas-core/index";
+export interface ShapeRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    isSelected: boolean;
+    shapeEditingSession: ShapeEditingSession | null;
+}
+/**
+ * Rendered inside the shape's render-bounds host. SVG coordinates should match
+ * the shape util's `getRenderBounds()` coordinate space.
+ */
+export interface ShapeHoverRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    /** Local-space width that renders as the standard hover width on screen. */
+    strokeWidth: number;
+}
+export declare const SHAPE_HOVER_STROKE = "var(--land-shape-hover, var(--land-selection, #2563eb))";
+/** Standard hover stroke width in screen pixels. */
+export declare const SHAPE_HOVER_STROKE_WIDTH = 2;
+export interface RegisteredShapeRenderer<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    component: ComponentType<ShapeRendererProps<S>>;
+    hoverComponent?: ComponentType<ShapeHoverRendererProps<S>>;
+    foregroundComponent?: 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 interface CanvasOverlayContribution {
+    id: string;
+    component: ComponentType;
+    order?: number;
+}
+export interface CanvasRenderPluginComponent {
+    id: string;
+    component: ComponentType;
+}
+export interface ShapeOpacityModifier {
+    id: string;
+    getOpacityValue(editor: Editor, shapeId: ShapeRecordBase["id"]): ReadonlyValue<number>;
+}
+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 CanvasRenderPlugin {
+    id: string;
+    shapeRenderers?: readonly AnyRegisteredShapeRenderer[];
+    canvasOverlays?: readonly CanvasOverlayContribution[];
+    selectionCustomHandleRenderers?: readonly AnyRegisteredSelectionCustomHandleRenderer[];
+    domEventGuards?: readonly CanvasDomEventGuard[];
+    canvasComponents?: readonly CanvasRenderPluginComponent[];
+    shapeOpacityModifiers?: readonly ShapeOpacityModifier[];
+}

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

@@ -0,0 +1,5 @@
+export { CanvasRenderBindingsContext, useCanvasOverlays, useCanvasRenderBindings, useCanvasRenderers, } from "./canvasRenderBindingsContext";
+export type { CanvasDomEventGuards, CanvasOverlayLookup, CanvasRendererLookup, } from "./canvasRenderBindings";
+export type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasOverlayContribution, CanvasDomEventGuard, CanvasDomEventGuardCursorInput, CanvasDomEventGuardDecision, CanvasDomEventGuardInput, CanvasDomEventGuardName, CanvasRenderPluginComponent, CanvasRenderPlugin, RegisteredSelectionCustomHandleRenderer, RegisteredShapeRenderer, SelectionCustomHandleRendererProps, ShapeHoverRendererProps, ShapeRendererProps, ShapeOpacityModifier, } from "./canvasRenderPlugin";
+export { SHAPE_HOVER_STROKE, SHAPE_HOVER_STROKE_WIDTH, } from "./canvasRenderPlugin";
+export { createCanvasRenderBindings, type CanvasRenderBindings, } from "./canvasRenderBindings";

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

@@ -0,0 +1,5 @@
+export { Canvas, DefaultGrid, PageSpace } from "./components";
+export type { CanvasContextMenuRequest, CanvasContextMenuTarget, } from "./contextMenuRequest";
+export { CANVAS_SURFACE_DATA_UI, CANVAS_SURFACE_SELECTOR, forwardWheelEventToCanvasSurface, getCanvasSurfaceElement, getCanvasSurfaceElementForNode, getCanvasSurfacePagePoint, getCanvasSurfaceScreenPoint, getEditableEventTarget, isEditableEventTarget, } from "./dom";
+export { useEditor, EditorContext } from "./hooks/useEditor";
+export { useValue } from "./hooks/useValue";

package/_vendor/plugin-flow/_vendor/plugin-connector/api.d.ts

@@ -0,0 +1,28 @@
+import { type Editor, type ShapeColor, type ShapeId } from "../canvas-core/index";
+import { type ConnectorHead, type ConnectorRouting, type ConnectorShapeProps, type ConnectorStrokeStyle } from "./types";
+export interface ConnectorStylePatch {
+    routing?: ConnectorRouting;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+    strokeStyle?: ConnectorStrokeStyle;
+    headStart?: ConnectorHead;
+    headEnd?: ConnectorHead;
+}
+export interface ConnectorSelectionStyle {
+    readonly routing: ConnectorRouting | null;
+    readonly stroke: ShapeColor | null;
+    readonly strokeWidth: number | null;
+    readonly strokeStyle: ConnectorStrokeStyle | null;
+    readonly headStart: ConnectorHead | null;
+    readonly headEnd: ConnectorHead | null;
+}
+export interface ConnectorApi {
+    getSelectionStyle(): ConnectorSelectionStyle | null;
+    setSelectionStyle(patch: ConnectorStylePatch): readonly ShapeId[];
+    getToolDefaults(): ConnectorShapeProps;
+    setToolDefaults(patch: ConnectorStylePatch): ConnectorShapeProps;
+}
+export declare const connectorApiToken: import("../canvas-extension-contracts/index").CanvasApiToken<ConnectorApi>;
+export declare function createConnectorPluginApi({ editor, }: {
+    editor: Editor;
+}): ConnectorApi;

package/_vendor/plugin-flow/_vendor/plugin-connector/canvasRender.d.ts

@@ -0,0 +1,2 @@
+import { type CanvasRenderPlugin } from "../canvas-react/host/index";
+export declare function createConnectorCanvasRenderPlugin(): CanvasRenderPlugin;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorBindingUtil.d.ts

@@ -0,0 +1,28 @@
+import { BindingUtil, type BindingUtilEffect, type Editor, type ShapeRecord } from "../canvas-core/index";
+import { type ConnectorBindingRecord } from "./types";
+export declare class ConnectorBindingUtil extends BindingUtil<ConnectorBindingRecord> {
+    readonly type: "connector";
+    getDefaultProps(): ConnectorBindingRecord["props"];
+    validateProps(props: unknown): ConnectorBindingRecord["props"];
+    canBind(editor: Editor, binding: ConnectorBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    getExclusiveBindingKey(binding: ConnectorBindingRecord): string;
+    onBindingCreate(editor: Editor, binding: ConnectorBindingRecord): void | BindingUtilEffect;
+    onBindingUpdate(editor: Editor, _before: ConnectorBindingRecord, after: ConnectorBindingRecord): void | BindingUtilEffect;
+    onBindingLoad(editor: Editor, binding: ConnectorBindingRecord): void | BindingUtilEffect;
+    onAfterShapeChange(editor: Editor, binding: ConnectorBindingRecord, context: {
+        role: "from" | "to";
+    }): void | BindingUtilEffect;
+    onBeforeDeleteShape(editor: Editor, binding: ConnectorBindingRecord, context: {
+        role: "from" | "to";
+    }): BindingUtilEffect;
+    onBeforeDeleteBinding(editor: Editor, binding: ConnectorBindingRecord): BindingUtilEffect;
+    getExportShapeIds(_editor: Editor, binding: ConnectorBindingRecord): ShapeRecord["id"][];
+    getGeometryDependentShapeIds(_editor: Editor, binding: ConnectorBindingRecord, context: {
+        role: "from" | "to";
+    }): ShapeRecord["id"][];
+    private getSyncEffect;
+    private getDetachEffect;
+}

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorBindings.d.ts

@@ -0,0 +1,8 @@
+import type { Editor, ShapeId } from "../canvas-core/index";
+import { type ConnectorBindingRecord } from "./types";
+export interface ConnectorTerminalBindings {
+    start: ConnectorBindingRecord | null;
+    end: ConnectorBindingRecord | null;
+}
+export declare function getConnectorTerminalBindings(editor: Editor, connectorId: ShapeId): ConnectorTerminalBindings;
+export declare function getConnectorBindings(editor: Editor, connectorId: ShapeId): ConnectorBindingRecord[];

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorGeometry.d.ts

@@ -0,0 +1,70 @@
+import { Box, Vec, type Editor, type Mat, type ShapeLabelPathGeometry } from "../canvas-core/index";
+import type { ConnectorHead, ConnectorRouting, ConnectorShapeRecord } from "./types";
+export interface ConnectorLineSegment {
+    type: "line";
+    start: Vec;
+    end: Vec;
+}
+export interface ConnectorCubicSegment {
+    type: "cubic";
+    start: Vec;
+    control1: Vec;
+    control2: Vec;
+    end: Vec;
+}
+export interface ConnectorQuadraticSegment {
+    type: "quadratic";
+    start: Vec;
+    control: Vec;
+    end: Vec;
+}
+export type ConnectorSegment = ConnectorLineSegment | ConnectorQuadraticSegment | ConnectorCubicSegment;
+export declare function getConnectorSegmentPoint(segment: ConnectorSegment, t: number): Vec;
+export declare function getConnectorLabelPathGeometry(info: ConnectorInfo): ShapeLabelPathGeometry;
+export interface ConnectorInfo {
+    path: string;
+    startPagePoint: Vec;
+    endPagePoint: Vec;
+    startTangent: Vec;
+    endTangent: Vec;
+    startArrowScale: number;
+    endArrowScale: number;
+    pageBounds: Box;
+    segments: readonly ConnectorSegment[];
+    markerSegments: readonly ConnectorLineSegment[];
+    points: readonly Vec[];
+    routePoints: readonly Vec[];
+}
+export interface ConnectorTerminalOffsetInput {
+    point: Vec;
+    direction: Vec;
+    along: number;
+    perpendicular: number;
+}
+export type ConnectorTerminalOffsetMapper = (input: ConnectorTerminalOffsetInput) => Vec;
+export interface ConnectorTerminalGeometry {
+    point: Vec;
+    outwardNormal: Vec;
+    obstacleId?: string;
+    obstacleBounds?: Box;
+}
+export declare function createConnectorTerminalOffsetMapper(localToGeometry: Mat): ConnectorTerminalOffsetMapper;
+export declare function getResolvedConnectorPageInfo(editor: Editor, shape: ConnectorShapeRecord): ConnectorInfo;
+export declare function getResolvedConnectorLocalInfo(editor: Editor, shape: ConnectorShapeRecord): ConnectorInfo;
+export declare function getConnectorInfo({ start, end, routing, cornerRadius, headStart, headEnd, strokeWidth, terminalOffsetMapper, curveWaypoints, orthogonalBends, }: {
+    start: ConnectorTerminalGeometry;
+    end: ConnectorTerminalGeometry;
+    routing: ConnectorRouting;
+    cornerRadius: number;
+    headStart?: ConnectorHead;
+    headEnd?: ConnectorHead;
+    strokeWidth?: number;
+    terminalOffsetMapper?: ConnectorTerminalOffsetMapper;
+    curveWaypoints?: readonly Vec[];
+    orthogonalBends?: readonly Vec[];
+}): ConnectorInfo;
+export declare function mapConnectorInfo(info: ConnectorInfo, transform: {
+    applyToPoint(point: Vec): Vec;
+}): ConnectorInfo;
+export declare function getConnectorMarkerSegmentsPath(segments: readonly ConnectorLineSegment[]): string;
+export declare function compactOrthogonalPoints(points: readonly Vec[]): Vec[];

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorHandles.d.ts

@@ -0,0 +1,12 @@
+export declare const CONNECTOR_CURVE_WAYPOINT_HANDLE_TYPE = "connector.curve-waypoint";
+export declare const CONNECTOR_CURVE_INSERT_HANDLE_TYPE = "connector.curve-insert";
+export declare const CONNECTOR_ORTHOGONAL_SEGMENT_HANDLE_TYPE = "connector.orthogonal-segment";
+export type ConnectorOrthogonalSegmentAxis = "horizontal" | "vertical";
+export declare function createConnectorCurveWaypointHandleId(index: number): string;
+export declare function createConnectorCurveInsertHandleId(index: number): string;
+export declare function createConnectorOrthogonalSegmentHandleId(index: number, axis: ConnectorOrthogonalSegmentAxis): string;
+export declare function parseConnectorIndexedHandleId(id: string, prefix: "waypoint" | "segment"): number | null;
+export declare function parseConnectorOrthogonalSegmentHandleId(id: string): {
+    index: number;
+    axis: ConnectorOrthogonalSegmentAxis;
+} | null;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorInteractions.d.ts

@@ -0,0 +1,3 @@
+import { type LandInteractionHandler } from "../canvas-core/index";
+import { type ConnectorQuickCreateNodeFactory } from "./types";
+export declare function createConnectorInteractionHandler(quickCreateNodeFactory: ConnectorQuickCreateNodeFactory): LandInteractionHandler;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorMarker.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectorTerminal } from "./types";
+export declare const CONNECTOR_ARROW_TERMINAL_PADDING = 3;
+export declare function getConnectorArrowMagnification(strokeWidth: number): number;
+export declare function getConnectorArrowLength(strokeWidth: number): number;
+export declare function getConnectorArrowGlyphLength(strokeWidth: number): number;
+export declare function getConnectorMarkerRefX(terminal: ConnectorTerminal, strokeWidth: number, scale?: number): number;
+export declare function getConnectorMarkerPath(terminal: ConnectorTerminal, strokeWidth: number, scale?: number): string;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorModel.d.ts

@@ -0,0 +1,43 @@
+import { Box, Vec, type ChangeSource, type Editor, type ResolvedShapeTerminalBindingPort, type ShapeId, type ShapeParentId, type ShapeRecord } from "../canvas-core/index";
+import { type ConnectorTerminalGeometry } from "./connectorGeometry";
+import { type ConnectorPortAttachment } from "./connectorPorts";
+import { type ConnectorShapeProps, type ConnectorShapeRecord, type ConnectorTerminal } from "./types";
+export interface ConnectorEndpointInput {
+    shape: ShapeRecord;
+    port: ResolvedShapeTerminalBindingPort;
+}
+export interface ConnectorBoundEndpoint {
+    kind: "bound";
+    shapeId: ShapeId;
+    attachment: ConnectorPortAttachment;
+}
+export type ConnectorDraftEndpoint = {
+    kind: "free";
+    pagePoint: Vec;
+} | ConnectorBoundEndpoint;
+export interface ResolvedConnectorDraftEndpoint {
+    draft: ConnectorDraftEndpoint;
+    pagePoint: Vec;
+    shape: ShapeRecord | null;
+    port: ResolvedShapeTerminalBindingPort | null;
+    obstacleBounds?: Box;
+}
+export type ConnectorCreationInvalidReason = "missing_endpoint" | "locked_source" | "cross_page" | "same_attachment" | "duplicate" | "invalid_parent";
+export interface CommitConnectorCreationInput {
+    start: ConnectorDraftEndpoint;
+    end: ConnectorDraftEndpoint;
+    props?: Partial<ConnectorShapeProps>;
+    selectionAfter?: "connector" | "none" | readonly ShapeId[];
+}
+export declare function createConnectorBoundEndpoint(shapeId: ShapeId, port: ResolvedShapeTerminalBindingPort): ConnectorBoundEndpoint;
+export declare function resolveConnectorDraftEndpoint(editor: Editor, draft: ConnectorDraftEndpoint): ResolvedConnectorDraftEndpoint | null;
+export declare function getConnectorCreationInvalidReason(editor: Editor, startDraft: ConnectorDraftEndpoint, endDraft: ConnectorDraftEndpoint, excludeConnectorId?: ShapeId): ConnectorCreationInvalidReason | null;
+export declare function commitConnectorCreation(editor: Editor, input: CommitConnectorCreationInput, source?: ChangeSource): ConnectorShapeRecord | null;
+export declare function getSyncedConnectorShape(editor: Editor, shape: ConnectorShapeRecord): ConnectorShapeRecord | null;
+export declare function setConnectorTerminalPagePoint(editor: Editor, shape: ConnectorShapeRecord, terminal: ConnectorTerminal, pagePoint: Vec): ConnectorShapeRecord | null;
+export declare function getConnectorDraftTerminalGeometry(endpoint: ResolvedConnectorDraftEndpoint, opposite: ResolvedConnectorDraftEndpoint, terminal: ConnectorTerminal): ConnectorTerminalGeometry;
+export declare function hasDirectedConnector(editor: Editor, sourceShapeId: ShapeId, sourcePortId: string, targetShapeId: ShapeId, targetPortId: string, excludeConnectorId?: ShapeId): boolean;
+export declare function areSameConnectorEndpointIds(leftShapeId: ShapeId, leftPortId: string, rightShapeId: ShapeId, rightPortId: string): boolean;
+export declare function getConnectorParentId(editor: Editor, startShape: ShapeRecord, endShape: ShapeRecord): ShapeParentId | null;
+export declare function resolveConnectorDraftParentId(editor: Editor, start: ResolvedConnectorDraftEndpoint, end: ResolvedConnectorDraftEndpoint): ShapeParentId | null;
+export declare function areConnectorShapesEquivalent(left: ConnectorShapeRecord, right: ConnectorShapeRecord): boolean;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorPortInteraction.d.ts

@@ -0,0 +1,13 @@
+import { type Editor, type ResolvedShapeTerminalBindingPort, type ShapeId, type ShapeRecord, type Vec } from "../canvas-core/index";
+export interface ConnectorPortInteractionState {
+    visibleShapes: readonly ShapeRecord[];
+    sourceShapeIds: ReadonlySet<ShapeId>;
+    targetShapeId: ShapeId | null;
+    highlightedPortId: string | null;
+}
+export declare function getConnectorPortInteractionState(editor: Editor): ConnectorPortInteractionState;
+export declare function getVisibleConnectorSourcePortAtPoint(editor: Editor, pagePoint: Vec): {
+    shape: ShapeRecord;
+    port: ResolvedShapeTerminalBindingPort;
+} | null;
+export declare function getConnectorHoverShapeAtPoint(editor: Editor, pagePoint: Vec): ShapeRecord | null;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorPorts.d.ts

@@ -0,0 +1,23 @@
+import { Vec, type Editor, type ResolvedShapeTerminalBindingPort, type ShapeRecord } from "../canvas-core/index";
+import type { ConnectorBindingProps, ConnectorPoint, ConnectorTerminal } from "./types";
+export type ConnectorPortAttachment = {
+    kind: "port";
+    portId: string;
+} | {
+    kind: "border";
+    normalizedAnchor: ConnectorPoint;
+};
+export interface ConnectorBorderPortHit {
+    port: ResolvedShapeTerminalBindingPort;
+    borderDistance: number;
+}
+export interface ConnectorPageBindingOutline {
+    points: readonly Vec[];
+    closed: boolean;
+}
+export declare function getConnectorPageBindingOutlines(editor: Editor, shape: ShapeRecord): ConnectorPageBindingOutline[];
+export declare function getConnectorBorderPortAtPoint(editor: Editor, shape: ShapeRecord, pagePoint: Vec, midpointSnapRadius: number): ConnectorBorderPortHit | null;
+export declare function getResolvedConnectorBindingPort(editor: Editor, shape: ShapeRecord, props: Pick<ConnectorBindingProps, "portId" | "normalizedAnchor">): ResolvedShapeTerminalBindingPort | null;
+export declare function getConnectorPortAttachment(port: ResolvedShapeTerminalBindingPort): ConnectorPortAttachment;
+export declare function getResolvedConnectorAttachmentPort(editor: Editor, shape: ShapeRecord, attachment: ConnectorPortAttachment): ResolvedShapeTerminalBindingPort | null;
+export declare function getConnectorBindingProps(terminal: ConnectorTerminal, port: ResolvedShapeTerminalBindingPort): ConnectorBindingProps & Record<string, unknown>;

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorRuntime.d.ts

@@ -0,0 +1,63 @@
+import { type Box, type Editor, type Mat, type CancelEditorEvent, type ShapeColor, type ShapeId, type TerminalBindingPortId, type Vec } from "../canvas-core/index";
+import type { Signal } from "../signals/index";
+import type { ConnectorHead, ConnectorQuickCreateNodeFactory, ConnectorRouting, ConnectorStrokeStyle, ConnectorTerminal } from "./types";
+import type { ConnectorCreationInvalidReason, ConnectorDraftEndpoint } from "./connectorModel";
+export interface ConnectorPreviewGeometry {
+    routing: ConnectorRouting;
+    cornerRadius: number;
+    headStart: ConnectorHead;
+    headEnd: ConnectorHead;
+    stroke: ShapeColor;
+    strokeWidth: number;
+    strokeStyle: ConnectorStrokeStyle;
+    curveWaypoints: readonly Vec[];
+    orthogonalBends: readonly Vec[];
+    localToPageTransform: Mat;
+}
+export interface ConnectorPreviewEndpoint {
+    draft: ConnectorDraftEndpoint;
+    pagePoint: Vec;
+    pageOutwardNormal: Vec;
+    shapeId: ShapeId | null;
+    portId: string | null;
+    obstacleBounds?: Box;
+}
+interface ConnectorInteractionPreviewBase {
+    start: ConnectorPreviewEndpoint;
+    end: ConnectorPreviewEndpoint;
+    isDragging: boolean;
+    movingTerminal: ConnectorTerminal;
+    geometry: ConnectorPreviewGeometry;
+}
+export interface ConnectorCreationPreview extends ConnectorInteractionPreviewBase {
+    kind: "create";
+    origin: "canvas" | "port";
+    invalidReason: ConnectorCreationInvalidReason | null;
+}
+export interface ConnectorRebindPreview extends ConnectorInteractionPreviewBase {
+    kind: "rebind";
+}
+export type ConnectorInteractionPreview = ConnectorCreationPreview | ConnectorRebindPreview;
+export interface ConnectorPointerSession {
+    pointerId: number;
+    originScreenPoint: Vec;
+    readonly preview: ConnectorCreationPreview;
+    update(screenPoint: Vec, pagePoint: Vec, accelKey: boolean): void;
+    complete(screenPoint: Vec, pagePoint: Vec, accelKey: boolean): boolean;
+    cancel(reason?: CancelEditorEvent["reason"]): void;
+}
+export interface ConnectorRuntime {
+    readonly previewSignal: Signal<ConnectorInteractionPreview | null>;
+    readonly quickCreateNodeFactory: ConnectorQuickCreateNodeFactory;
+    readonly selectionHandlesHiddenSignal: Signal<boolean>;
+    readonly pointerSession: ConnectorPointerSession | null;
+    isPortVisible(portId: TerminalBindingPortId): boolean;
+    setPointerSession(session: ConnectorPointerSession | null): void;
+    setPreview(preview: ConnectorInteractionPreview | null): void;
+    setSelectionHandlesHidden(hidden: boolean): void;
+    dispose(): void;
+}
+export declare const connectorRuntimeToken: import("../canvas-core/index").EditorRuntimeToken<ConnectorRuntime>;
+export declare function createConnectorRuntime(editor: Editor, quickCreateNodeFactory: ConnectorQuickCreateNodeFactory, visiblePortIds?: readonly TerminalBindingPortId[]): ConnectorRuntime;
+export declare function getConnectorRuntime(editor: Editor): ConnectorRuntime;
+export {};

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorShapeUtil.d.ts

@@ -0,0 +1,29 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushWrapInput, type ShapeGeometryInput, type ShapeLineSegmentHitTestInput, type ShapeLabelPathGeometry, type ShapePointHitTestInput, type ShapeSelectionFrameInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionOverlayInfo, type ShapeSelectionOverlayInfoInput, type ShapeSelectionResizeInput, type ShapeSelectionTransformCapabilityInput, type ShapeUpdate } from "../canvas-core/index";
+import type { ConnectorShapeProps, ConnectorShapeRecord } from "./types";
+export declare class ConnectorShapeUtil extends ShapeUtil<ConnectorShapeRecord> {
+    readonly type: "connector";
+    getDefaultProps(): ConnectorShapeProps;
+    validateProps(props: unknown): ConnectorShapeProps;
+    getLocalBounds(shape: ConnectorShapeRecord): Box;
+    getPointHitTestBounds(shape: ConnectorShapeRecord, input?: ShapeGeometryInput): Box;
+    canSnap(): boolean;
+    canParticipateInSelectionResize(_shape: ConnectorShapeRecord, input: ShapeSelectionTransformCapabilityInput): boolean;
+    resizeSelectionBounds(shape: ConnectorShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    canParticipateInSelectionFlip(): boolean;
+    canParticipateInSelectionRotation(): boolean;
+    canParticipateInSelectionTranslation(): boolean;
+    contributesToSelectionFrame(_shape: ConnectorShapeRecord, _input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionResizeHandles(_shape: ConnectorShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionRotateHandle(_shape: ConnectorShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canStartTranslateFromSelectionBounds(_shape: ConnectorShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    getSelectionHandleAnchors(shape: ConnectorShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+    getSelectionOverlayInfo(shape: ConnectorShapeRecord, input: ShapeSelectionOverlayInfoInput): ShapeSelectionOverlayInfo;
+    getLabelPathGeometry(shape: ConnectorShapeRecord, input: ShapeSelectionOverlayInfoInput): ShapeLabelPathGeometry;
+    canCopyToClipboard(shape: ConnectorShapeRecord, input: {
+        editor: ShapeSelectionOverlayInfoInput["editor"];
+        copiedShapeIds: ReadonlySet<ConnectorShapeRecord["id"]>;
+    }): boolean;
+    isWrappedByBrush(shape: ConnectorShapeRecord, input: ShapeBrushWrapInput): boolean;
+    hitTest(shape: ConnectorShapeRecord, point: Vec, input?: ShapePointHitTestInput): boolean;
+    hitTestLineSegment(shape: ConnectorShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+}

package/_vendor/plugin-flow/_vendor/plugin-connector/connectorTool.d.ts

@@ -0,0 +1,4 @@
+import { StateNode, type Editor } from "../canvas-core/index";
+export declare class ConnectorTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/plugin-flow/_vendor/plugin-connector/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const CONNECTOR_ORTHOGONAL_STUB_PAGE = 36;
+export declare const CONNECTOR_ORTHOGONAL_OBSTACLE_CLEARANCE_PAGE = 36;
+export declare const CONNECTOR_PORT_VISUAL_RADIUS_SCREEN = 4;
+export declare const CONNECTOR_PORT_HOVER_RADIUS_SCREEN = 12;
+export declare const CONNECTOR_PORT_HOVER_GAP_SCREEN = 8;
+export declare const CONNECTOR_PORT_HOVER_ICON_SCREEN = 15;
+export declare const CONNECTOR_PORT_HIT_RADIUS_SCREEN = 12;
+export declare const CONNECTOR_PORT_VISUAL_OFFSET_SCREEN: number;
+export declare const CONNECTOR_LINE_HIT_RADIUS_SCREEN = 12;
+export declare const CONNECTOR_CLICK_DRAG_THRESHOLD_SCREEN = 10;
+export declare const CONNECTOR_ORTHOGONAL_TERMINAL_SNAP_SCREEN = 8;
+export declare const CONNECTOR_ORTHOGONAL_SEGMENT_SNAP_SCREEN = 8;
+export declare const CONNECTOR_QUICK_CONNECT_DISTANCE_PAGE = 320;
+export declare const CONNECTOR_QUICK_CONNECT_CROSS_AXIS_PAGE = 160;
+export declare const CONNECTOR_QUICK_CREATE_GAP_PAGE = 96;
+export declare const CONNECTOR_QUICK_CREATE_CROSS_GAP_PAGE = 48;
+export declare const CONNECTOR_DASH_ARRAY = "8 6";

package/_vendor/plugin-flow/_vendor/plugin-connector/editorRuntime.d.ts

@@ -0,0 +1,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode, type TerminalBindingPortId } from "../canvas-core/index";
+import type { ConnectorQuickCreateNodeFactory, ConnectorShapeRecord } from "./types";
+export declare class ConnectorShapeSvgExporter implements ShapeSvgExporter<ConnectorShapeRecord> {
+    readonly type: "connector";
+    toSvg(shape: ConnectorShapeRecord, context: SvgExportContext): SvgNode;
+}
+export declare function createConnectorEditorPlugin(quickCreateNodeFactory: ConnectorQuickCreateNodeFactory, visiblePortIds?: readonly TerminalBindingPortId[]): EditorPlugin;

package/_vendor/plugin-flow/_vendor/plugin-connector/feature.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectorPluginOptions } from "./types";
+export declare function createConnectorPlugin(options?: ConnectorPluginOptions): import("../canvas-extension-contracts/index").CanvasPlugin<import("./api").ConnectorApi>;
+export declare const Connector: import("../canvas-extension-contracts/index").CanvasPlugin<import("./api").ConnectorApi>;

package/_vendor/plugin-flow/_vendor/plugin-connector/index.d.ts

@@ -0,0 +1,20 @@
+export { Connector, createConnectorPlugin } from "./feature";
+export { connectorApiToken } from "./api";
+export type { ConnectorApi, ConnectorSelectionStyle, ConnectorStylePatch, } from "./api";
+export { ConnectorShapeUtil } from "./connectorShapeUtil";
+export { ConnectorBindingUtil } from "./connectorBindingUtil";
+export { ConnectorTool } from "./connectorTool";
+export { ConnectorShapeSvgExporter, createConnectorEditorPlugin, } from "./editorRuntime";
+export { createConnectorCanvasRenderPlugin } from "./canvasRender";
+export { createConnectorTerminalOffsetMapper, getConnectorSegmentPoint, getConnectorInfo, getResolvedConnectorLocalInfo, getResolvedConnectorPageInfo, } from "./connectorGeometry";
+export * from "./connectorHandles";
+export type { ConnectorInfo, ConnectorSegment, ConnectorTerminalOffsetInput, ConnectorTerminalOffsetMapper, ConnectorTerminalGeometry, } from "./connectorGeometry";
+export { CONNECTOR_ARROW_TERMINAL_PADDING, getConnectorArrowGlyphLength, getConnectorArrowLength, getConnectorArrowMagnification, getConnectorMarkerPath, getConnectorMarkerRefX, } from "./connectorMarker";
+export { commitConnectorCreation, createConnectorBoundEndpoint, getConnectorCreationInvalidReason, getConnectorParentId, resolveConnectorDraftEndpoint, resolveConnectorDraftParentId, hasDirectedConnector, setConnectorTerminalPagePoint, } from "./connectorModel";
+export type { CommitConnectorCreationInput, ConnectorBoundEndpoint, ConnectorCreationInvalidReason, ConnectorDraftEndpoint, ResolvedConnectorDraftEndpoint, } from "./connectorModel";
+export { chooseFacingPort, createDefaultConnectorQuickCreateNodeFactory, findQuickConnectTargets, getBalancedConnectorBranchNodeInput, getConnectorVisualPortPoint, getNearestConnectorPortAtPoint, quickConnectFromPort, } from "./quickConnect";
+export type { ConnectorPortTarget, ConnectorQuickConnectPlan, } from "./quickConnect";
+export { getConnectorPortInteractionState, getVisibleConnectorSourcePortAtPoint, } from "./connectorPortInteraction";
+export * from "./constants";
+export type { ConnectorBindingProps, ConnectorBindingRecord, ConnectorHead, ConnectorPluginOptions, ConnectorPoint, ConnectorQuickCreateNodeFactory, ConnectorRouting, ConnectorShapeProps, ConnectorShapeRecord, ConnectorStrokeStyle, ConnectorTerminal, } from "./types";
+export { isConnectorBindingRecord, isConnectorShapeRecord, } from "./types";

package/_vendor/plugin-flow/_vendor/plugin-connector/orthogonalRoute.d.ts

@@ -0,0 +1,9 @@
+import { Box, Vec } from "../canvas-core/index";
+interface RouteTerminal {
+    point: Vec;
+    direction: Vec;
+    obstacleId?: string;
+    obstacleBounds?: Box;
+}
+export declare function getOrthogonalRoutePoints(start: RouteTerminal, end: RouteTerminal): Vec[];
+export {};