@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,40 @@
+import type { Editor, ShapeId } from "../../canvas-core/index";
+import { type ImageCropAspectRatioPresetValue } from "./crop/model";
+import { type ImageSmudgeBrush, type ImageSmudgeSessionSnapshot } from "./smudge/session";
+import { type ImageShapeCrop } from "./types";
+export interface ImageSelectionState {
+    readonly shapeId: ShapeId;
+    readonly cornerRadius: number;
+    readonly crop: ImageShapeCrop | null;
+    readonly cropPreset: ImageCropAspectRatioPresetValue | null;
+    readonly isCropping: boolean;
+    readonly smudge: ImageSmudgeSessionSnapshot | null;
+}
+export interface ImageStylePatch {
+    readonly cornerRadius?: number;
+}
+export interface ImageApi {
+    getSelectionState(): ImageSelectionState | null;
+    setSelectionStyle(patch: ImageStylePatch): readonly ShapeId[];
+    startCrop(shapeId?: ShapeId): boolean;
+    finishCrop(): boolean;
+    cancelCrop(): boolean;
+    zoomCrop(direction: "in" | "out"): boolean;
+    setCropAspectRatio(preset: ImageCropAspectRatioPresetValue): boolean;
+    resetCrop(): boolean;
+    smudge: {
+        start(input?: {
+            readonly shapeId?: ShapeId;
+            readonly brush?: Partial<ImageSmudgeBrush>;
+        }): boolean;
+        setBrush(brush: Partial<ImageSmudgeBrush>): boolean;
+        cancel(): void;
+        undo(): boolean;
+        redo(): boolean;
+        getSnapshot(): ImageSmudgeSessionSnapshot | null;
+    };
+}
+export declare const imageApiToken: import("../../canvas-extension-contracts/index").CanvasApiToken<ImageApi>;
+export declare function createImagePluginApi({ editor, }: {
+    editor: Editor;
+}): ImageApi;

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

@@ -0,0 +1,6 @@
+export declare function normalizeImageCornerRadius(value: unknown, fallback?: number): number;
+export declare function getImageCornerRadiusForBounds({ cornerRadius, h, w, }: {
+    cornerRadius: unknown;
+    h: number;
+    w: number;
+}): number;

package/_vendor/plugin-flow/_vendor/plugin-image/image/crop/interactions.d.ts

@@ -0,0 +1,3 @@
+import { type LandInteractionHandler, type SelectionHandleInteractionHandler } from "../../../canvas-core/index";
+export declare function createImageCropSelectionHandleInteractionHandler(): SelectionHandleInteractionHandler;
+export declare function createImageCropInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-flow/_vendor/plugin-image/image/crop/model.d.ts

@@ -0,0 +1,112 @@
+import { Vec, type SelectionResizeHandleId, type ShapeUpdate } from "../../../canvas-core/index";
+import type { ImageShapeCrop, ImageShapeRecord } from "../types";
+export declare const IMAGE_CROP_HANDLE_TYPE = "image.crop";
+export declare const IMAGE_CROP_OPERATION_KIND_PREFIX = "image.crop:";
+export declare const IMAGE_CROP_HANDLE_OPERATION_KIND = "image.crop.handle";
+export declare const IMAGE_CROP_TRANSLATE_OPERATION_KIND = "image.crop.translate";
+export declare const IMAGE_CROP_MODE_OPERATION_KIND_PREFIX = "image.crop:edit:";
+export declare const IMAGE_CROP_ASPECT_RATIO_PRESETS: readonly [{
+    readonly label: "1:1";
+    readonly value: "1:1";
+    readonly ratio: 1;
+}, {
+    readonly label: "4:3";
+    readonly value: "4:3";
+    readonly ratio: number;
+}, {
+    readonly label: "16:9";
+    readonly value: "16:9";
+    readonly ratio: number;
+}];
+export type ImageCropAspectRatioPresetValue = (typeof IMAGE_CROP_ASPECT_RATIO_PRESETS)[number]["value"];
+export interface ImageCropRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface ImageCropPlacement {
+    imageX: number;
+    imageY: number;
+    imageWidth: number;
+    imageHeight: number;
+    rect: ImageCropRect;
+}
+export interface ImageCropCustomHandleAnchor {
+    kind: "custom";
+    type: typeof IMAGE_CROP_HANDLE_TYPE;
+    id: SelectionResizeHandleId;
+    point: Vec;
+    cursor: string;
+}
+interface UncroppedImageSpace {
+    w: number;
+    h: number;
+}
+export declare function normalizeImageShapeCrop(value: unknown): ImageShapeCrop | null;
+export declare function getImageCropRect(crop: ImageShapeCrop | null | undefined): ImageCropRect | null;
+export declare function getDefaultImageCrop(): ImageShapeCrop;
+export declare function getImageCropRectOrDefault(crop: ImageShapeCrop | null | undefined): ImageCropRect;
+export declare function getUncroppedImageSize({ crop, shape, }: {
+    crop: ImageShapeCrop | null | undefined;
+    shape: ImageShapeRecord;
+}): UncroppedImageSpace;
+export declare function getImageCropAspectRatioPresetValue(shape: ImageShapeRecord): ImageCropAspectRatioPresetValue | null;
+export declare function isImageCropModeForShape(shape: ImageShapeRecord, operationKind: string | null | undefined): boolean;
+export declare function getImageCropModeOperationKind(shapeId: ImageShapeRecord["id"]): string;
+export declare function getImageCropHandleIds(): readonly SelectionResizeHandleId[];
+export declare function isImageCropHandleId(value: string): value is SelectionResizeHandleId;
+export declare function getImageCropHandleCursor(handleId: SelectionResizeHandleId): string;
+export declare function getImageCropHandleAnchors({ localToPage, shape, }: {
+    crop: ImageShapeCrop | null | undefined;
+    localToPage: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+}): ImageCropCustomHandleAnchor[];
+export declare function getImageCropUpdateFromHandleDrag({ handleId, pageToLocal, shape, startCrop, startPagePoint, currentPagePoint, }: {
+    handleId: SelectionResizeHandleId;
+    pageToLocal: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+    startPagePoint: Vec;
+    currentPagePoint: Vec;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromContentDrag({ currentPagePoint, pageToLocal, shape, startCrop, startPagePoint, shiftKey, }: {
+    currentPagePoint: Vec;
+    pageToLocal: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+    startPagePoint: Vec;
+    shiftKey: boolean;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromContentNudge({ pageDelta, shape, startCrop, }: {
+    pageDelta: Vec;
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromZoom({ direction, shape, }: {
+    direction: "in" | "out";
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromAspectRatioPreset({ preset, shape, }: {
+    preset: ImageCropAspectRatioPresetValue;
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropResetUpdate({ baselineShape, shape, }: {
+    baselineShape: ImageShapeRecord;
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropPlacement({ crop, shapeHeight, shapeWidth, }: {
+    crop: ImageShapeCrop | null | undefined;
+    shapeHeight: number;
+    shapeWidth: number;
+}): ImageCropPlacement | null;
+export declare function formatImageCropViewBox(rect: ImageCropRect): string;
+export {};

package/_vendor/plugin-flow/_vendor/plugin-image/image/crop/session.d.ts

@@ -0,0 +1,6 @@
+import { type Editor } from "../../../canvas-core/index";
+import type { ImageShapeRecord } from "../types";
+export declare function rememberImageCropSessionBaseline(editor: Editor, shape: ImageShapeRecord): void;
+export declare function getImageCropSessionBaseline(editor: Editor, shapeId: ImageShapeRecord["id"]): ImageShapeRecord | null;
+export declare function clearImageCropSessionBaseline(editor: Editor, shapeId: ImageShapeRecord["id"]): void;
+export declare function setupImageCropSessionLifecycle(editor: Editor): () => void;

package/_vendor/plugin-flow/_vendor/plugin-image/image/editor/imageShapeUtil.d.ts

@@ -0,0 +1,13 @@
+import { Box, ShapeUtil, type ShapeEditEndInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionResizeModesInput } from "../../../canvas-core/index";
+import type { ImageShapeProps, ImageShapeRecord } from "../types";
+export declare class ImageShapeUtil extends ShapeUtil<ImageShapeRecord> {
+    readonly type: "image";
+    getDefaultProps(): ImageShapeProps;
+    validateProps(props: unknown): ImageShapeProps;
+    getLocalBounds(shape: ImageShapeRecord): Box;
+    canReceiveTerminalBinding(_shape: ImageShapeRecord): boolean;
+    getAllowedSelectionResizeModes(_shape: ImageShapeRecord, _input: ShapeSelectionResizeModesInput): readonly ["aspect_ratio_locked"];
+    canEdit(_shape: ImageShapeRecord): boolean;
+    onEditEnd(shape: ImageShapeRecord, input: ShapeEditEndInput): void;
+    getSelectionHandleAnchors(shape: ImageShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+}

package/_vendor/plugin-flow/_vendor/plugin-image/image/editor/imageSvgExporter.d.ts

@@ -0,0 +1,6 @@
+import type { ShapeSvgExporter, SvgExportContext, SvgNode } from "../../../canvas-core/index";
+import type { ImageShapeRecord } from "../types";
+export declare class ImageShapeSvgExporter implements ShapeSvgExporter<ImageShapeRecord> {
+    readonly type: "image";
+    toSvg(shape: ImageShapeRecord, context: SvgExportContext): SvgNode | null;
+}

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

@@ -0,0 +1,3 @@
+import type { EditorPlugin } from "../../../canvas-core/index";
+export { ImageShapeSvgExporter } from "./imageSvgExporter";
+export declare function createImageEditorPlugin(): EditorPlugin;

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

@@ -0,0 +1,14 @@
+export { ImageShapeSvgExporter, createImageEditorPlugin, } from "./editor/plugin";
+export { createImageCanvasRenderPlugin } from "./render/plugin";
+export { createImageCropInteractionHandler, createImageCropSelectionHandleInteractionHandler, } from "./crop/interactions";
+export { createImageSmudgeInteractionHandler } from "./smudge/interactions";
+export { IMAGE_CROP_ASPECT_RATIO_PRESETS, getImageCropModeOperationKind, getImageCropRectOrDefault, } from "./crop/model";
+export type { ImageCropRect } from "./crop/model";
+export { DEFAULT_IMAGE_SMUDGE_BRUSH_COLOR, DEFAULT_IMAGE_SMUDGE_BRUSH_SIZE, IMAGE_SMUDGE_BRUSH_SIZE_MAX, IMAGE_SMUDGE_BRUSH_SIZE_MIN, cancelImageSmudgeSession, cancelImageSmudgeSessionIfActive, cloneImageSmudgeStrokes, completeImageSmudgeSession, getActiveImageSmudgeSession, getImageSmudgeModeOperationKind, isImageSmudgeModeForShape, registerImageSmudgeConfirmHandler, redoImageSmudgeStroke, requestImageSmudgeConfirm, startImageSmudgeSession, undoImageSmudgeStroke, updateImageSmudgeBrush, } from "./smudge/session";
+export type { ImageSmudgeBrush, ImageSmudgeSessionSnapshot, ImageSmudgeStroke, ImageSmudgeStrokePoint, } from "./smudge/session";
+export { Image } from "./plugin";
+export { imageApiToken } from "./api";
+export type { ImageApi, ImageSelectionState, ImageStylePatch, } from "./api";
+export { ImageShapeUtil } from "./editor/imageShapeUtil";
+export type { ImageAssetProps, ImageAssetRecord, ImageAssetSource, ImageShapeCrop, ImageShapeProps, ImageShapeRecord, } from "./types";
+export { isImageAssetRecord, isImageShapeRecord } from "./types";

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

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

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

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

package/_vendor/plugin-flow/_vendor/plugin-image/image/smudge/interactions.d.ts

@@ -0,0 +1,2 @@
+import { type LandInteractionHandler } from "../../../canvas-core/index";
+export declare function createImageSmudgeInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-flow/_vendor/plugin-image/image/smudge/session.d.ts

@@ -0,0 +1,61 @@
+import { type Editor, type ShapeId } from "../../../canvas-core/index";
+import type { ImageShapeRecord } from "../types";
+export declare const IMAGE_SMUDGE_OPERATION_KIND_PREFIX = "image.smudge:";
+export declare const IMAGE_SMUDGE_MODE_OPERATION_KIND_PREFIX = "image.smudge:edit:";
+export declare const DEFAULT_IMAGE_SMUDGE_BRUSH_SIZE = 24;
+export declare const DEFAULT_IMAGE_SMUDGE_BRUSH_COLOR = "#ffff00";
+export declare const IMAGE_SMUDGE_BRUSH_SIZE_MIN = 1;
+export declare const IMAGE_SMUDGE_BRUSH_SIZE_MAX = 128;
+export interface ImageSmudgeBrush {
+    size: number;
+    color?: string;
+    opacity?: number;
+}
+export interface ImageSmudgeStrokePoint {
+    x: number;
+    y: number;
+    pressure?: number;
+}
+export interface ImageSmudgeStroke {
+    id: string;
+    points: ImageSmudgeStrokePoint[];
+    brush: ImageSmudgeBrush;
+}
+export interface ImageSmudgeConfirmInput {
+    replace?: boolean;
+}
+export type ImageSmudgeSessionSnapshot = Readonly<{
+    shapeId: ShapeId;
+    brush: ImageSmudgeBrush;
+    strokes: readonly ImageSmudgeStroke[];
+    canUndo: boolean;
+    canRedo: boolean;
+}>;
+type ImageSmudgeSubscriber = () => void;
+type ImageSmudgeConfirmHandler = (input?: ImageSmudgeConfirmInput) => Promise<unknown>;
+export declare function getImageSmudgeModeOperationKind(shapeId: ShapeId): string;
+export declare function isImageSmudgeModeForShape(shape: ImageShapeRecord, operationKind: string | null | undefined): boolean;
+export declare function normalizeImageSmudgeBrush(brush?: Partial<ImageSmudgeBrush>): ImageSmudgeBrush;
+export declare function startImageSmudgeSession({ brush, editor, shape, }: {
+    brush?: Partial<ImageSmudgeBrush>;
+    editor: Editor;
+    shape: ImageShapeRecord;
+}): boolean;
+export declare function cancelImageSmudgeSession(editor: Editor): void;
+export declare function completeImageSmudgeSession(editor: Editor): void;
+export declare function cancelImageSmudgeSessionIfActive(editor: Editor): boolean;
+export declare function clearImageSmudgeSessionForShape(editor: Editor, shapeId: ShapeId): void;
+export declare function updateImageSmudgeBrush(editor: Editor, brush: Partial<ImageSmudgeBrush>): boolean;
+export declare function getImageSmudgeSessionSnapshot(editor: Editor, shapeId: ShapeId): ImageSmudgeSessionSnapshot | null;
+export declare function getActiveImageSmudgeSession(editor: Editor): ImageSmudgeSessionSnapshot | null;
+export declare function subscribeImageSmudgeSession(editor: Editor, subscriber: ImageSmudgeSubscriber): () => void;
+export declare function beginImageSmudgeStroke(editor: Editor, point: ImageSmudgeStrokePoint): void;
+export declare function appendImageSmudgeStrokePoint(editor: Editor, point: ImageSmudgeStrokePoint): void;
+export declare function endImageSmudgeStroke(editor: Editor): void;
+export declare function cancelImageSmudgeStroke(editor: Editor): void;
+export declare function undoImageSmudgeStroke(editor: Editor): boolean;
+export declare function redoImageSmudgeStroke(editor: Editor): boolean;
+export declare function registerImageSmudgeConfirmHandler(editor: Editor, handler: ImageSmudgeConfirmHandler): () => void;
+export declare function requestImageSmudgeConfirm(editor: Editor, input?: ImageSmudgeConfirmInput): Promise<unknown>;
+export declare function cloneImageSmudgeStrokes(strokes: readonly ImageSmudgeStroke[]): ImageSmudgeStroke[];
+export {};

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

@@ -0,0 +1,46 @@
+import { type AssetId, type AssetRecordBase, type BaseRecord, type ShapeRecordBase } from "../../canvas-core/index";
+export type ImageAssetSource = {
+    kind: "local";
+    storageKey: string;
+    originalUrl?: string;
+} | {
+    kind: "remote";
+    url: string;
+};
+export interface ImageAssetProps {
+    w: number;
+    h: number;
+    name: string;
+    source: ImageAssetSource;
+    mimeType: string | null;
+    fileSize?: number;
+    isAnimated: boolean;
+}
+export interface ImageAssetRecord extends AssetRecordBase<"image", ImageAssetProps> {
+    type: "image";
+    props: ImageAssetProps;
+}
+export interface ImageShapeCrop {
+    topLeft: {
+        x: number;
+        y: number;
+    };
+    bottomRight: {
+        x: number;
+        y: number;
+    };
+}
+export interface ImageShapeProps {
+    w: number;
+    h: number;
+    assetId: AssetId | null;
+    crop: ImageShapeCrop | null;
+    cornerRadius: number;
+    altText: string;
+}
+export interface ImageShapeRecord extends ShapeRecordBase<"image", ImageShapeProps> {
+    type: "image";
+    props: ImageShapeProps;
+}
+export declare function isImageAssetRecord(record: BaseRecord | null | undefined): record is ImageAssetRecord;
+export declare function isImageShapeRecord(record: BaseRecord | null | undefined): record is ImageShapeRecord;

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

@@ -0,0 +1,2 @@
+export * from "./image";
+export * from "./host";

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

@@ -0,0 +1,45 @@
+import { type Editor, type ShapeColor, type ShapeId } from "../canvas-core/index";
+import { type CanvasShapeRef } from "../canvas-extension-contracts/index";
+import type { TextBlockType, TextFormattingSnapshot, TextFormattingValue, TextInlineFormat } from "./textFormatting";
+import type { TextShapeAlign, TextShapeFont, TextShapeProps, TextShapeSize } from "./textTypes";
+export interface TextInput {
+    x: number;
+    y: number;
+    text: string;
+    w?: number;
+    h?: number;
+    font?: TextShapeProps["font"];
+    color?: ShapeColor;
+    size?: TextShapeProps["size"];
+    textAlign?: TextShapeProps["textAlign"];
+    meta?: Record<string, unknown>;
+}
+export interface TextStylePatch {
+    color?: ShapeColor;
+    backgroundColor?: ShapeColor;
+    font?: TextShapeFont;
+    size?: TextShapeSize;
+    textAlign?: TextShapeAlign;
+}
+export interface TextApi {
+    create(input: TextInput): CanvasShapeRef<"text"> | null;
+    startEditing(shapeId?: ShapeId): boolean;
+    startEditingGeoLabel(ownerShapeId?: ShapeId): boolean;
+    startEditingPathLabel(ownerShapeId?: ShapeId): boolean;
+    getBoundTextLabel(ownerShapeId: ShapeId): CanvasShapeRef<"text"> | null;
+    getFormattingSnapshot(): TextFormattingSnapshot | null;
+    setSelectionStyle(patch: TextStylePatch, targetShapeId?: ShapeId): readonly ShapeId[];
+    getInlineFormatState(format: TextInlineFormat, targetShapeId?: ShapeId): TextFormattingSnapshot[TextInlineFormat];
+    toggleInlineFormat(format: TextInlineFormat, targetShapeId?: ShapeId): boolean;
+    getBlockType(targetShapeId?: ShapeId): TextFormattingValue<TextBlockType>;
+    setBlockType(blockType: TextBlockType, targetShapeId?: ShapeId): boolean;
+    clearFormatting(): boolean;
+    getLinkHref(): TextFormattingValue<string>;
+    setLink(href: string | null): boolean;
+    getToolDefaults(): TextShapeProps;
+    setToolDefaults(patch: TextStylePatch): TextShapeProps;
+}
+export declare const textApiToken: import("../canvas-extension-contracts/index").CanvasApiToken<TextApi>;
+export declare function createTextPluginApi({ editor, }: {
+    editor: Editor;
+}): TextApi;

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

@@ -0,0 +1,10 @@
+import { type RichTextLinkOpener } from "./richTextLinks";
+import { type TextFontCatalog } from "./textFonts";
+import type { TextTiptapEditorChangeHandler } from "./textFormatting";
+import { type CanvasRenderPlugin } from "../canvas-react/host/index";
+export declare function createTextCanvasRenderPlugin({ fontCatalog, formattingToolbar, openLink, onTiptapEditorChange, }?: {
+    fontCatalog?: TextFontCatalog;
+    formattingToolbar?: boolean;
+    openLink?: RichTextLinkOpener;
+    onTiptapEditorChange?: TextTiptapEditorChangeHandler;
+}): CanvasRenderPlugin;

package/_vendor/plugin-flow/_vendor/plugin-text/editorRichTextLinks.d.ts

@@ -0,0 +1,7 @@
+import type { Editor } from "../canvas-core/index";
+import { type RichTextLinkOpener } from "./richTextLinks";
+export declare function openEditorRichTextLink({ editor, href, openExternal, }: {
+    editor: Editor;
+    href: string;
+    openExternal: RichTextLinkOpener;
+}): void;

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

@@ -0,0 +1,5 @@
+import type { EditorPlugin } from "../canvas-core/index";
+import { type TextFontCatalog } from "./textFonts";
+export declare function createTextEditorPlugin({ fontCatalog, }?: {
+    fontCatalog?: TextFontCatalog;
+}): EditorPlugin;

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

@@ -0,0 +1,10 @@
+import { type CanvasPlugin } from "../canvas-extension-contracts/index";
+import type { TextApi } from "./api";
+import type { RichTextLinkOpener } from "./richTextLinks";
+import { type TextFontCatalog, type TextPluginOptions } from "./textFonts";
+export interface CreateTextPluginOptions extends Partial<TextPluginOptions> {
+    readonly fontCatalog?: TextFontCatalog;
+    readonly openLink?: RichTextLinkOpener;
+}
+export declare function createTextPlugin(options?: Readonly<CreateTextPluginOptions>): CanvasPlugin<TextApi>;
+export declare const Text: CanvasPlugin<TextApi>;

package/_vendor/plugin-flow/_vendor/plugin-text/geoLabelBindingUtil.d.ts

@@ -0,0 +1,48 @@
+import { BindingUtil, type BindingRecordBase, type BindingUtilEffect, type Editor, type ShapeRecord } from "../canvas-core/index";
+import { GEO_LABEL_BINDING_TYPE } from "./textLabelHelpers";
+import type { TextShapeRecord } from "./textTypes";
+export declare const GEO_LABEL_INDEX_SUFFIX = ".label";
+export interface GeoLabelBindingProps {
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    ownerBaseHeight: number;
+}
+export interface GeoLabelBindingRecord extends BindingRecordBase<typeof GEO_LABEL_BINDING_TYPE, GeoLabelBindingProps> {
+    type: typeof GEO_LABEL_BINDING_TYPE;
+    props: GeoLabelBindingProps;
+}
+export declare class GeoLabelBindingUtil extends BindingUtil<GeoLabelBindingRecord> {
+    readonly type = "geo-label";
+    getDefaultProps(): GeoLabelBindingProps;
+    validateProps(props: unknown): GeoLabelBindingProps;
+    canBind(_editor: Editor, binding: GeoLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    canUseShapeCompanion(_binding: GeoLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    getExclusiveBindingKey(binding: GeoLabelBindingRecord): string;
+    onBindingCreate(editor: Editor, binding: GeoLabelBindingRecord): BindingUtilEffect | void;
+    onBindingUpdate(editor: Editor, before: GeoLabelBindingRecord, after: GeoLabelBindingRecord): BindingUtilEffect | void;
+    onBindingLoad(editor: Editor, binding: GeoLabelBindingRecord): BindingUtilEffect | void;
+    getGeometryDependentShapeIds(_editor: Editor, binding: GeoLabelBindingRecord, context: {
+        role: "from" | "to";
+    }): ShapeRecord["id"][];
+    onAfterShapeChange(editor: Editor, binding: GeoLabelBindingRecord, context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteShape(editor: Editor, binding: GeoLabelBindingRecord, context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteBinding(editor: Editor, binding: GeoLabelBindingRecord): BindingUtilEffect | void;
+    getExportShapeIds(_editor: Editor, binding: GeoLabelBindingRecord): TextShapeRecord["id"][];
+    getShapeCompanionRootId(binding: GeoLabelBindingRecord, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
+    private syncLabelPosition;
+}
+export declare function getGeoLabelLayout(editor: Editor, label: TextShapeRecord, owner: ShapeRecord): Pick<TextShapeRecord, "x" | "y" | "rotation"> & {
+    props: Pick<TextShapeRecord["props"], "w">;
+};

package/_vendor/plugin-flow/_vendor/plugin-text/host/RichTextEditingBox.d.ts

@@ -0,0 +1,12 @@
+import type { TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import type { TextTiptapEditorChangeHandler } from "../textFormatting";
+import type { RichTextLinkOpener } from "../richTextLinks";
+export declare function ShapeEditingSessionBox({ shapeId, operationKind, fontCatalog, formattingToolbar, openLink, onTiptapEditorChange, }: {
+    shapeId: TextShapeRecord["id"];
+    operationKind: string;
+    fontCatalog: TextFontCatalog;
+    formattingToolbar?: boolean;
+    openLink?: RichTextLinkOpener;
+    onTiptapEditorChange?: TextTiptapEditorChangeHandler;
+}): import("react/jsx-runtime").JSX.Element | null;

package/_vendor/plugin-flow/_vendor/plugin-text/host/TiptapTextEditor.d.ts

@@ -0,0 +1,29 @@
+import { type CSSProperties } from "react";
+import { type Editor as TiptapEditor } from "@tiptap/react";
+import { type Editor as LandEditor } from "../../canvas-core/index";
+import type { RichTextDocument, TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import type { TextTiptapEditorChangeHandler, TextTiptapEditorHandle } from "../textFormatting";
+import { type TiptapTextEditorController } from "./tiptapTextEditorController";
+export interface TiptapTextEditorHandle extends TextTiptapEditorHandle {
+    readonly editor: TiptapEditor;
+    readonly controller: TiptapTextEditorController;
+}
+export interface TiptapTextEditorProps {
+    landEditor: LandEditor;
+    shape: TextShapeRecord;
+    fontCatalog: TextFontCatalog;
+    initialRichText: RichTextDocument;
+    className: string;
+    editorStyle: CSSProperties;
+    formattingToolbar?: boolean;
+    onTiptapEditorChange?: TextTiptapEditorChangeHandler;
+    onReady(handle: TiptapTextEditorHandle): void;
+    onDispose(handle: TiptapTextEditorHandle): void;
+    onRichTextChange(input: {
+        editor: TiptapEditor;
+        controller: TiptapTextEditorController;
+        richText: RichTextDocument;
+    }): void;
+}
+export declare function TiptapTextEditor({ landEditor, shape, fontCatalog, initialRichText, className, editorStyle, formattingToolbar, onTiptapEditorChange, onReady, onDispose, onRichTextChange, }: TiptapTextEditorProps): import("react/jsx-runtime").JSX.Element;

package/_vendor/plugin-flow/_vendor/plugin-text/host/blobDataUrl.d.ts

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

package/_vendor/plugin-flow/_vendor/plugin-text/host/browserRichTextLink.d.ts

@@ -0,0 +1 @@
+export declare function openBrowserRichTextLink(href: string): void;

package/_vendor/plugin-flow/_vendor/plugin-text/host/initialTextBackground.d.ts

@@ -0,0 +1,2 @@
+import type { Editor as TiptapEditor } from "@tiptap/react";
+export declare function applyInitialTextBackgroundToEmptyEditor(editor: TiptapEditor, backgroundColor: string | null): boolean;

package/_vendor/plugin-flow/_vendor/plugin-text/host/richTextRendering.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from "react";
+import type { RichTextDocument } from "../textTypes";
+import type { RichTextSearchRange } from "../textSearch";
+export interface RichTextRenderLinkHandlers {
+    onPointerEnter?(input: {
+        href: string;
+        element: HTMLSpanElement;
+    }): void;
+    onPointerLeave?(): void;
+}
+export interface RichTextRenderOptions {
+    readonly activeSearchRange?: RichTextSearchRange | null;
+    readonly defaultBackgroundColor?: string;
+    readonly linkHandlers?: RichTextRenderLinkHandlers;
+    readonly searchRanges?: readonly RichTextSearchRange[];
+}
+export declare function renderRichTextDocument(richText: RichTextDocument, options?: RichTextRenderOptions): ReactNode;

package/_vendor/plugin-flow/_vendor/plugin-text/host/textDomSelection.d.ts

@@ -0,0 +1,7 @@
+import type { Editor as TiptapEditor } from "@tiptap/react";
+import type { TiptapTextSelectionSnapshot } from "./tiptapTextEditorController";
+export declare function hasMountedTextEditorView(textEditor: TiptapEditor): boolean;
+export declare function ensureTextEditorFocused(textEditor: TiptapEditor): void;
+export declare function placeCaretInTextEditorAtClientPoint(textEditor: TiptapEditor, clientX: number, clientY: number): void;
+export declare function isDomSelectionRangeInsideTextEditor(textEditor: TiptapEditor): boolean;
+export declare function getTextEditorSelectionSnapshot(textEditor: TiptapEditor): TiptapTextSelectionSnapshot;

package/_vendor/plugin-flow/_vendor/plugin-text/host/textEditingBoxStyle.d.ts

@@ -0,0 +1,4 @@
+import { type CSSProperties } from "react";
+import type { TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+export declare function useTextEditingBoxStyle(shape: TextShapeRecord, fontCatalog: TextFontCatalog, paddingInline?: number): CSSProperties;

package/_vendor/plugin-flow/_vendor/plugin-text/host/textEntryFocus.d.ts

@@ -0,0 +1,23 @@
+import { type MutableRefObject } from "react";
+import type { Editor as TiptapEditor } from "@tiptap/react";
+import type { Editor, ShapeEditingEntryRequest, ShapeEditingSession } from "../../canvas-core/index";
+import type { TextShapeRecord } from "../textTypes";
+import type { TiptapTextEditorController } from "./tiptapTextEditorController";
+export declare function focusTextEditorWhenMounted({ editor, controller, shapeId, request, onApplied, attempt, }: {
+    editor: Editor;
+    controller: TiptapTextEditorController;
+    shapeId: TextShapeRecord["id"];
+    request: ShapeEditingEntryRequest | null;
+    onApplied?: (request: ShapeEditingEntryRequest | null) => void;
+    attempt?: number;
+}): void;
+export declare function useTextEditingEntryFocus({ editor, shapeId, session, tiptapEditor, richTextController, entryRequest, consumedEntryRequestIdRef, onEntryFocusApplied, }: {
+    editor: Editor;
+    shapeId: TextShapeRecord["id"];
+    session: ShapeEditingSession;
+    tiptapEditor: TiptapEditor | null;
+    richTextController: TiptapTextEditorController | null;
+    entryRequest: ShapeEditingEntryRequest | null;
+    consumedEntryRequestIdRef: MutableRefObject<number | null>;
+    onEntryFocusApplied?: () => void;
+}): void;

package/_vendor/plugin-flow/_vendor/plugin-text/host/textFontLoader.d.ts

@@ -0,0 +1,3 @@
+import type { TextShapeFont } from "../textTypes";
+import { type TextFontCatalog } from "../textFonts";
+export declare function ensureTextFontLoaded(font: TextShapeFont, fontCatalog: TextFontCatalog, ownerDocument?: Document): Promise<void>;

package/_vendor/plugin-flow/_vendor/plugin-text/host/textFormattingApi.d.ts

@@ -0,0 +1,16 @@
+import { type Editor as LandEditor } from "../../canvas-core/index";
+import type { Editor as TiptapEditor } from "@tiptap/core";
+import type { TextFormattingApi, TextFormattingSnapshot } from "../textFormatting";
+import type { TextFontCatalog } from "../textFonts";
+import type { TextShapeRecord } from "../textTypes";
+export declare function createTextFormattingApi({ editor, fontCatalog, landEditor, shapeId, }: {
+    editor: TiptapEditor;
+    fontCatalog: TextFontCatalog;
+    landEditor: LandEditor;
+    shapeId: TextShapeRecord["id"];
+}): TextFormattingApi;
+export declare function getTextFormattingSnapshot({ editor, fontCatalog, shape, }: {
+    editor: TiptapEditor;
+    fontCatalog: TextFontCatalog;
+    shape: TextShapeRecord;
+}): TextFormattingSnapshot;

package/_vendor/plugin-flow/_vendor/plugin-text/host/textMeasurement.d.ts

@@ -0,0 +1,21 @@
+import type { Editor as TiptapEditor } from "@tiptap/react";
+import type { RichTextDocument, TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import { type TextLabelLayoutConstraints } from "../textLabelHelpers";
+export declare const TEXT_AUTO_SIZE_MIN_W = 16;
+export declare function measureTextShapeFromEditor(textEditor: TiptapEditor, shape: TextShapeRecord, fontCatalog: TextFontCatalog, labelLayout?: TextLabelLayoutConstraints | null): {
+    w: number;
+    h: number;
+} | undefined;
+export declare function measureTextShapeFromRichText(richText: RichTextDocument, shape: TextShapeRecord, fontCatalog: TextFontCatalog, labelLayout?: TextLabelLayoutConstraints | null): {
+    w: number;
+    h: number;
+} | undefined;
+export declare function applyTextShapeElementStyles(element: HTMLElement, shape: TextShapeRecord, fontCatalog: TextFontCatalog): void;
+export declare function resolveMeasuredTextShapeSize(shape: TextShapeRecord, measuredSize: {
+    w: number;
+    h: number;
+}, labelLayout?: TextLabelLayoutConstraints | null): {
+    w: number;
+    h: number;
+} | undefined;