@yuzhouu/canvas-kit 0.1.9 → 0.1.11

package/_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-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-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-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-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-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-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-connector/connectorRuntime.d.ts

@@ -0,0 +1,62 @@
+import { type Box, type Editor, type Mat, type CancelEditorEvent, type ShapeColor, type ShapeId, 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): void;
+    cancel(reason?: CancelEditorEvent["reason"]): void;
+}
+export interface ConnectorRuntime {
+    readonly previewSignal: Signal<ConnectorInteractionPreview | null>;
+    readonly quickCreateNodeFactory: ConnectorQuickCreateNodeFactory;
+    readonly selectionHandlesHiddenSignal: Signal<boolean>;
+    readonly pointerSession: ConnectorPointerSession | null;
+    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): ConnectorRuntime;
+export declare function getConnectorRuntime(editor: Editor): ConnectorRuntime;
+export {};

package/_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-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-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 = 4;
+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-connector/editorRuntime.d.ts

@@ -0,0 +1,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } 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): EditorPlugin;

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

@@ -0,0 +1,4 @@
+import { setupConnectorProduct } from "./productRuntime";
+import type { ConnectorPluginOptions } from "./types";
+export declare function createConnectorPlugin(options?: ConnectorPluginOptions): import("../canvas-plugin-sdk/index").CanvasPlugin<typeof setupConnectorProduct>;
+export declare const Connector: import("../canvas-plugin-sdk/index").CanvasPlugin<typeof setupConnectorProduct>;

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

@@ -0,0 +1,18 @@
+export { Connector, createConnectorPlugin } from "./feature";
+export { ConnectorShapeUtil } from "./connectorShapeUtil";
+export { ConnectorBindingUtil } from "./connectorBindingUtil";
+export { ConnectorTool } from "./connectorTool";
+export { ConnectorShapeSvgExporter, createConnectorEditorPlugin, } from "./editorRuntime";
+export { setupConnectorProduct } from "./productRuntime";
+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, getConnectorVisualPortPoint, getNearestConnectorPortAtPoint, quickConnectFromPort, } 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-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 {};

package/_vendor/plugin-connector/productRuntime.d.ts

@@ -0,0 +1,2 @@
+import { type CanvasPluginSetupContext } from "../canvas-plugin-sdk/index";
+export declare function setupConnectorProduct(context: CanvasPluginSetupContext): void;

package/_vendor/plugin-connector/quickConnect.d.ts

@@ -0,0 +1,28 @@
+import { Vec, type CreateShapeInput, type Editor, type ResolvedShapeTerminalBindingPort, type ShapeId, type ShapeRecord } from "../canvas-core/index";
+import { type ConnectorQuickCreateNodeFactory, type ConnectorShapeProps } from "./types";
+export interface ConnectorPortTarget {
+    shape: ShapeRecord;
+    port: ResolvedShapeTerminalBindingPort;
+}
+export type ConnectorQuickConnectPlan = {
+    kind: "connect";
+    target: ConnectorPortTarget;
+} | {
+    kind: "create";
+    nodeInput: CreateShapeInput;
+    previewShape: ShapeRecord;
+    targetPort: ResolvedShapeTerminalBindingPort;
+};
+export declare function getConnectorVisualPortPoint(port: ResolvedShapeTerminalBindingPort, zoom: number): Vec;
+export declare function getConnectorPortHitDistance(port: ResolvedShapeTerminalBindingPort, pagePoint: Vec, zoom: number): number;
+export declare function getNearestConnectorPortAtPoint(editor: Editor, pagePoint: Vec, options?: {
+    allowInteriorShapeId?: ShapeId;
+    excludeShapeIds?: ReadonlySet<ShapeId>;
+    mode?: "source" | "target";
+    pageId?: ReturnType<Editor["getShapePageId"]>;
+}): ConnectorPortTarget | null;
+export declare function quickConnectFromPort(editor: Editor, source: ConnectorPortTarget, factory: ConnectorQuickCreateNodeFactory, props: ConnectorShapeProps): boolean;
+export declare function getConnectorQuickConnectPlan(editor: Editor, source: ConnectorPortTarget, factory: ConnectorQuickCreateNodeFactory): ConnectorQuickConnectPlan | null;
+export declare function findQuickConnectTargets(editor: Editor, source: ConnectorPortTarget): ConnectorPortTarget[];
+export declare function chooseFacingPort(editor: Editor, shape: ShapeRecord, sourcePagePoint: Vec): ResolvedShapeTerminalBindingPort | null;
+export declare function createDefaultConnectorQuickCreateNodeFactory(): ConnectorQuickCreateNodeFactory;

package/_vendor/plugin-connector/types.d.ts

@@ -0,0 +1,51 @@
+import { type BaseRecord, type BindingRecordBase, type CreateShapeInput, type Editor, type ShapeColor, type ShapeParentId, type ShapeRecord, type ShapeRecordBase, type Vec } from "../canvas-core/index";
+export interface ConnectorPoint {
+    x: number;
+    y: number;
+}
+export type ConnectorTerminal = "start" | "end";
+export type ConnectorRouting = "straight" | "orthogonal" | "curved";
+export type ConnectorStrokeStyle = "solid" | "dashed";
+export type ConnectorHead = "none" | "arrow";
+export interface ConnectorShapeProps {
+    w: number;
+    h: number;
+    start: ConnectorPoint;
+    end: ConnectorPoint;
+    routing: ConnectorRouting;
+    stroke: ShapeColor;
+    strokeWidth: number;
+    strokeStyle: ConnectorStrokeStyle;
+    headStart: ConnectorHead;
+    headEnd: ConnectorHead;
+    cornerRadius: number;
+    curveWaypoints: ConnectorPoint[];
+    orthogonalBends: ConnectorPoint[];
+}
+export interface ConnectorShapeRecord extends ShapeRecordBase<"connector", ConnectorShapeProps> {
+    type: "connector";
+    props: ConnectorShapeProps;
+}
+export interface ConnectorBindingProps {
+    terminal: ConnectorTerminal;
+    portId: string;
+    normalizedAnchor?: ConnectorPoint;
+}
+export interface ConnectorBindingRecord extends BindingRecordBase<"connector", ConnectorBindingProps> {
+    type: "connector";
+    props: ConnectorBindingProps;
+}
+export interface ConnectorQuickCreateNodeFactory {
+    createNode(input: {
+        editor: Editor;
+        sourceShape: ShapeRecord;
+        sourcePortId: string;
+        pageCenter: Vec;
+        parentId: ShapeParentId;
+    }): CreateShapeInput;
+}
+export interface ConnectorPluginOptions {
+    quickCreateNodeFactory?: ConnectorQuickCreateNodeFactory;
+}
+export declare function isConnectorShapeRecord(record: BaseRecord | null | undefined): record is ConnectorShapeRecord;
+export declare function isConnectorBindingRecord(record: BaseRecord | null | undefined): record is ConnectorBindingRecord;

package/_vendor/plugin-draw/DrawShapeRenderer.d.ts

@@ -2,9 +2,12 @@ import { type ShapeColor } from "../canvas-core/index";
 import type { DrawShapeRecord } from "./types";
 interface DrawShapeSvgProps {
     shape: DrawShapeRecord;
-    isHovered?: boolean;
     stroke?: ShapeColor;
     strokeWidth?: number;
 }
-export declare function DrawShapeSvg({ shape, isHovered, stroke, strokeWidth, }: DrawShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DrawShapeSvg({ shape, stroke, strokeWidth, }: DrawShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DrawShapeHoverSvg({ shape, strokeWidth, }: {
+    shape: DrawShapeRecord;
+    strokeWidth: number;
+}): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/_vendor/plugin-draw/canvasRender.d.ts

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

package/_vendor/plugin-draw/drawGeometry.d.ts

@@ -6,7 +6,6 @@ export { getDrawPointGeometry, getDrawSegmentGeometry };
 export type { DrawShapeGeometry, DrawShapeSamplingStats, } from "./drawShapeGeometry";
 type DrawLocalGeometryCacheKey = Pick<DrawShapeRecord, "props">;
 type DrawPositionedGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "props">;
-type DrawPageGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "rotation" | "scaleX" | "scaleY" | "props">;
 export interface DrawShapeDiagnostics extends DrawShapeSamplingStats {
     hasPath: boolean;
     hasSelectionPath: boolean;
@@ -29,15 +28,13 @@ export interface NormalizedDrawShape {
 export declare function getDrawShapeLocalGeometry(shape: DrawLocalGeometryCacheKey): DrawShapeGeometry;
 export declare function normalizeDrawShapeFromSegmentSet(segments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
 export declare function normalizeDrawShapeFromPointSet(points: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
-export declare function normalizeDrawShapeFromPagePoints(pagePoints: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
-export declare function normalizeDrawShapeFromPageSegments(pageSegments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPoints(pagePoints: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromSegments(pageSegments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
 export declare function getDrawShapePositionedSegments(shape: Pick<DrawShapeRecord, "x" | "y" | "props">): DrawShapeSegment[];
 export declare function getDrawShapePositionedPoints(shape: Pick<DrawShapeRecord, "x" | "y" | "props">): DrawShapePoint[];
 export declare function getDrawShapePositionedGeometry(shape: DrawPositionedGeometryCacheKey): DrawShapeGeometry;
-export declare function getDrawShapePagePoints(shape: DrawShapeRecord): DrawShapePoint[];
-export declare function getDrawShapePageSegments(shape: DrawShapeRecord): DrawShapeSegment[];
-export declare function normalizeTransformedDrawShape(shape: DrawShapeRecord): NormalizedDrawShape;
-export declare function getDrawShapePageGeometry(shape: DrawPageGeometryCacheKey): DrawShapeGeometry;
+export declare function getDrawShapeParentPoints(shape: DrawShapeRecord): DrawShapePoint[];
+export declare function getDrawShapeParentSegments(shape: DrawShapeRecord): DrawShapeSegment[];
 export declare function resizeDrawShapeToSelectionBounds(shape: DrawShapeRecord, input: DrawSelectionResizeInput): NormalizedDrawShape;
 export declare function flipDrawShapeInSelectionBounds(shape: DrawShapeRecord, input: DrawSelectionFlipInput): NormalizedDrawShape;
 export declare function resizeDrawShapeToPageBounds(shape: Pick<DrawShapeRecord, "x" | "y" | "props">, nextPageBounds: Box): NormalizedDrawShape;

package/_vendor/plugin-draw/drawPath.d.ts

@@ -13,6 +13,10 @@ export interface DrawInputPointGuardOptions {
     hardMaxPointCount: number;
     maxDistanceMultiplier: number;
 }
+export interface DrawInputPointGuardState {
+    anchorPoint: DrawShapePoint;
+    hasProvisionalPoint: boolean;
+}
 export interface DrawPointSamplingResult {
     points: DrawShapePoint[];
     rawPointCount: number;
@@ -29,7 +33,9 @@ export declare function cloneDrawSegment(segment: DrawShapeSegment): DrawShapeSe
 export declare function getFlattenedDrawSegmentPoints(segments: readonly DrawShapeSegment[]): DrawShapePoint[];
 export declare function getDrawSegmentsFromPoints(points: readonly DrawShapePoint[]): DrawShapeSegment[];
 export declare function getDrawInputPointGuardOptions(strokeWidth: number, isPen: boolean): DrawInputPointGuardOptions;
-export declare function appendGuardedDrawPoint(points: DrawShapePoint[], point: DrawShapePoint, options: DrawInputPointGuardOptions): void;
+export declare function appendGuardedDrawPoint(points: DrawShapePoint[], point: DrawShapePoint, options: DrawInputPointGuardOptions, state: DrawInputPointGuardState, appendOptions?: {
+    force?: boolean;
+}): DrawInputPointGuardState;
 export declare function sampleDrawPoints(points: readonly DrawShapePoint[], options: DrawPointSamplingOptions): DrawPointSamplingResult;
 export declare function getDrawCenterlinePathFromPoints(points: readonly DrawShapePoint[]): string | null;
 export declare function getClosedDrawCenterlinePathFromPoints(points: readonly DrawShapePoint[]): string | null;

package/_vendor/plugin-draw/drawShapeUtil.d.ts

@@ -4,7 +4,7 @@ export declare class DrawShapeUtil extends ShapeUtil<DrawShapeRecord> {
     readonly type: "draw";
     getDefaultProps(): DrawShapeProps;
     validateProps(props: unknown): DrawShapeProps;
-    getBounds(shape: DrawShapeRecord): Box;
+    getPositionedBounds(shape: DrawShapeRecord): Box;
     getLocalBounds(shape: DrawShapeRecord): Box;
     getRenderBounds(shape: DrawShapeRecord): Box;
     getExportBounds(shape: DrawShapeRecord): Box;
@@ -18,5 +18,5 @@ export declare class DrawShapeUtil extends ShapeUtil<DrawShapeRecord> {
     getPositionedOutlineVertices(shape: DrawShapeRecord): Vec[];
     hitTest(shape: DrawShapeRecord, positionedPoint: Vec): boolean;
     hitTestLineSegment(shape: DrawShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
-    repairLoadedShape(shape: DrawShapeRecord): DrawShapeRecord | null;
+    repairLoadedShape(_shape: DrawShapeRecord): DrawShapeRecord | null;
 }

package/_vendor/plugin-draw/editorRuntime.d.ts

@@ -1,7 +1,7 @@
-import { type LandEditorRuntimePlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
-import { type DrawShapeRecord } from "./types";
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { DrawShapeRecord } from "./types";
 export declare class DrawShapeSvgExporter implements ShapeSvgExporter<DrawShapeRecord> {
     readonly type: "draw";
     toSvg(shape: DrawShapeRecord, context: SvgExportContext): SvgNode | null;
 }
-export declare function createDrawEditorRuntimePlugin(): LandEditorRuntimePlugin;
+export declare function createDrawEditorPlugin(): EditorPlugin;

package/_vendor/plugin-draw/feature.d.ts

@@ -1,3 +1,2 @@
-import { type LandFeatureBundle } from "../canvas-react/host/index";
-export declare function createDrawFeatureBundle(): LandFeatureBundle;
-export declare const Draw: import("../canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>;
+import { setupDrawProduct } from "./productRuntime";
+export declare const Draw: import("../canvas-plugin-sdk/index").CanvasPlugin<typeof setupDrawProduct>;

package/_vendor/plugin-draw/index.d.ts

@@ -1,10 +1,11 @@
 export { DrawTool } from "./drawTool";
 export { DrawShapeUtil } from "./drawShapeUtil";
-export { DrawShapeSvgExporter, createDrawEditorRuntimePlugin } from "./editorRuntime";
+export { DrawShapeSvgExporter, createDrawEditorPlugin } from "./editorRuntime";
+export { setupDrawProduct } from "./productRuntime";
 export { DrawShapeSvg } from "./DrawShapeRenderer";
 export { createDrawCanvasRenderPlugin } from "./canvasRender";
-export { Draw, createDrawFeatureBundle } from "./feature";
-export { flipDrawShapeInSelectionBounds, getDrawShapeDiagnostics, getDrawShapePageSegments, getDrawShapePagePoints, normalizeTransformedDrawShape, } from "./drawGeometry";
+export { Draw } from "./feature";
+export { flipDrawShapeInSelectionBounds, getDrawShapeDiagnostics, getDrawShapeParentSegments, getDrawShapeParentPoints, } from "./drawGeometry";
 export { interpolateDrawShapeRecords } from "./drawInterpolation";
 export type { DrawShapePoint, DrawShapeProps, DrawShapeRecord, DrawShapeSegment, } from "./types";
 export { isDrawShapeRecord } from "./types";

package/_vendor/plugin-draw/productRuntime.d.ts

@@ -0,0 +1,2 @@
+import { type CanvasPluginSetupContext } from "../canvas-plugin-sdk/index";
+export declare function setupDrawProduct(context: CanvasPluginSetupContext): void;

package/_vendor/plugin-eraser/canvasRender.d.ts

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

package/_vendor/plugin-eraser/editorRuntime.d.ts

@@ -1,2 +1,2 @@
-import { type LandEditorRuntimePlugin } from "../canvas-core/index";
-export declare function createEraserEditorRuntimePlugin(): LandEditorRuntimePlugin;
+import type { EditorPlugin } from "../canvas-core/index";
+export declare function createEraserEditorPlugin(): EditorPlugin;

package/_vendor/plugin-eraser/eraserRuntime.d.ts

@@ -0,0 +1,12 @@
+import { type Editor, type ShapeId, type Vec } from "../canvas-core/index";
+import { type Signal } from "../signals/index";
+export interface EraserRuntime {
+    readonly erasingShapeIdsSignal: Signal<readonly ShapeId[]>;
+    readonly trailSignal: Signal<readonly Vec[]>;
+    readonly trailActiveSignal: Signal<boolean>;
+    setPreview(shapeIds: readonly ShapeId[], trail: readonly Vec[]): void;
+    clear(): void;
+}
+export declare const eraserRuntimeToken: import("../canvas-core/index").EditorRuntimeToken<EraserRuntime>;
+export declare function createEraserRuntime(editor: Editor): EraserRuntime;
+export declare function getEraserRuntime(editor: Editor): EraserRuntime;

package/_vendor/plugin-eraser/feature.d.ts

@@ -1,3 +1,2 @@
-import { type LandFeatureBundle } from "../canvas-react/host/index";
-export declare function createEraserFeatureBundle(): LandFeatureBundle;
-export declare const Eraser: import("../canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>;
+import { setupEraserProduct } from "./productRuntime";
+export declare const Eraser: import("../canvas-plugin-sdk/index").CanvasPlugin<typeof setupEraserProduct>;

package/_vendor/plugin-eraser/index.d.ts

@@ -1,4 +1,6 @@
 export { EraserTool } from "./eraserTool";
 export { createEraserCanvasRenderPlugin } from "./canvasRender";
-export { createEraserEditorRuntimePlugin } from "./editorRuntime";
-export { Eraser, createEraserFeatureBundle } from "./feature";
+export { createEraserEditorPlugin } from "./editorRuntime";
+export { setupEraserProduct } from "./productRuntime";
+export { getEraserRuntime } from "./eraserRuntime";
+export { Eraser } from "./feature";

package/_vendor/plugin-eraser/productRuntime.d.ts

@@ -0,0 +1,2 @@
+import { type CanvasPluginSetupContext } from "../canvas-plugin-sdk/index";
+export declare function setupEraserProduct(context: CanvasPluginSetupContext): void;