@yuzhouu/canvas-kit 0.1.10 → 0.1.11

package/_vendor/plugin-builtin-clipboard/clipboardChromeContributions.d.ts

@@ -0,0 +1,2 @@
+import { type ChromeContribution } from "../canvas-plugin-sdk/index";
+export declare const clipboardChromeContributions: readonly ChromeContribution[];

package/{features/clipboard → _vendor/plugin-builtin-clipboard}/clipboardContextMenuContributions.d.ts

@@ -1,2 +1,2 @@
-import { type ContextMenuContribution } from "../../_vendor/canvas-plugin-sdk/index";
+import { type ContextMenuContribution } from "../canvas-plugin-sdk/index";
 export declare const clipboardContextMenuContributions: readonly ContextMenuContribution[];

package/{features/clipboard → _vendor/plugin-builtin-clipboard}/clipboardContribution.d.ts

@@ -1,6 +1,5 @@
-import { type CanvasAction } from "../../_vendor/canvas-plugin-sdk/index";
-import type { KeyboardShortcutInput } from "../../_vendor/canvas-core/index";
-import type { ProductServiceRegistry } from "../../core/runtime/productServices";
+import { type CanvasAction, type ProductServiceRegistry } from "../canvas-plugin-sdk/index";
+import type { KeyboardShortcutInput } from "../canvas-core/index";
 export declare const SYSTEM_CLIPBOARD_COPY_ACTION_ID = "system.clipboard.copy";
 export declare const SYSTEM_CLIPBOARD_CUT_ACTION_ID = "system.clipboard.cut";
 export declare const SYSTEM_CLIPBOARD_PASTE_ACTION_ID = "system.clipboard.paste";

package/{features/clipboard → _vendor/plugin-builtin-clipboard}/clipboardService.d.ts

@@ -1,10 +1,10 @@
-import type { EditorClipboardPayload } from "../../_vendor/canvas-core/index";
-import { type ProductServiceFactory, type ProductServiceRegistry } from "../../core/runtime/productServices";
+import type { EditorClipboardPayload } from "../canvas-core/index";
+import { type ProductServiceFactory, type ProductServiceRegistry } from "../canvas-plugin-sdk/index";
 export interface CanvasClipboardService {
     write(payload: EditorClipboardPayload): Promise<void>;
     read(): Promise<EditorClipboardPayload | null>;
     getMemoryPayload(): EditorClipboardPayload | null;
 }
-export declare const canvasClipboardServiceToken: import("../..").ProductServiceToken<CanvasClipboardService>;
+export declare const canvasClipboardServiceToken: import("../canvas-plugin-sdk/index").ProductServiceToken<CanvasClipboardService>;
 export declare function getCanvasClipboardService(services: ProductServiceRegistry): CanvasClipboardService | null;
 export declare function memoryCanvasClipboardService(): ProductServiceFactory<CanvasClipboardService>;

package/_vendor/plugin-builtin-clipboard/index.d.ts

@@ -0,0 +1,3 @@
+export { ClipboardPlugin } from "./plugin";
+export * from "./clipboardContribution";
+export * from "./clipboardService";

package/_vendor/plugin-builtin-clipboard/plugin.d.ts

@@ -0,0 +1 @@
+export declare const ClipboardPlugin: import("../canvas-plugin-sdk/index").CanvasPlugin<(context: import("../canvas-plugin-sdk/index").CanvasPluginSetupContext<import("../canvas-plugin-sdk/index").CanvasPluginApiContext>) => void>;

package/_vendor/plugin-builtin-export/blobDataUrl.d.ts

@@ -0,0 +1 @@
+export declare function readBlobAsDataUrl(blob: Blob): Promise<string | null>;

package/_vendor/plugin-builtin-export/canvasExportApi.d.ts

@@ -0,0 +1,43 @@
+import type { Editor, ShapeId, ThemeColorResolver } from "../canvas-core/index";
+import { type CanvasExportArtifact, type CanvasExportContribution, type CanvasExportFormat, type CanvasExportRegistry } from "../canvas-plugin-sdk/index";
+import { type PngExportResult } from "./pngExport";
+import { type SvgAssetInliner, type SvgExportResult } from "./svgExport";
+export type CanvasExportTarget = {
+    scope: "page" | "selection";
+    shapeIds?: never;
+} | {
+    scope?: never;
+    shapeIds: readonly ShapeId[];
+};
+export interface CanvasExportAppearance {
+    readonly resolveThemeColor?: ThemeColorResolver;
+}
+export type CanvasSvgExportInput = CanvasExportTarget & {
+    appearance?: CanvasExportAppearance;
+    padding?: number;
+};
+export type CanvasPngExportInput = CanvasSvgExportInput & {
+    background?: string;
+    pixelRatio?: number;
+};
+export type CanvasGenericExportInput = CanvasExportTarget & {
+    format: string;
+    options?: unknown;
+};
+export interface CanvasExportApi {
+    getFormats(): readonly CanvasExportFormat[];
+    export(input: CanvasGenericExportInput): Promise<CanvasExportArtifact>;
+    exportPng(input: CanvasPngExportInput): Promise<PngExportResult>;
+    exportSvg(input: CanvasSvgExportInput): Promise<SvgExportResult>;
+}
+export declare const canvasExportApiToken: import("../canvas-plugin-sdk/index").ProductApiToken<CanvasExportApi>;
+export declare function createCanvasExportApi({ editor, exportRegistry, }: {
+    editor: Editor;
+    exportRegistry: CanvasExportRegistry;
+}): CanvasExportApi;
+export declare function createSvgExportContribution({ assetInliners, }: {
+    assetInliners: readonly SvgAssetInliner[];
+}): CanvasExportContribution;
+export declare function createPngExportContribution({ assetInliners, }: {
+    assetInliners: readonly SvgAssetInliner[];
+}): CanvasExportContribution;

package/_vendor/plugin-builtin-export/index.d.ts

@@ -0,0 +1,8 @@
+export { readBlobAsDataUrl } from "./blobDataUrl";
+export { canvasExportApiToken, createCanvasExportApi, createPngExportContribution, createSvgExportContribution, } from "./canvasExportApi";
+export type { CanvasExportAppearance, CanvasExportApi, CanvasGenericExportInput, CanvasExportTarget, CanvasPngExportInput, CanvasSvgExportInput, } from "./canvasExportApi";
+export { exportEditorPng, } from "./pngExport";
+export type { PngExportOptions, PngExportResult, } from "./pngExport";
+export { createBuiltinCanvasExportPlugin } from "./plugin";
+export { exportEditorSvg, } from "./svgExport";
+export type { ExportStatus, SvgAssetInliner, SvgExportOptions, SvgExportResult, } from "./svgExport";

package/_vendor/plugin-builtin-export/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { SvgAssetInliner } from "./svgExport";
+import { type CanvasPlugin } from "../canvas-plugin-sdk/index";
+export declare function createBuiltinCanvasExportPlugin({ svgAssetInliners, }: {
+    svgAssetInliners: SvgAssetInliner[];
+}): CanvasPlugin;

package/_vendor/plugin-builtin-export/pngExport.d.ts

@@ -0,0 +1,15 @@
+import type { ShapeId, SvgExportSkippedShape } from "../canvas-core/index";
+import { type ExportStatus, type SvgExportOptions } from "./svgExport";
+export interface PngExportOptions extends SvgExportOptions {
+    background?: string;
+    pixelRatio?: number;
+}
+export interface PngExportResult {
+    status: ExportStatus;
+    blob: Blob | null;
+    width: number | null;
+    height: number | null;
+    exportedShapeIds: readonly ShapeId[];
+    skippedShapes: readonly SvgExportSkippedShape[];
+}
+export declare function exportEditorPng({ background, pixelRatio, ...svgOptions }: PngExportOptions): Promise<PngExportResult>;

package/{features/export → _vendor/plugin-builtin-export}/svgExport.d.ts

@@ -1,7 +1,12 @@
-import type { Editor, ExportIntegrityReport, ShapeCapabilityManifest, ShapeId, SvgExportSkippedShape, SvgThemeColorResolver } from "../../_vendor/canvas-core/index";
+import type { Editor, ExportIntegrityReport, ShapeCapabilityManifest, ShapeId, ShapeRecord, SvgExportSkippedShape, ThemeColorResolver } from "../canvas-core/index";
 export interface SvgAssetInliner {
+    prepare?(input: {
+        editor: Editor;
+        requestedShapeIds: readonly ShapeId[];
+    }): Promise<void>;
     inline(input: {
         editor: Editor;
+        exportedShapes: readonly ShapeRecord[];
         exportedShapeIds: readonly ShapeId[];
         svg: string;
     }): Promise<string>;
@@ -16,6 +21,8 @@ export type ExportStatus = {
 export interface SvgExportResult {
     status: ExportStatus;
     svg: string | null;
+    width: number | null;
+    height: number | null;
     exportedShapeIds: readonly ShapeId[];
     skippedShapes: readonly SvgExportSkippedShape[];
 }
@@ -23,7 +30,7 @@ export interface SvgExportOptions {
     assetInliners?: readonly SvgAssetInliner[];
     editor: Editor;
     padding?: number;
-    resolveThemeColor?: SvgThemeColorResolver;
+    resolveThemeColor?: ThemeColorResolver;
     shapeIds: readonly ShapeId[];
 }
 export declare function exportEditorSvg({ assetInliners, editor, padding, resolveThemeColor, shapeIds, }: SvgExportOptions): Promise<SvgExportResult>;

package/_vendor/plugin-builtin-import-host/CanvasImportHost.d.ts

@@ -0,0 +1,3 @@
+import type { CanvasImportPreview, CanvasPluginComponentProps } from "../canvas-plugin-sdk/index";
+export declare function CanvasImportHost({ editor, getHostElement, imports, }: CanvasPluginComponentProps): null;
+export declare function getImportPreview(dataTransfer: DataTransfer | null): CanvasImportPreview;

package/_vendor/plugin-builtin-import-host/capability.d.ts

@@ -0,0 +1 @@
+export declare const canvasImportHostCapability: import("../canvas-plugin-sdk/index").CanvasPluginValueToken<boolean>;

package/_vendor/plugin-builtin-import-host/index.d.ts

@@ -0,0 +1,2 @@
+export { canvasImportHostCapability } from "./capability";
+export { ImportHostPlugin } from "./plugin";

package/_vendor/plugin-builtin-import-host/plugin.d.ts

@@ -0,0 +1 @@
+export declare const ImportHostPlugin: import("../canvas-plugin-sdk/index").CanvasPlugin<(context: import("../canvas-plugin-sdk/index").CanvasPluginSetupContext<import("../canvas-plugin-sdk/index").CanvasPluginApiContext>) => void>;

package/_vendor/plugin-builtin-tool-actions/capability.d.ts

@@ -0,0 +1 @@
+export declare const canvasToolActionsCapability: import("../canvas-plugin-sdk/index").CanvasPluginValueToken<true>;

package/_vendor/plugin-builtin-tool-actions/index.d.ts

@@ -0,0 +1,2 @@
+export { canvasToolActionsCapability } from "./capability";
+export { BuiltinToolActionsPlugin } from "./plugin";

package/_vendor/plugin-builtin-tool-actions/plugin.d.ts

@@ -0,0 +1 @@
+export declare const BuiltinToolActionsPlugin: import("../canvas-plugin-sdk/index").CanvasPlugin<(context: import("../canvas-plugin-sdk/index").CanvasPluginSetupContext<import("../canvas-plugin-sdk/index").CanvasPluginApiContext>) => void>;

package/_vendor/plugin-builtin-tool-actions/toolActions.d.ts

@@ -0,0 +1,2 @@
+import { type CanvasAction } from "../canvas-plugin-sdk/index";
+export declare const toolActions: readonly CanvasAction[];

package/_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-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-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-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;