@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,40 @@
+import { type Signal, type SignalGraph } from "../signals/index";
+import type { ChangeSource, RecordsDiff, ScopedStoreRecord, StoreChange, StoreRecord, StoreScopeOf } from "./types";
+type StoreListener<TRecord extends StoreRecord> = (change: StoreChange<TRecord>) => void;
+export interface StoreOptions<TRecord extends StoreRecord> {
+    signals?: SignalGraph;
+    writeGuard?: (change: StoreChange<TRecord>) => void;
+}
+type ScopedRecord<TRecord extends StoreRecord> = Extract<TRecord, ScopedStoreRecord>;
+export declare class Store<TRecord extends StoreRecord = StoreRecord> {
+    readonly signals: SignalGraph;
+    private readonly records;
+    private activeTransaction;
+    private readonly recordAtoms;
+    private readonly revisionAtom;
+    private readonly draftRevisionAtom;
+    private readonly listeners;
+    private readonly writeGuard?;
+    constructor(initialRecords: TRecord[], options?: StoreOptions<TRecord>);
+    get(id: string): TRecord | undefined;
+    getRevision(): number;
+    getActiveTransactionRevision(): number | null;
+    getActiveTransactionDiff(): RecordsDiff<TRecord>;
+    getRecordSignal(id: string): Signal<TRecord | undefined>;
+    getAll(): TRecord[];
+    getByScope<TScope extends StoreScopeOf<ScopedRecord<TRecord>>>(scope: TScope): Array<Extract<ScopedRecord<TRecord>, {
+        scope: TScope;
+    }>>;
+    listen(listener: StoreListener<TRecord>): () => void;
+    atomic(fn: () => void, source?: ChangeSource): void;
+    put(records: TRecord[], source?: ChangeSource): void;
+    remove(ids: string[], source?: ChangeSource): void;
+    applyDiff<TChangeRecord extends TRecord>(diff: RecordsDiff<TChangeRecord>, source?: ChangeSource): void;
+    private stageRecord;
+    private getReadableRecords;
+    private requireActiveTransaction;
+    private bumpDraftRevision;
+    private restoreTransactionSignals;
+    private notifyListeners;
+}
+export {};

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

@@ -0,0 +1,27 @@
+export type ChangeSource = "user" | "system" | "history";
+export interface StoreRecord {
+    id: string;
+}
+export interface ScopedStoreRecord<TScope extends string = string> extends StoreRecord {
+    scope: TScope;
+}
+export type StoreScopeOf<TRecord> = TRecord extends {
+    scope: infer TScope extends string;
+} ? TScope : never;
+export interface StoreSnapshot<TRecord extends StoreRecord = StoreRecord, TSchemaVersion extends number = number> {
+    schemaVersion: TSchemaVersion;
+    records: TRecord[];
+}
+export interface RecordUpdate<TRecord extends StoreRecord = StoreRecord> {
+    before: TRecord;
+    after: TRecord;
+}
+export interface RecordsDiff<TRecord extends StoreRecord = StoreRecord> {
+    added: TRecord[];
+    updated: RecordUpdate<TRecord>[];
+    removed: TRecord[];
+}
+export interface StoreChange<TRecord extends StoreRecord = StoreRecord> {
+    source: ChangeSource;
+    diff: RecordsDiff<TRecord>;
+}

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

@@ -0,0 +1,28 @@
+import { type Editor, type ShapeColor, type ShapeId } from "./_vendor/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("./_vendor/canvas-extension-contracts/index").CanvasApiToken<ConnectorApi>;
+export declare function createConnectorPluginApi({ editor, }: {
+    editor: Editor;
+}): ConnectorApi;

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

@@ -0,0 +1,2 @@
+import { type CanvasRenderPlugin } from "./_vendor/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 "./_vendor/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 "./_vendor/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 "./_vendor/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 "./_vendor/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 "./_vendor/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 "./_vendor/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 "./_vendor/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,63 @@
+import { type Box, type Editor, type Mat, type CancelEditorEvent, type ShapeColor, type ShapeId, type TerminalBindingPortId, type Vec } from "./_vendor/canvas-core/index";
+import type { Signal } from "./_vendor/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("./_vendor/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-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 "./_vendor/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 "./_vendor/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 = 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-connector/editorRuntime.d.ts

@@ -0,0 +1,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode, type TerminalBindingPortId } from "./_vendor/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-connector/feature.d.ts

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

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

@@ -0,0 +1,9 @@
+import { Box, Vec } from "./_vendor/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/quickConnect.d.ts

@@ -0,0 +1,29 @@
+import { Vec, type CreateShapeInput, type Editor, type ResolvedShapeTerminalBindingPort, type ShapeId, type ShapeRecord } from "./_vendor/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["layers"]["getPageId"]>;
+}): 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 getBalancedConnectorBranchNodeInput(editor: Editor, source: ConnectorPortTarget, input: CreateShapeInput): CreateShapeInput;
+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,52 @@
+import { type BaseRecord, type BindingRecordBase, type CreateShapeInput, type Editor, type ShapeColor, type ShapeParentId, type ShapeRecord, type ShapeRecordBase, type TerminalBindingPortId, type Vec } from "./_vendor/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;
+    visiblePortIds?: readonly TerminalBindingPortId[];
+}
+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

@@ -0,0 +1,13 @@
+import { type ShapeColor } from "./_vendor/canvas-core/index";
+import type { DrawShapeRecord } from "./types";
+interface DrawShapeSvgProps {
+    shape: DrawShapeRecord;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+}
+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/_vendor/canvas-core/bindings/bindingManager.d.ts

@@ -0,0 +1,33 @@
+import type { ChangeSource } from "../../store/index";
+import { type BindingId, type BindingRecord, type ShapeId, type ShapeRecord } from "../schema/records";
+import type { Editor } from "../editor/editor";
+declare const SYNCHRONOUS_CALLBACK_ERROR = "Binding reaction scope callbacks must be synchronous";
+type SynchronousCallbackGuard<T> = T extends PromiseLike<unknown> ? [error: typeof SYNCHRONOUS_CALLBACK_ERROR] : [];
+export interface ShapeChangeEntry {
+    before: ShapeRecord;
+    after: ShapeRecord;
+}
+export declare class BindingManager {
+    private readonly editor;
+    private suppressedReactionIds;
+    constructor(editor: Editor);
+    getSuppressedReactionIds(): ReadonlySet<BindingId>;
+    runWithSuppressedReactions<T>(bindingIds: Iterable<BindingId>, callback: () => T, ..._synchronousCallbackGuard: SynchronousCallbackGuard<T>): T;
+    getConflictingBindings(binding: BindingRecord): BindingRecord[];
+    canBind(binding: BindingRecord): boolean;
+    syncCreatedBinding(binding: BindingRecord, source: ChangeSource): void;
+    syncUpdatedBinding(before: BindingRecord, after: BindingRecord, source: ChangeSource): void;
+    repairLoadedBindings(source: ChangeSource): void;
+    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource): void;
+    getShapeCompanionRootId(shapeId: ShapeId): ShapeId;
+    getShapeCompanionRootIds(shapeIds: readonly ShapeId[], bindings?: readonly BindingRecord[]): ReadonlyMap<ShapeId, ShapeId>;
+    getShapeCompanionMemberIds(shapeIds: readonly ShapeId[]): ShapeId[];
+    cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
+    cleanupBindings(ids: BindingId[], source: ChangeSource): void;
+    private applyEffect;
+    private syncShapeCompanionState;
+    private getShapeCompanionContext;
+    private getAllBindings;
+    private getExclusiveBindingKey;
+}
+export {};