@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,29 @@
+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["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-flow/_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 "../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-flow/_vendor/plugin-geo/api.d.ts

@@ -0,0 +1,43 @@
+import type { Editor, ShapeColor, ShapeId } from "../canvas-core/index";
+import { type CanvasShapeRef } from "../canvas-extension-contracts/index";
+import { type GeoShapeKind, type GeoShapeProps } from "./types";
+export interface GeoCreateInput {
+    kind: GeoShapeKind;
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeStyle?: GeoShapeProps["strokeStyle"];
+    strokeWidth?: number;
+    cornerRadiusPercent?: number;
+    meta?: Record<string, unknown>;
+}
+export interface GeoStylePatch {
+    kind?: GeoShapeKind;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeStyle?: GeoShapeProps["strokeStyle"];
+    strokeWidth?: number;
+    cornerRadiusPercent?: number;
+}
+export interface GeoSelectionStyle {
+    readonly kind: GeoShapeKind | null;
+    readonly fill: ShapeColor | null;
+    readonly stroke: ShapeColor | null;
+    readonly strokeStyle: GeoShapeProps["strokeStyle"] | null;
+    readonly strokeWidth: number | null;
+    readonly cornerRadiusPercent: number | null;
+}
+export interface GeoApi {
+    create(input: GeoCreateInput): CanvasShapeRef<"geo"> | null;
+    getSelectionStyle(): GeoSelectionStyle | null;
+    setSelectionStyle(patch: GeoStylePatch): readonly ShapeId[];
+    getToolDefaults(): GeoShapeProps;
+    setToolDefaults(patch: GeoStylePatch): GeoShapeProps;
+}
+export declare const geoApiToken: import("../canvas-extension-contracts/index").CanvasApiToken<GeoApi>;
+export declare function createGeoPluginApi({ editor, }: {
+    editor: Editor;
+}): GeoApi;

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

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

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

@@ -0,0 +1,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { GeoShapeRecord } from "./types";
+export declare class GeoShapeSvgExporter implements ShapeSvgExporter<GeoShapeRecord> {
+    readonly type: "geo";
+    toSvg(shape: GeoShapeRecord, context: SvgExportContext): SvgNode;
+}
+export declare function createGeoEditorPlugin(): EditorPlugin;

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

@@ -0,0 +1 @@
+export declare const Geo: import("../canvas-extension-contracts/index").CanvasPlugin<import("./api").GeoApi>;

package/_vendor/plugin-flow/_vendor/plugin-geo/geoCreationRuntime.d.ts

@@ -0,0 +1,20 @@
+import { Box, type Editor, type ReadonlyValue, type Vec } from "../canvas-core/index";
+import { type GeoShapeProps } from "./types";
+interface GeoHoverSample {
+    pagePoint: Vec;
+    timestamp: number;
+}
+export interface GeoCreationPreview {
+    bounds: Box;
+    props: GeoShapeProps;
+}
+export interface GeoCreationRuntime {
+    readonly preview: ReadonlyValue<GeoCreationPreview | null>;
+    setHover(sample: GeoHoverSample): void;
+    clearHover(): void;
+}
+export declare const geoCreationRuntimeToken: import("../canvas-core/index").EditorRuntimeToken<GeoCreationRuntime>;
+export declare function createGeoCreationRuntime(editor: Editor): GeoCreationRuntime;
+export declare function getGeoCreationRuntime(editor: Editor): GeoCreationRuntime;
+export declare function getGeoDefaultBoundsAtTopLeft(topLeft: Vec, props: GeoShapeProps): Box;
+export {};

package/_vendor/plugin-flow/_vendor/plugin-geo/geoGeometry.d.ts

@@ -0,0 +1,64 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { GeoShapeKind } from "./types";
+export declare const GEO_ELLIPSE_SEGMENTS = 32;
+export declare const GEO_RECTANGLE_DEFAULT_CORNER_RADIUS_PERCENT = 12;
+export declare const GEO_RECTANGLE_MAX_CORNER_RADIUS_PERCENT = 50;
+export declare const GEO_RECTANGLE_CORNER_SEGMENTS = 4;
+export type GeoVisualGeometry = {
+    tag: "ellipse";
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+} | {
+    tag: "path";
+    d: string;
+    transform?: string;
+    fill?: "none";
+    vectorEffect?: "non-scaling-stroke";
+} | {
+    tag: "polygon";
+    points: Vec[];
+} | {
+    tag: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number;
+    ry: number;
+};
+export declare const GEO_BURST_PATH = "m19.8415 12.945 1.827 1.428h-2.26a1 1 0 0 0-.972 1.232l.676 2.828-2.462-2.204a1 1 0 0 0-1.66.624l-.386 3.152-1.548-2.838c-.417-.765-1.545-.668-1.825.158l-1.064 3.138-.215-2.358a1 1 0 0 0-1.535-.751l-1.482.95.437-1.803a1 1 0 0 0-1.099-1.228l-2.962.38 1.446-1.17a1 1 0 0 0 .036-1.525L2.1425 10.6l3.088-.791a1 1 0 0 0 .534-1.592l-2-2.513L7.7425 7.879a1 1 0 0 0 1.434-.578l.775-2.464 1.377 2.067a1 1 0 0 0 1.635.042l2.539-3.41-.115 2.574a1 1 0 0 0 1.16 1.031l2.59-.42-.804 1.34a1 1 0 0 0 .67 1.496l2.853.544-1.93 1.207a1 1 0 0 0-.085 1.636Z";
+export declare const GEO_TRAPEZOID_PATH = "M3.383 17.776A1.1 1.1 0 0 0 4.46 19.1h15.08a1.1 1.1 0 0 0 1.077-1.324l-2.5-12A1.1 1.1 0 0 0 17.04 4.9H6.96a1.1 1.1 0 0 0-1.077.876z";
+export declare const GEO_SUMMARY_PATH = "M16 15a3.2 3.2 0 0 0-1.618-2.783L14 12l.382-.217C15.382 11.213 16 10.15 16 9V7a4 4 0 0 1 4-4M16 15v2a4 4 0 0 0 4 4";
+export declare const GEO_SUMMARY_LEFT_PATH = "M7 15c0-1.151.618-2.214 1.618-2.783L9 12l-.382-.217A3.2 3.2 0 0 1 7 9V7a4 4 0 0 0-4-4M7 15v2a4 4 0 0 1-4 4";
+export declare const GEO_ARROW_LEFT_PATH = "M12.444 6.416v.9h8.265a.1.1 0 0 1 .1.1v8.455a.1.1 0 0 1-.1.1h-8.265v4.314c0 .034-.008.048-.014.056a.1.1 0 0 1-.047.036.1.1 0 0 1-.058.009c-.01-.002-.025-.005-.05-.029l-9.053-8.641a.1.1 0 0 1 0-.145l9.053-8.641c.025-.024.04-.028.05-.03a.1.1 0 0 1 .058.01.1.1 0 0 1 .047.036c.006.008.014.022.014.056z";
+export declare const GEO_ARROW_RIGHT_PATH = "M10.656 7.316h.9V3.002c0-.034.008-.048.014-.056a.1.1 0 0 1 .046-.036.1.1 0 0 1 .059-.01c.01.002.025.006.05.03l9.053 8.641a.1.1 0 0 1 0 .145l-9.053 8.641c-.025.024-.04.027-.05.029a.1.1 0 0 1-.059-.01.1.1 0 0 1-.046-.035c-.006-.008-.014-.022-.014-.056V15.97H3.29a.1.1 0 0 1-.1-.1V7.416a.1.1 0 0 1 .1-.1z";
+export declare function getGeoInteractionOutlinePoints(bounds: Box, kind: GeoShapeKind, options?: {
+    cornerRadiusPercent?: unknown;
+}): Vec[];
+export declare function getGeoEllipsePoints(bounds: Box, segments?: number): Vec[];
+export declare function normalizeGeoRectangleCornerRadiusPercent(value: unknown, fallback?: number): number;
+export declare function getGeoRectangleCornerRadius({ cornerRadiusPercent, h, w, }: {
+    cornerRadiusPercent?: unknown;
+    h: number;
+    w: number;
+}): number;
+export declare function getGeoRoundedRectanglePoints(bounds: Box, radius?: number, segments?: number): Vec[];
+export declare function getGeoMessageCirclePath(bounds: Box): string;
+export declare function getGeoSourcePathTransform(bounds: Box): string;
+export declare function getGeoBurstPathTransform(bounds: Box): string;
+export declare function getGeoSummaryPathTransform(bounds: Box, side: "left" | "right"): string;
+export declare function resolveGeoVisualGeometry(bounds: Box, kind: GeoShapeKind, options?: {
+    cornerRadiusPercent?: unknown;
+}): GeoVisualGeometry;
+export declare function getGeoHorizontalArrowGeometry(bounds: Box, direction: "left" | "right"): {
+    outline: Vec[];
+    path: string;
+};
+export declare function getGeoHorizontalArrowWidthForSelectionWidth({ direction, height, selectionWidth, }: {
+    direction: "left" | "right";
+    height: number;
+    selectionWidth: number;
+}): number;
+export declare function isPointInPolygon(point: Vec, points: readonly Vec[]): boolean;

package/_vendor/plugin-flow/_vendor/plugin-geo/geoShapeUtil.d.ts

@@ -0,0 +1,16 @@
+import { Box, ShapeUtil, Vec, type ShapeBindingPointInput, type ShapeHandleSnapGeometry, type ShapeLineSegmentHitTestInput, type ShapeSelectionResizeInput, type ShapeUpdate } from "../canvas-core/index";
+import type { GeoShapeProps, GeoShapeRecord } from "./types";
+export declare class GeoShapeUtil extends ShapeUtil<GeoShapeRecord> {
+    readonly type: "geo";
+    getDefaultProps(): GeoShapeProps;
+    validateProps(props: unknown): GeoShapeProps;
+    getLocalBounds(shape: GeoShapeRecord): Box;
+    canReceiveTerminalBinding(_shape: GeoShapeRecord): boolean;
+    getPositionedOutlineVertices(shape: GeoShapeRecord): Vec[];
+    getSelectionResizeLocalBounds(shape: GeoShapeRecord): Box;
+    resizeSelectionBounds(shape: GeoShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    getHandleSnapGeometry(shape: GeoShapeRecord): ShapeHandleSnapGeometry;
+    hitTest(shape: GeoShapeRecord, positionedPoint: Vec): boolean;
+    hitTestLineSegment(shape: GeoShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+    resolveBindingPoint(shape: GeoShapeRecord, input: ShapeBindingPointInput): Vec;
+}

package/_vendor/plugin-flow/_vendor/plugin-geo/geoStrokeStyle.d.ts

@@ -0,0 +1,2 @@
+import type { GeoStrokeStyle } from "./types";
+export declare function getGeoStrokeDasharray(strokeStyle: GeoStrokeStyle, strokeWidth: number): string | undefined;

package/_vendor/plugin-flow/_vendor/plugin-geo/geoTools.d.ts

@@ -0,0 +1,51 @@
+import { StateNode, type Editor } from "../canvas-core/index";
+import type { GeoShapeKind, GeoShapeProps } from "./types";
+declare class BoxGeoTool extends StateNode {
+    private readonly kind;
+    constructor(editor: Editor, id: string, kind: GeoShapeKind);
+    getDefaultProps(): GeoShapeProps;
+    protected onEnter(): void;
+}
+export declare class RectangleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class EllipseTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class MessageCircleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class SummaryTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class SummaryLeftTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class BurstTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class RhombusTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class TriangleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class PentagonTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class HexagonTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class StarTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class TrapezoidTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class ArrowLeftTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class ArrowRightTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export {};

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

@@ -0,0 +1,9 @@
+export { ArrowLeftTool, ArrowRightTool, BurstTool, EllipseTool, HexagonTool, MessageCircleTool, PentagonTool, RectangleTool, RhombusTool, StarTool, SummaryLeftTool, SummaryTool, TrapezoidTool, TriangleTool, } from "./geoTools";
+export { geoApiToken } from "./api";
+export type { GeoApi, GeoCreateInput, GeoSelectionStyle, GeoStylePatch, } from "./api";
+export { GeoShapeUtil } from "./geoShapeUtil";
+export { GeoShapeSvgExporter, createGeoEditorPlugin } from "./editorRuntime";
+export { createGeoCanvasRenderPlugin } from "./canvasRender";
+export { Geo } from "./feature";
+export type { GeoShapeKind, GeoShapeProps, GeoShapeRecord, GeoStrokeStyle, } from "./types";
+export { GEO_SHAPE_KINDS, GEO_STROKE_STYLES, isGeoShapeKind, isGeoShapeRecord, isGeoStrokeStyle, } from "./types";

package/_vendor/plugin-flow/_vendor/plugin-geo/svgPathGeometry.d.ts

@@ -0,0 +1,7 @@
+import { Box, Vec } from "../canvas-core/index";
+export interface FlattenedSvgPathSubpath {
+    points: Vec[];
+    closed: boolean;
+}
+export declare function flattenSvgPath(path: string): FlattenedSvgPathSubpath[];
+export declare function getSvgPathBounds(path: string): Box;

package/_vendor/plugin-flow/_vendor/plugin-geo/types.d.ts

@@ -0,0 +1,22 @@
+import { type ShapeColor, type BaseRecord, type ShapeRecordBase } from "../canvas-core/index";
+export declare const GEO_SHAPE_KINDS: readonly ["rectangle", "ellipse", "message-circle", "summary", "summary-left", "burst", "rhombus", "triangle", "pentagon", "hexagon", "star", "trapezoid", "arrow-left", "arrow-right"];
+export type GeoShapeKind = (typeof GEO_SHAPE_KINDS)[number];
+export declare const GEO_STROKE_STYLES: readonly ["solid", "dashed", "dotted", "none"];
+export type GeoStrokeStyle = (typeof GEO_STROKE_STYLES)[number];
+export interface GeoShapeProps {
+    w: number;
+    h: number;
+    kind: GeoShapeKind;
+    fill: ShapeColor;
+    stroke: ShapeColor;
+    strokeStyle: GeoStrokeStyle;
+    strokeWidth: number;
+    cornerRadiusPercent: number;
+}
+export interface GeoShapeRecord extends ShapeRecordBase<"geo", GeoShapeProps> {
+    type: "geo";
+    props: GeoShapeProps;
+}
+export declare function isGeoShapeRecord(record: BaseRecord | null | undefined): record is GeoShapeRecord;
+export declare function isGeoShapeKind(value: unknown): value is GeoShapeKind;
+export declare function isGeoStrokeStyle(value: unknown): value is GeoStrokeStyle;

package/_vendor/plugin-flow/_vendor/plugin-image/host/api.d.ts

@@ -0,0 +1,61 @@
+import type { AssetId, ShapeId, Vec } from "../../canvas-core/index";
+import type { ImageSmudgeBrush, ImageSmudgeStroke } from "../image/smudge/session";
+import type { ImageShapeCrop } from "../image/types";
+export type ImageHostInsertSource = {
+    type: "file";
+    file: File;
+} | {
+    type: "blob";
+    blob: Blob;
+    name?: string;
+    mimeType?: string;
+    originalUrl?: string;
+} | {
+    type: "url";
+    url: string;
+    name?: string;
+    altText?: string;
+};
+export interface ImageHostInsertSize {
+    w: number;
+    h: number;
+}
+export interface ImageHostInsertInput {
+    source: ImageHostInsertSource;
+    pagePoint?: Vec;
+    size?: ImageHostInsertSize;
+}
+export interface ImageHostReplaceInput {
+    file: File;
+}
+export interface ImageHostSmudgeConfirmPayload {
+    shapeId: ShapeId;
+    sourceAssetId: AssetId | null;
+    imageBlob: Blob;
+    maskBlob?: Blob;
+    width: number;
+    height: number;
+    crop: ImageShapeCrop | null;
+    strokes: ImageSmudgeStroke[];
+}
+export interface ImageHostSmudgeController {
+    start(input?: {
+        shapeId?: ShapeId;
+        brush?: Partial<ImageSmudgeBrush>;
+    }): boolean;
+    setBrush(brush: Partial<ImageSmudgeBrush>): boolean;
+    cancel(): void;
+    confirm(input?: {
+        replace?: boolean;
+    }): Promise<ImageHostSmudgeConfirmPayload | null>;
+    isActive(): boolean;
+}
+export interface ImageHostApi {
+    openInsertFilePicker(): void;
+    openReplaceFilePicker(): void;
+    insert(input: ImageHostInsertInput): Promise<ShapeId | null>;
+    replaceSelection(input: ImageHostReplaceInput): Promise<boolean>;
+    downloadSelectionOriginal(): Promise<void>;
+    smudge: ImageHostSmudgeController;
+}
+export declare const imageHostApiToken: import("../../canvas-extension-contracts/index").CanvasApiToken<ImageHostApi>;

package/_vendor/plugin-flow/_vendor/plugin-image/host/asset/blobDataUrl.d.ts

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

package/_vendor/plugin-flow/_vendor/plugin-image/host/asset/imageAssetOperations.d.ts

@@ -0,0 +1,44 @@
+import { type AssetId, type Editor, type ShapeId, Vec } from "../../../canvas-core/index";
+import { type ImageAssetRecord, type ImageShapeRecord } from "../../image/types";
+import type { ImageHostInsertSize, ImageHostInsertSource } from "../api";
+import { type ImageObjectUrlStore } from "./imageBlobStore";
+export { getFirstImageFile } from "./imageFileHelpers";
+export interface InsertImageInput {
+    editor: Editor;
+    imageObjectUrls: ImageObjectUrlStore;
+    source: ImageHostInsertSource;
+    pagePoint?: Vec;
+    size?: ImageHostInsertSize;
+    signal: AbortSignal;
+}
+export interface ReplaceSelectedImageFileInput {
+    editor: Editor;
+    file: File;
+    imageObjectUrls: ImageObjectUrlStore;
+    signal: AbortSignal;
+}
+interface ImageShapeAssetReplacementResult {
+    assetId: AssetId;
+    storageKey: string | null;
+}
+export declare function insertImageIntoEditor({ editor, imageObjectUrls, pagePoint, signal, size, source, }: InsertImageInput): Promise<ShapeId | null>;
+export declare function replaceSelectedImageFromFile({ editor, file, imageObjectUrls, signal, }: ReplaceSelectedImageFileInput): Promise<void>;
+export declare function downloadSelectedImageOriginal({ editor, imageObjectUrls, onError, }: {
+    editor: Editor;
+    imageObjectUrls: ImageObjectUrlStore;
+    onError?: (error: unknown) => void;
+}): Promise<void>;
+export declare function replaceImageShapeFromBlob({ blob, canCommit, editor, imageObjectUrls, name, shape, signal, }: {
+    blob: Blob;
+    canCommit?: () => boolean;
+    editor: Editor;
+    imageObjectUrls: ImageObjectUrlStore;
+    name: string;
+    shape: ImageShapeRecord;
+    signal: AbortSignal;
+}): Promise<ImageShapeAssetReplacementResult | null>;
+export declare function readImageAssetSourceBlob({ asset, imageObjectUrls, }: {
+    asset: ImageAssetRecord;
+    imageObjectUrls: ImageObjectUrlStore;
+}): Promise<Blob | null>;
+export declare function isImageBlob(blob: Blob): boolean;

package/_vendor/plugin-flow/_vendor/plugin-image/host/asset/imageAssetService.d.ts

@@ -0,0 +1,17 @@
+import type { AssetId, Editor } from "../../../canvas-core/index";
+import { type ImageObjectUrlStore } from "./imageBlobStore";
+export interface ImageAssetService {
+    objectUrls: ImageObjectUrlStore;
+    cleanupAfterRestore(editor: Editor, options: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    preloadForEditor(editor: Editor, options: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    resolveAssetUrl(editor: Editor, assetId: AssetId): string | null;
+}
+export interface OwnedImageAssetService {
+    readonly value: ImageAssetService;
+    dispose(): void;
+}
+export declare function createLocalImageAssetService(): OwnedImageAssetService;

package/_vendor/plugin-flow/_vendor/plugin-image/host/asset/imageBlobStore.d.ts

@@ -0,0 +1,31 @@
+import type { AssetId, Editor } from "../../../canvas-core/index";
+export { readBlobAsDataUrl } from "./blobDataUrl";
+export interface ImageBlobWriteResult {
+    storageKey: string;
+}
+export interface ImageObjectUrlStore {
+    preloadForEditor(editor: Editor, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    preload(storageKey: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | null>;
+    resolve(storageKey: string): string | null;
+    resolveAssetUrl(editor: Editor, assetId: AssetId): string | null;
+    release(storageKey: string): void;
+    releaseAll(): void;
+}
+export declare function createImageStorageKey(): string;
+export declare function writeImageBlob(blob: Blob): Promise<ImageBlobWriteResult>;
+export declare function readImageBlob(storageKey: string): Promise<Blob | null>;
+export declare function readImageBlobAsDataUrl(storageKey: string): Promise<string | null>;
+export declare function deleteImageBlob(storageKey: string): Promise<void>;
+export declare function getAllImageBlobStorageKeys(): Promise<string[]>;
+export declare function getLocalImageAssetStorageKey(editor: Editor, assetId: AssetId): string | null;
+export declare function getRemoteImageAssetUrl(editor: Editor, assetId: AssetId): string | null;
+export declare function getReferencedImageStorageKeys(editor: Editor): Set<string>;
+export declare function cleanupUnreferencedImageBlobs({ editor, objectUrls, }: {
+    editor: Editor;
+    objectUrls?: ImageObjectUrlStore;
+}): Promise<string[]>;
+export declare function createImageObjectUrlStore(): ImageObjectUrlStore;

package/_vendor/plugin-flow/_vendor/plugin-image/host/asset/imageFileHelpers.d.ts

@@ -0,0 +1,47 @@
+import type { ImageAssetSource } from "../../image/types";
+export interface PreparedImageAssetInput {
+    name: string;
+    source: ImageAssetSource;
+    mimeType: string | null;
+    fileSize?: number;
+    width: number;
+    height: number;
+}
+export interface LocalImageBlobInput {
+    blob: Blob;
+    name?: string;
+    mimeType?: string;
+    originalUrl?: string;
+}
+export interface RemoteImageUrlInput {
+    url: string;
+    name?: string;
+    signal?: AbortSignal;
+}
+export declare function decodeImageSize(src: string, { signal }?: {
+    signal?: AbortSignal;
+}): Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function getLocalImageAssetInput(input: File | LocalImageBlobInput, { signal }?: {
+    signal?: AbortSignal;
+}): Promise<PreparedImageAssetInput>;
+export declare function getRemoteImageAssetInput({ name, signal, url, }: RemoteImageUrlInput): Promise<PreparedImageAssetInput>;
+export declare function fitImageSize({ height, width, }: {
+    height: number;
+    width: number;
+}): {
+    w: number;
+    h: number;
+};
+export declare function getFirstImageFile(files: Iterable<File>): File | null;
+export declare function downloadObjectUrl({ filename, url, }: {
+    filename: string;
+    url: string;
+}): void;
+export declare function openUrlInNewTab(url: string): void;
+export declare function downloadBlob({ blob, filename, }: {
+    blob: Blob;
+    filename: string;
+}): Promise<void>;

package/_vendor/plugin-flow/_vendor/plugin-image/host/asset/indexedDb.d.ts

@@ -0,0 +1,4 @@
+export declare function readImageStoreValue(key: IDBValidKey): Promise<unknown | null>;
+export declare function writeImageStoreValue(key: IDBValidKey, value: unknown): Promise<void>;
+export declare function deleteImageStoreValue(key: IDBValidKey): Promise<void>;
+export declare function getAllImageStoreKeys(): Promise<IDBValidKey[] | null>;

package/_vendor/plugin-flow/_vendor/plugin-image/host/createImageHostApi.d.ts

@@ -0,0 +1,15 @@
+import type { Editor } from "../../canvas-core/index";
+import type { CanvasTaskRunner } from "../../canvas-extension-contracts/index";
+import type { ImageApi } from "../image/api";
+import type { ImageAssetService } from "./asset/imageAssetService";
+import { type ImageHostApi } from "./api";
+export declare function createImageHostApi({ editor, imageAssetService, imageApi, onError, tasks, }: {
+    editor: Editor;
+    imageAssetService: ImageAssetService;
+    imageApi: ImageApi;
+    onError?: (error: unknown) => void;
+    tasks: CanvasTaskRunner;
+}): {
+    readonly value: ImageHostApi;
+    dispose(): void;
+};

package/_vendor/plugin-flow/_vendor/plugin-image/host/export/imageSvgResourceInliner.d.ts

@@ -0,0 +1,3 @@
+import type { SvgResourceInliner } from "../../../canvas-extension-contracts/index";
+import type { ImageAssetService } from "../asset/imageAssetService";
+export declare function createImageSvgAssetInliner(imageAssetService: ImageAssetService): SvgResourceInliner;

package/_vendor/plugin-flow/_vendor/plugin-image/host/index.d.ts

@@ -0,0 +1,14 @@
+export { createImageHostPlugin } from "./plugin";
+export type { ImageHostPluginOptions } from "./plugin";
+export { createImageHostApi } from "./createImageHostApi";
+export { imageHostApiToken } from "./api";
+export type { ImageHostApi, ImageHostInsertInput, ImageHostInsertSize, ImageHostInsertSource, ImageHostReplaceInput, ImageHostSmudgeConfirmPayload, ImageHostSmudgeController, } from "./api";
+export { createLocalImageAssetService } from "./asset/imageAssetService";
+export type { ImageAssetService, OwnedImageAssetService, } from "./asset/imageAssetService";
+export { cleanupUnreferencedImageBlobs, createImageObjectUrlStore, createImageStorageKey, deleteImageBlob, getAllImageBlobStorageKeys, getLocalImageAssetStorageKey, getRemoteImageAssetUrl, getReferencedImageStorageKeys, readImageBlob, readImageBlobAsDataUrl, writeImageBlob, } from "./asset/imageBlobStore";
+export type { ImageBlobWriteResult, ImageObjectUrlStore, } from "./asset/imageBlobStore";
+export { downloadSelectedImageOriginal, getFirstImageFile, insertImageIntoEditor, replaceSelectedImageFromFile, } from "./asset/imageAssetOperations";
+export type { InsertImageInput, ReplaceSelectedImageFileInput, } from "./asset/imageAssetOperations";
+export { confirmImageSmudgeSession } from "./smudge/confirm";
+export type { ConfirmImageSmudgeSessionInput } from "./smudge/confirm";
+export { createImageSvgAssetInliner } from "./export/imageSvgResourceInliner";

package/_vendor/plugin-flow/_vendor/plugin-image/host/plugin.d.ts

@@ -0,0 +1,8 @@
+import { type CanvasPlugin } from "../../canvas-extension-contracts/index";
+import { type ImageHostApi } from "./api";
+import { type OwnedImageAssetService } from "./asset/imageAssetService";
+export interface ImageHostPluginOptions {
+    readonly createAssetService?: () => OwnedImageAssetService;
+    readonly onError?: (error: unknown) => void;
+}
+export declare function createImageHostPlugin(options?: ImageHostPluginOptions): CanvasPlugin<ImageHostApi>;

package/_vendor/plugin-flow/_vendor/plugin-image/host/smudge/confirm.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../canvas-core/index";
+import type { ImageHostSmudgeConfirmPayload } from "../api";
+import { type ImageObjectUrlStore } from "../asset/imageBlobStore";
+export interface ConfirmImageSmudgeSessionInput {
+    editor: Editor;
+    imageObjectUrls: ImageObjectUrlStore;
+    replace?: boolean;
+    signal: AbortSignal;
+}
+export declare function confirmImageSmudgeSession({ editor, imageObjectUrls, replace, signal, }: ConfirmImageSmudgeSessionInput): Promise<ImageHostSmudgeConfirmPayload | null>;