@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,11 @@
+import type { ChangeSource, Editor } from "../../canvas-core/index";
+import type { TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import type { TiptapTextEditorController } from "./tiptapTextEditorController";
+export declare function scheduleTextEditorMeasurement(editor: Editor, controller: TiptapTextEditorController, latestShapeRef: {
+    current: TextShapeRecord;
+}, measureTimerRef: {
+    current: number | null;
+}): void;
+export declare function measureTextEditorLayout(editor: Editor, controller: TiptapTextEditorController, shape: TextShapeRecord): void;
+export declare function measureTextShapeRichTextLayout(editor: Editor, shape: TextShapeRecord, fontCatalog: TextFontCatalog, source?: ChangeSource): void;

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

@@ -0,0 +1,14 @@
+import { type PointerEvent as ReactPointerEvent } from "react";
+import type { Editor } from "../../canvas-core/index";
+import type { TextShapeRecord } from "../textTypes";
+import type { TiptapTextEditorController } from "./tiptapTextEditorController";
+export declare function useRangeClickCollapse({ editor, shapeId, richTextController, }: {
+    editor: Editor;
+    shapeId: TextShapeRecord["id"];
+    richTextController: TiptapTextEditorController | null;
+}): {
+    onPointerDownCapture(event: ReactPointerEvent<HTMLDivElement>): void;
+    onPointerMoveCapture(event: ReactPointerEvent<HTMLDivElement>): void;
+    onPointerUpCapture(event: ReactPointerEvent<HTMLDivElement>): void;
+    onPointerCancel(): void;
+};

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

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+import type { Editor } from "../../canvas-core/index";
+import type { TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import type { TextTiptapEditorChangeHandler } from "../textFormatting";
+import type { RichTextLinkOpener } from "../richTextLinks";
+export interface TextShapeRendererRuntime {
+    hasEditingSession: boolean;
+    isEditingThisShape: boolean;
+    editingHost: ReactNode;
+}
+export declare function useTextShapeRendererRuntime(editor: Editor, shape: TextShapeRecord, fontCatalog: TextFontCatalog, formattingToolbar?: boolean, openLink?: RichTextLinkOpener, onTiptapEditorChange?: TextTiptapEditorChangeHandler): TextShapeRendererRuntime;

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

@@ -0,0 +1,19 @@
+import { type MutableRefObject } from "react";
+import type { Editor as TiptapEditor } from "@tiptap/react";
+import type { Editor } from "../../canvas-core/index";
+import { type RichTextDocument, type TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import type { TiptapTextEditorController } from "./tiptapTextEditorController";
+export declare function useLatestTextShapeRef(shape: TextShapeRecord): MutableRefObject<TextShapeRecord>;
+export declare function useRichTextShapeSync({ editor, shape, tiptapEditor, richTextController, latestShapeRef, fontCatalog, }: {
+    editor: Editor;
+    shape: TextShapeRecord;
+    tiptapEditor: TiptapEditor | null;
+    richTextController: TiptapTextEditorController | null;
+    latestShapeRef: MutableRefObject<TextShapeRecord>;
+    fontCatalog: TextFontCatalog;
+}): (input: {
+    editor: TiptapEditor;
+    controller: TiptapTextEditorController;
+    richText: RichTextDocument;
+}) => void;

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

@@ -0,0 +1,3 @@
+import { type TextFontCatalog } from "../textFonts";
+import type { SvgResourceInliner } from "../../canvas-extension-contracts/index";
+export declare function createTextSvgAssetInliner(fontCatalog: TextFontCatalog): SvgResourceInliner;

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

@@ -0,0 +1,5 @@
+import { type CanvasPlugin } from "../../canvas-extension-contracts/index";
+import type { TextFontCatalog } from "../textFonts";
+export declare function createTextSvgExportPlugin({ fontCatalog, }: {
+    fontCatalog: TextFontCatalog;
+}): CanvasPlugin;

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

@@ -0,0 +1,38 @@
+import type { Editor as TiptapEditor } from "@tiptap/react";
+import { type Editor, type ShapeId } from "../../canvas-core/index";
+import type { RichTextDocument, TextShapeRecord } from "../textTypes";
+import type { TextFontCatalog } from "../textFonts";
+import type { TextFormattingApi } from "../textFormatting";
+export interface TiptapTextSelectionSnapshot {
+    type: string | null;
+    text: string | null;
+}
+export interface TiptapTextEditorController {
+    readonly shapeId: ShapeId;
+    readonly formatting: TextFormattingApi;
+    getValue(): RichTextDocument;
+    setValue(value: RichTextDocument): void;
+    isDestroyed(): boolean;
+    isConnected(): boolean;
+    isFocused(): boolean;
+    focus(): void;
+    focusEnd(): void;
+    focusSelectAll(): void;
+    focusAtPagePoint(editor: Editor, pagePoint: {
+        x: number;
+        y: number;
+    }): void;
+    getSelectionSnapshot(): TiptapTextSelectionSnapshot;
+    collapseSelectionAtClientPoint(clientX: number, clientY: number): void;
+    measure(shape: TextShapeRecord): {
+        w: number;
+        h: number;
+    } | undefined;
+    onCompositionStateChange(listener: (isComposing: boolean) => void): () => void;
+}
+export declare function createTiptapTextEditorController({ shapeId, editor, fontCatalog, landEditor, }: {
+    shapeId: ShapeId;
+    editor: TiptapEditor;
+    fontCatalog: TextFontCatalog;
+    landEditor: Editor;
+}): TiptapTextEditorController;

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

@@ -0,0 +1,21 @@
+export { Text, createTextPlugin } from "./feature";
+export type { CreateTextPluginOptions } from "./feature";
+export { textApiToken } from "./api";
+export type { TextApi, TextInput, TextStylePatch } from "./api";
+export { createTextEditorPlugin } from "./editorRuntime";
+export { createTextCanvasRenderPlugin } from "./canvasRender";
+export { DEFAULT_TEXT_FONT, HOST_TEXT_FONT, createDefaultTextFontCatalog, createDefaultTextPluginOptions, createTextFontCatalog, } from "./textFonts";
+export { createRichTextFromPlainText, getPlainTextFromRichText, validateRichTextDocument, } from "./richTextUtils";
+export { TextSearchHighlightProvider, findRichTextSearchMatches, } from "./textSearch";
+export type { RichTextSearchRange, TextSearchHighlightState, TextSearchHighlightTarget, } from "./textSearch";
+export { TEXT_SIZE_PRESETS } from "./textStyle";
+export { isTextShapeRecord, updateTextShapeRichText, } from "./textShapeHelpers";
+export { TextLinkPopoverPresenterProvider, } from "./textLinkPopoverPresentation";
+export type { TextLinkPopoverPresenter, TextLinkPopoverPresenterProps, } from "./textLinkPopoverPresentation";
+export type { TextPluginOptions, TextFontDefinition, TextFontCatalog, TextFontFaceSource, TextFontSource, TextStylesheetFontSource, TextSystemFontSource, } from "./textFonts";
+export type { RichTextDocument, TextShapeAlign, TextShapeFont, TextShapeProps, TextShapeRecord, TextShapeSize, } from "./textTypes";
+export type { TextFormattingApi, TextBlockType, TextFormattingMixed, TextFormattingSnapshot, TextFormattingTarget, TextFormattingValue, TextInlineFormat, TextTiptapEditorChangeHandler, TextTiptapEditorHandle, } from "./textFormatting";
+export { createTextSvgExportPlugin } from "./host/textSvgExportPlugin";
+export { openBrowserRichTextLink } from "./host/browserRichTextLink";
+export { createCanvasShapeLinkHref, isAllowedRichTextLinkHref, isExternalRichTextLinkHref, normalizeRichTextLinkHref, openRichTextLink, parseCanvasShapeLinkHref, } from "./richTextLinks";
+export type { RichTextLinkOpener } from "./richTextLinks";

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

@@ -0,0 +1,55 @@
+import { BindingUtil, type BindingRecord, type BindingRecordBase, type BindingUtilEffect, type BindingSelectionCompanionFrameContext, type Editor, type SelectionOverlayFrameGeometryState, type ShapeLabelPathGeometry, type ShapeRecord, Vec } from "../canvas-core/index";
+import { PATH_LABEL_BINDING_TYPE } from "./textLabelHelpers";
+import type { TextShapeRecord } from "./textTypes";
+export declare const PATH_LABEL_INDEX_SUFFIX = ".label";
+export interface PathLabelBindingProps {
+    labelPosition: number;
+}
+export interface PathLabelBindingRecord extends BindingRecordBase<typeof PATH_LABEL_BINDING_TYPE, PathLabelBindingProps> {
+    type: typeof PATH_LABEL_BINDING_TYPE;
+    props: PathLabelBindingProps;
+}
+export declare function isPathLabelBindingRecord(record: BindingRecord | null | undefined): record is PathLabelBindingRecord;
+export declare class PathLabelBindingUtil extends BindingUtil<PathLabelBindingRecord> {
+    readonly type = "path-label";
+    getDefaultProps(): PathLabelBindingProps;
+    validateProps(props: unknown): PathLabelBindingProps;
+    canBind(editor: Editor, binding: PathLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    canUseShapeCompanion(_binding: PathLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }, editor?: Editor): boolean;
+    getExclusiveBindingKey(binding: PathLabelBindingRecord): string;
+    onBindingCreate(editor: Editor, binding: PathLabelBindingRecord): BindingUtilEffect | void;
+    onBindingUpdate(editor: Editor, _before: PathLabelBindingRecord, after: PathLabelBindingRecord): BindingUtilEffect | void;
+    onBindingLoad(editor: Editor, binding: PathLabelBindingRecord): BindingUtilEffect | void;
+    getGeometryDependentShapeIds(_editor: Editor, binding: PathLabelBindingRecord, context: {
+        role: "from" | "to";
+    }): ShapeRecord["id"][];
+    getTargetShapeContentCutoutLocalPolygons(editor: Editor, _binding: PathLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): readonly (readonly Vec[])[];
+    onAfterShapeChange(editor: Editor, binding: PathLabelBindingRecord, _context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteShape(_editor: Editor, binding: PathLabelBindingRecord, context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteBinding(_editor: Editor, binding: PathLabelBindingRecord): BindingUtilEffect | void;
+    getExportShapeIds(_editor: Editor, binding: PathLabelBindingRecord): TextShapeRecord["id"][];
+    getShapeCompanionRootId(binding: PathLabelBindingRecord, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
+    getSelectionCompanionFrameGeometries(editor: Editor, binding: PathLabelBindingRecord, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
+    private syncLabelPosition;
+}
+export declare function getPathLabelLayout(editor: Editor, label: TextShapeRecord, owner: ShapeRecord, labelPosition?: number): Pick<TextShapeRecord, "x" | "y" | "rotation"> & {
+    props: Pick<TextShapeRecord["props"], "w">;
+};
+export declare function getPathLabelOwnerGeometry(editor: Editor, owner: ShapeRecord): ShapeLabelPathGeometry | null;
+export declare function getPathLabelPositionRange(editor: Editor, label: TextShapeRecord, pathGeometry: ShapeLabelPathGeometry): {
+    start: number;
+    end: number;
+};

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

@@ -0,0 +1,12 @@
+import type { ShapeId } from "../canvas-core/index";
+export declare function normalizeRichTextLinkHref(value: string): string | null;
+export declare function isAllowedRichTextLinkHref(value: string): boolean;
+export declare function isExternalRichTextLinkHref(value: string): boolean;
+export declare function createCanvasShapeLinkHref(shapeId: ShapeId): string;
+export declare function parseCanvasShapeLinkHref(value: string): ShapeId | null;
+export declare function openRichTextLink({ href, openExternal, openInternal, }: {
+    href: string;
+    openExternal: RichTextLinkOpener;
+    openInternal?(shapeId: ShapeId): void;
+}): void;
+export type RichTextLinkOpener = (href: string) => void;

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

@@ -0,0 +1,26 @@
+import type { JSONContent } from "@tiptap/core";
+import type { RichTextDocument } from "./textTypes";
+export type RichTextTextNode = JSONContent & {
+    type: "text";
+    text: string;
+};
+export type RichTextBlockTextAlign = "left" | "center" | "right";
+export interface RichTextMarkStyle {
+    color?: string;
+    backgroundColor?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: number;
+    fontStyle?: "italic";
+    lineHeight?: string;
+    textDecorationLine?: string;
+}
+export declare function createRichTextFromPlainText(text: string): RichTextDocument;
+export declare function getPlainTextFromRichText(richTextDocument: RichTextDocument): string;
+export declare function validateRichTextDocument(value: unknown): RichTextDocument;
+export declare function renderRichTextDocumentToHtml(richText: RichTextDocument): string;
+export declare function isRichTextTextNode(node: JSONContent): node is RichTextTextNode;
+export declare function getRichTextTextNodeStyle(node: RichTextTextNode, defaultBackgroundColor?: string): string | undefined;
+export declare function getRichTextBlockTextAlign(node: JSONContent): RichTextBlockTextAlign | undefined;
+export declare function getRichTextMarkStyle(marks: JSONContent["marks"], defaultBackgroundColor?: string): RichTextMarkStyle | undefined;
+export declare function getRichTextLinkHref(marks: JSONContent["marks"]): string | undefined;

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

@@ -0,0 +1,18 @@
+import type { TextBlockType, TextFormattingValue } from "./textFormatting";
+import type { RichTextDocument } from "./textTypes";
+export type ShapeWideTextInlineFormat = "bold" | "italic" | "strike" | "underline";
+export type ShapeWideTextStyleProperty = "color" | "font" | "size" | "textAlign";
+export type ShapeWideTextFormatState = boolean | "mixed";
+export type ShapeWideTextBackgroundColorState = string | "mixed" | null;
+export type ShapeWideTextLinkState = string | "mixed" | null;
+export declare function getShapeWideTextBlockType(richText: RichTextDocument): TextFormattingValue<TextBlockType>;
+export declare function setShapeWideTextBlockType(richText: RichTextDocument, blockType: TextBlockType): RichTextDocument;
+export declare function getShapeWideTextFormatState(richText: RichTextDocument, format: ShapeWideTextInlineFormat): ShapeWideTextFormatState;
+export declare function setShapeWideTextFormat(richText: RichTextDocument, format: ShapeWideTextInlineFormat, enabled: boolean): RichTextDocument;
+export declare function getShapeWideTextLinkHref(richText: RichTextDocument): ShapeWideTextLinkState;
+export declare function setShapeWideTextLink(richText: RichTextDocument, href: string | null): RichTextDocument;
+export declare function getShapeWideTextBackgroundColor(richText: RichTextDocument): ShapeWideTextBackgroundColorState;
+export declare function setShapeWideTextBackgroundColor(richText: RichTextDocument, backgroundColor: string | null): RichTextDocument;
+export declare function fillMissingShapeWideTextBackgroundColor(richText: RichTextDocument, backgroundColor: string): RichTextDocument;
+export declare function clearShapeWideTextStyleOverride(richText: RichTextDocument, property: ShapeWideTextStyleProperty): RichTextDocument;
+export declare function clearShapeWideTextFormatting(richText: RichTextDocument): RichTextDocument;

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

@@ -0,0 +1,49 @@
+import type { TextShapeFont } from "./textTypes";
+import type { TextTiptapEditorChangeHandler } from "./textFormatting";
+export declare const DEFAULT_TEXT_FONT: "default";
+export declare const DEFAULT_TEXT_FONT_LABEL = "Default";
+export interface TextSystemFontSource {
+    readonly kind: "system";
+}
+export interface TextStylesheetFontSource {
+    readonly kind: "stylesheet";
+    readonly cssUrl: string;
+    readonly family: string;
+    readonly weights?: readonly number[];
+    readonly sampleText?: string;
+}
+export interface TextFontFaceSource {
+    readonly kind: "font-face";
+    readonly family: string;
+    readonly src: string | ArrayBuffer;
+    readonly descriptors?: FontFaceDescriptors;
+    readonly weights?: readonly number[];
+    readonly sampleText?: string;
+}
+export type TextFontSource = TextSystemFontSource | TextStylesheetFontSource | TextFontFaceSource;
+export interface TextFontDefinition {
+    readonly id: TextShapeFont;
+    readonly label: string;
+    readonly cssFamily: string;
+    readonly source?: TextFontSource;
+}
+export interface TextFontCatalog {
+    readonly defaultFont: TextFontDefinition;
+    readonly defaultFontLabel: string;
+    readonly fontOptions: readonly TextFontDefinition[];
+    readonly fontsById: ReadonlyMap<TextShapeFont, TextFontDefinition>;
+}
+export type TextPluginOptions = {
+    defaultFont: TextFontDefinition;
+    defaultFontLabel: string;
+    fonts: readonly TextFontDefinition[];
+    formattingToolbar?: boolean;
+    onTiptapEditorChange?: TextTiptapEditorChangeHandler;
+};
+export declare const HOST_TEXT_FONT: TextFontDefinition;
+export declare function createDefaultTextPluginOptions(): TextPluginOptions;
+export declare function createDefaultTextFontCatalog(): TextFontCatalog;
+export declare function createTextFontCatalog(options: Readonly<TextPluginOptions>): TextFontCatalog;
+export declare function isUsableFontId(value: unknown): value is TextShapeFont;
+export declare function isTextFontInCatalog(fontCatalog: TextFontCatalog, font: unknown): font is TextShapeFont;
+export declare function resolveTextFont(fontCatalog: TextFontCatalog, font: TextShapeFont): TextFontDefinition;

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

@@ -0,0 +1,50 @@
+import type { ShapeId } from "../canvas-core/index";
+import type { Editor as TiptapEditor } from "@tiptap/core";
+import type { TextShapeAlign, TextShapeFont, TextShapeSize } from "./textTypes";
+export type TextFormattingMixed = "mixed";
+export type TextFormattingValue<T> = T | TextFormattingMixed | null;
+export type TextFormattingTarget = "selection" | "shape";
+export type TextBlockType = "paragraph" | "orderedList" | "bulletList" | "blockquote";
+export type TextInlineFormat = "bold" | "italic" | "strike" | "underline";
+export interface TextFormattingSnapshot {
+    shapeId: ShapeId;
+    target: TextFormattingTarget;
+    bold: boolean | TextFormattingMixed;
+    italic: boolean | TextFormattingMixed;
+    strike: boolean | TextFormattingMixed;
+    underline: boolean | TextFormattingMixed;
+    blockType: TextFormattingValue<TextBlockType>;
+    color: TextFormattingValue<string>;
+    backgroundColor: TextFormattingValue<string>;
+    font: TextFormattingValue<TextShapeFont>;
+    size: TextFormattingValue<TextShapeSize>;
+    textAlign: TextFormattingValue<TextShapeAlign>;
+    linkHref: TextFormattingValue<string>;
+    canSetLink: boolean;
+}
+export interface TextFormattingApi {
+    readonly shapeId: ShapeId;
+    getSnapshot(): TextFormattingSnapshot | null;
+    subscribe(listener: () => void): () => void;
+    focus(): void;
+    toggle(format: TextInlineFormat): boolean;
+    setBlockType(blockType: TextBlockType): boolean;
+    setColor(color: string | null): boolean;
+    setBackgroundColor(color: string | null): boolean;
+    setFont(font: TextShapeFont | null): boolean;
+    setSize(size: TextShapeSize | null): boolean;
+    setTextAlign(align: TextShapeAlign): boolean;
+    setLink(href: string | null): boolean;
+    clearFormatting(): boolean;
+    /**
+     * Escape hatch for extensions that need native Tiptap commands. Prefer the
+     * semantic methods above so shape defaults, sanitization, and rendering stay
+     * synchronized.
+     */
+    getUnsafeTiptapEditor(): TiptapEditor | null;
+}
+export interface TextTiptapEditorHandle {
+    readonly shapeId: ShapeId;
+    readonly formatting: TextFormattingApi;
+}
+export type TextTiptapEditorChangeHandler = (handle: TextTiptapEditorHandle | null) => void;

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

@@ -0,0 +1,6 @@
+import type { Editor } from "../canvas-core/index";
+import type { TextFormattingApi, TextFormattingSnapshot } from "./textFormatting";
+export declare function activateTextFormattingSession(editor: Editor, api: TextFormattingApi): () => void;
+export declare function getActiveTextFormattingApi(editor: Editor): TextFormattingApi | null;
+export declare function getActiveTextFormattingSnapshot(editor: Editor): TextFormattingSnapshot | null;
+export declare function subscribeToTextFormattingSession(editor: Editor, listener: () => void): () => void;

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

@@ -0,0 +1,4 @@
+import { type Editor, type LandInteractionHandler, type Vec, type ShapeId } from "../canvas-core/index";
+export declare function createTextInteractionHandler(): LandInteractionHandler;
+export declare function startEditingPathLabel(editor: Editor, ownerShapeId: ShapeId, pagePoint?: Vec): boolean;
+export declare function startEditingGeoLabel(editor: Editor, ownerShapeId: ShapeId): boolean;

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

@@ -0,0 +1,72 @@
+import { type Editor, type ShapeEditingEntryMode, type ShapeId, type ShapeParentId, type ShapeRecord, type ShapeTransformFields } from "../canvas-core/index";
+import type { TextShapeProps, TextShapeRecord } from "./textTypes";
+export declare const PATH_LABEL_BINDING_TYPE = "path-label";
+export declare const GEO_LABEL_BINDING_TYPE = "geo-label";
+export declare const PATH_LABEL_MAX_WIDTH = 120;
+export declare const PATH_LABEL_MIN_WIDTH = 24;
+export declare const PATH_LABEL_PADDING = 4.25;
+export declare const GEO_LABEL_MIN_WIDTH = 16;
+export declare const GEO_LABEL_PADDING = 16;
+export type TextLabelBindingType = typeof PATH_LABEL_BINDING_TYPE | typeof GEO_LABEL_BINDING_TYPE;
+export interface TextLabelBehavior {
+    selectionTarget: "label" | "owner";
+    hoverTarget: "label" | "owner";
+    hoverDecorationTarget: "label" | "owner";
+    translateTarget: "label" | "owner";
+    canSnap: boolean;
+    canReceiveTerminalBinding: boolean;
+    contributesToSelectionFrame: boolean;
+    canUseSelectionResizeHandles: boolean;
+    canUseSelectionRotateHandle: boolean;
+    canPlaceCaretWhenOwnerSelected: boolean;
+    showsCompanionFrameWhenOwnerSelected: boolean;
+}
+export interface TextLabelTargetInfo {
+    label: TextShapeRecord;
+    ownerId: ShapeId;
+    bindingType: TextLabelBindingType;
+    behavior: TextLabelBehavior;
+}
+export interface TextLabelLayoutConstraints {
+    minWidth: number;
+    maxWidth: number;
+    paddingInline: number;
+    normalizedCenterX?: number;
+}
+export declare function getTextLabelPaddingInline(constraints: TextLabelLayoutConstraints | null, width: number): number;
+export interface TextLabelCreateOptions {
+    bindingType: TextLabelBindingType;
+    owner: ShapeRecord;
+    operationKind: string;
+    index: string;
+    layout: Pick<TextShapeRecord, "x" | "y" | "rotation"> & {
+        props: Pick<TextShapeProps, "w"> & Partial<TextShapeProps>;
+    };
+    bindingProps?: Record<string, unknown>;
+}
+export type TextLabelPageLayout = TextLabelCreateOptions["layout"];
+export declare function getTextLabelOwnerPageRotation(editor: Editor, owner: ShapeRecord): number;
+export declare function getTextLabelParentLocalTransform(editor: Editor, label: TextShapeRecord, targetParentId: ShapeParentId, pageLayout: TextLabelPageLayout): ShapeTransformFields | null;
+export declare function getTextLabelShapeForOwner(editor: Editor, ownerId: ShapeId, bindingType: TextLabelBindingType): TextShapeRecord | null;
+export declare function createBoundTextLabelShape(editor: Editor, options: TextLabelCreateOptions): TextShapeRecord | null;
+export declare function getTextLabelTargetInfo(editor: Editor, shapeId: ShapeId): TextLabelTargetInfo | null;
+export declare function getTextLabelLayoutConstraintsForOwner(editor: Editor, label: TextShapeRecord, owner: ShapeRecord, bindingType: TextLabelBindingType): TextLabelLayoutConstraints;
+export declare function getTextLabelLayoutConstraints(editor: Editor, label: TextShapeRecord): TextLabelLayoutConstraints | null;
+export declare function getTextLabelBehavior(bindingType: TextLabelBindingType): TextLabelBehavior;
+export declare function getTextLabelSelectionTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTextLabelHoverTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTextLabelHoverDecorationTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTextLabelTranslateTargetId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function textLabelCanReceiveTerminalBinding(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelCanSnap(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelContributesToSelectionFrame(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelCanUseSelectionResizeHandles(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelCanUseSelectionRotateHandle(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function textLabelShowsCompanionFrameWhenOwnerSelected(editor: Editor, shapeId: ShapeId): boolean | null;
+export declare function canPlaceCaretInTextShapeFromSelection(editor: Editor, shapeId: ShapeId): boolean;
+export declare function startEditingTextLabel(editor: Editor, label: TextShapeRecord, options: {
+    editOperationKind: string;
+    createOperationKind: string;
+    isExisting: boolean;
+    entryMode?: ShapeEditingEntryMode;
+}): void;

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

@@ -0,0 +1,20 @@
+import { type ComponentType, type ReactNode } from "react";
+export interface TextLinkPopoverPresenterProps {
+    anchorElement: HTMLElement;
+    href: string;
+    kind: "external" | "internal";
+    unavailable: boolean;
+    onOpen(): void;
+    onPopoverPointerEnter(): void;
+    onPopoverPointerLeave(): void;
+}
+export type TextLinkPopoverPresenter = ComponentType<TextLinkPopoverPresenterProps>;
+export declare function TextLinkPopoverPresenterProvider({ children, presenter, }: {
+    children: ReactNode;
+    presenter: TextLinkPopoverPresenter | null;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTextLinkPopoverPresenter(): TextLinkPopoverPresenter | null;
+export declare function shouldShowTextLinkPopover({ isEditing, isOnlySelected, }: {
+    isEditing: boolean;
+    isOnlySelected: boolean;
+}): boolean;

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

@@ -0,0 +1,19 @@
+import type { ShapeId } from "../canvas-core/index";
+import { type ReactNode } from "react";
+import type { RichTextDocument } from "./textTypes";
+export interface RichTextSearchRange {
+    readonly from: number;
+    readonly to: number;
+}
+export interface TextSearchHighlightTarget extends RichTextSearchRange {
+    readonly shapeId: ShapeId;
+}
+export interface TextSearchHighlightState {
+    readonly query: string;
+    readonly activeMatch: TextSearchHighlightTarget | null;
+}
+export declare function TextSearchHighlightProvider({ activeMatch, children, query, }: TextSearchHighlightState & {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTextSearchHighlightState(): TextSearchHighlightState;
+export declare function findRichTextSearchMatches(richText: RichTextDocument, query: string): RichTextSearchRange[];

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

@@ -0,0 +1,21 @@
+import type { BaseRecord, ChangeSource, Editor, ShapeId, ShapeParentId } from "../canvas-core/index";
+import type { RichTextDocument, TextShapeProps, TextShapeRecord } from "./textTypes";
+export interface CreateTextShapeInput {
+    x: number;
+    y: number;
+    props?: Partial<TextShapeProps>;
+    parentId?: ShapeParentId;
+    index?: string;
+    rotation?: number;
+    scaleX?: number;
+    scaleY?: number;
+    meta?: Record<string, unknown>;
+}
+export declare function isTextShapeRecord(record: BaseRecord | null | undefined): record is TextShapeRecord;
+export declare function cloneTextShapeProps(props: TextShapeProps): TextShapeProps;
+export declare function getDefaultTextShapeProps(editor: Editor): TextShapeProps;
+export declare function createTextShape(editor: Editor, input: CreateTextShapeInput, source?: ChangeSource): TextShapeRecord;
+export declare function updateTextShapeRichText(editor: Editor, shapeId: ShapeId, richText: RichTextDocument, options?: {
+    w?: number;
+    h?: number;
+}, source?: ChangeSource): void;

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

@@ -0,0 +1,9 @@
+import { type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { TextShapeRecord } from "./textTypes";
+import type { TextFontCatalog } from "./textFonts";
+export declare class TextShapeSvgExporter implements ShapeSvgExporter<TextShapeRecord> {
+    private readonly fontCatalog;
+    readonly type: "text";
+    constructor(fontCatalog: TextFontCatalog);
+    toSvg(shape: TextShapeRecord, context: SvgExportContext): SvgNode | null;
+}

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

@@ -0,0 +1,24 @@
+import { Box, ShapeUtil, type ShapeId, type ShapeEditEndResult, type ShapeGeometryInput, type ShapeHoverTargetInput, type ShapeSelectionFrameInput, type ShapeSelectionResizeInput, type ShapeSelectionResizeModesInput, type ShapeSelectionTranslateInput, type ShapeUpdate } from "../canvas-core/index";
+import { type TextShapeProps, type TextShapeRecord } from "./textTypes";
+export declare class TextShapeUtil extends ShapeUtil<TextShapeRecord> {
+    readonly type: "text";
+    getDefaultProps(): TextShapeProps;
+    validateProps(props: unknown): TextShapeProps;
+    getPositionedBounds(shape: TextShapeRecord): Box;
+    getLocalBounds(shape: TextShapeRecord): Box;
+    getRenderBounds(shape: TextShapeRecord): Box;
+    getExportBounds(shape: TextShapeRecord): Box;
+    canSnap(shape: TextShapeRecord, input?: ShapeGeometryInput): boolean;
+    canReceiveTerminalBinding(shape: TextShapeRecord, input?: ShapeGeometryInput): boolean;
+    canEdit(_shape: TextShapeRecord): boolean;
+    contributesToSelectionFrame(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionResizeHandles(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionRotateHandle(shape: TextShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    getSelectionTargetId(shape: TextShapeRecord, input: ShapeSelectionFrameInput): ShapeId;
+    getHoverTargetId(shape: TextShapeRecord, input: ShapeHoverTargetInput): ShapeId;
+    getHoverDecorationTargetId(shape: TextShapeRecord, input: ShapeHoverTargetInput): ShapeId;
+    getTranslateTargetId(shape: TextShapeRecord, input: ShapeSelectionTranslateInput): ShapeId;
+    resizeSelectionBounds(shape: TextShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    getAllowedSelectionResizeModes(_shape: TextShapeRecord, input: ShapeSelectionResizeModesInput): readonly ["free"] | readonly ["aspect_ratio_locked"];
+    onEditEnd(shape: TextShapeRecord): ShapeEditEndResult | void;
+}

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

@@ -0,0 +1,18 @@
+import type { TextShapeAlign, TextShapeFont, TextShapeRecord, TextShapeSize } from "./textTypes";
+import { DEFAULT_TEXT_FONT, type TextFontCatalog } from "./textFonts";
+export { DEFAULT_TEXT_FONT };
+export declare const TEXT_SIZE_PRESETS: {
+    readonly s: 14;
+    readonly m: 16;
+    readonly l: 20;
+    readonly xl: 28;
+};
+export declare const DEFAULT_TEXT_SIZE: TextShapeSize;
+export declare function normalizeTextSize(value: unknown, fallback?: TextShapeSize): TextShapeSize;
+export declare function getTextFontFamily(font: TextShapeFont, fontCatalog: TextFontCatalog): string;
+export declare function getTextFontSize(size: TextShapeSize): number;
+export declare function getTextLineHeight(size: TextShapeSize): number;
+export declare function getTextMinHeight(size: TextShapeSize, scale?: number): number;
+export declare function getTextAlign(align: TextShapeAlign): "left" | "center" | "right";
+export declare function getTextAnchorX(align: TextShapeRecord["props"]["textAlign"], width: number): number;
+export declare function getSvgTextAnchor(align: TextShapeRecord["props"]["textAlign"]): "start" | "middle" | "end";

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

@@ -0,0 +1,4 @@
+import { StateNode, type Editor } from "../canvas-core/index";
+export declare class TextTool extends StateNode {
+    constructor(editor: Editor);
+}

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

@@ -0,0 +1,29 @@
+import type { ShapeColor, ShapeRecordBase } from "../canvas-core/index";
+import type { JSONContent } from "@tiptap/core";
+export type RichTextJsonValue = string | number | boolean | null | RichTextJsonValue[] | {
+    [key: string]: RichTextJsonValue;
+};
+export interface RichTextDocument {
+    type: "doc";
+    attrs?: Record<string, RichTextJsonValue>;
+    content: JSONContent[];
+}
+export type TextShapeFont = string;
+export type TextShapeSize = number;
+export type TextShapeAlign = "start" | "middle" | "end";
+export interface TextShapeProps {
+    richText: RichTextDocument;
+    w: number;
+    h: number;
+    autoSize: boolean;
+    scale: number;
+    font: TextShapeFont;
+    size: TextShapeSize;
+    color: ShapeColor;
+    backgroundColor: ShapeColor;
+    textAlign: TextShapeAlign;
+}
+export interface TextShapeRecord extends ShapeRecordBase<"text", TextShapeProps> {
+    type: "text";
+    props: TextShapeProps;
+}

package/_vendor/plugin-flow/_vendor/signals/atom.d.ts

@@ -0,0 +1,11 @@
+import type { SignalGraph } from "./core";
+import type { Signal } from "./types";
+export interface AtomOptions<T> {
+    isEqual?: (left: T, right: T) => boolean;
+}
+export interface Atom<T> extends Signal<T> {
+    set(value: T): T;
+    update(updater: (value: T) => T): T;
+}
+export declare function createAtom<T>(graph: SignalGraph, name: string, initialValue: T, options?: AtomOptions<T>): Atom<T>;
+export declare function isAtom(value: unknown): value is Atom<unknown>;

package/_vendor/plugin-flow/_vendor/signals/computed.d.ts

@@ -0,0 +1,13 @@
+import type { SignalGraph } from "./core";
+import type { Signal } from "./types";
+declare const UNINITIALIZED_VALUE: unique symbol;
+export type UNINITIALIZED = typeof UNINITIALIZED_VALUE;
+export { UNINITIALIZED_VALUE as UNINITIALIZED };
+export interface ComputedOptions<T> {
+    isEqual?: (left: T, right: T) => boolean;
+}
+export interface Computed<T> extends Signal<T> {
+    readonly isComputed: true;
+}
+export declare function createComputed<T>(graph: SignalGraph, name: string, derive: (previous: T | UNINITIALIZED) => T, options?: ComputedOptions<T>): Computed<T>;
+export declare function isComputed(value: unknown): value is Computed<unknown>;