@yuzhouu/canvas-kit 0.1.9 → 0.1.11

package/_vendor/plugin-path/pathGeometry.d.ts

@@ -0,0 +1,74 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { PathHandle, PathNode, PathShapeProps, PathShapeRecord, PathSubpath } from "./types";
+export interface FlattenedPathSubpath {
+    id: string;
+    closed: boolean;
+    points: Vec[];
+}
+export interface PathSegmentHit {
+    subpathId: string;
+    startNodeId: string;
+    endNodeId: string;
+    t: number;
+    point: Vec;
+    distance: number;
+}
+export interface PathNodeRef {
+    subpathId: string;
+    nodeId: string;
+}
+export type PathNodeOperation = "merge" | "join" | "separate";
+export interface PathNodeOperationResult {
+    subpaths: PathSubpath[];
+    selectedNodes: PathNodeRef[];
+    primaryNode: PathNodeRef | null;
+}
+export interface PathShapeGeometry {
+    path: string | null;
+    pointBounds: Box;
+    localBounds: Box;
+    renderBounds: Box;
+    outlineVertices: Vec[];
+    flattenedSubpaths: FlattenedPathSubpath[];
+}
+export interface NormalizedPathShape {
+    x: number;
+    y: number;
+    subpaths: PathSubpath[];
+    geometry: PathShapeGeometry;
+}
+export declare function clonePathHandle(handle: PathHandle): PathHandle;
+export declare function clonePathNode(node: PathNode): PathNode;
+export declare function clonePathSubpath(subpath: PathSubpath): PathSubpath;
+export declare function clonePathSubpaths(subpaths: readonly PathSubpath[]): PathSubpath[];
+export declare function getNodePoint(node: PathNode): Vec;
+export declare function getNodeInPoint(node: PathNode): Vec;
+export declare function getNodeOutPoint(node: PathNode): Vec;
+export declare function flattenPathSubpath(subpath: PathSubpath): FlattenedPathSubpath;
+export declare function getPathShapeLocalGeometry(shape: Pick<PathShapeRecord, "props">): PathShapeGeometry;
+export declare function translatePathSubpaths(subpaths: readonly PathSubpath[], dx: number, dy: number): PathSubpath[];
+export declare function mapPathSubpaths(subpaths: readonly PathSubpath[], mapPoint: (point: Vec) => Vec): PathSubpath[];
+export declare function normalizePathShapeFromPageSubpaths(pageSubpaths: readonly PathSubpath[], props: Pick<PathShapeProps, "strokeWidth" | "fill" | "stroke" | "fillRule">): NormalizedPathShape;
+export declare function resizePathShapeToLocalBounds(shape: PathShapeRecord, targetBounds: Box): PathSubpath[];
+export declare function getPathShapePageSubpaths(shape: PathShapeRecord, localToPage: {
+    applyToPoint(point: Vec): Vec;
+}): PathSubpath[];
+export declare function getPathShapePagePath(shape: PathShapeRecord, localToPage: {
+    applyToPoint(point: Vec): Vec;
+}): string | null;
+export declare function hitTestPathStroke(flattenedSubpaths: readonly FlattenedPathSubpath[], point: Vec, margin: number): boolean;
+export declare function findPathSegmentAtLocalPoint(subpaths: readonly PathSubpath[], point: Vec, margin: number): PathSegmentHit | null;
+export declare function hitTestPathFill(flattenedSubpaths: readonly FlattenedPathSubpath[], point: Vec, fillRule: "nonzero" | "evenodd"): boolean;
+export declare function getPathSubpathById(subpaths: readonly PathSubpath[], subpathId: string): PathSubpath | null;
+export declare function getPathNodeById(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string): PathNode | null;
+export declare function updatePathNode(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string, update: (node: PathNode) => PathNode): PathSubpath[];
+export declare function updatePathNodeEntries(subpaths: readonly PathSubpath[], entries: readonly PathNodeRef[], update: (node: PathNode) => PathNode): PathSubpath[];
+export declare function setPathNodeCurveHandles(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string): PathSubpath[];
+export declare function removePathNodeHandles(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string): PathSubpath[];
+export declare function removePathNodeEntries(subpaths: readonly PathSubpath[], entries: readonly PathNodeRef[]): PathSubpath[];
+export declare function canApplyPathNodeOperation(subpaths: readonly PathSubpath[], refs: readonly PathNodeRef[], operation: PathNodeOperation): boolean;
+export declare function applyPathNodeOperation(subpaths: readonly PathSubpath[], refsInput: readonly PathNodeRef[], operation: PathNodeOperation, primaryRef?: PathNodeRef | null): PathNodeOperationResult | null;
+export declare function insertPathNodeAfter(subpaths: readonly PathSubpath[], subpathId: string, afterNodeId: string, node: PathNode): PathSubpath[];
+export declare function insertPathNodeAtSegment(subpaths: readonly PathSubpath[], hit: PathSegmentHit, nodeId: string): PathSubpath[];
+export declare function arePathSubpathsEmpty(subpaths: readonly PathSubpath[]): boolean;
+export declare function sanitizePathSubpaths(subpaths: readonly PathSubpath[]): PathSubpath[];

package/_vendor/plugin-path/pathHandles.d.ts

@@ -0,0 +1,18 @@
+export declare const PATH_NODE_HANDLE_TYPE = "path.node";
+export declare const PATH_CONTROL_HANDLE_TYPE = "path.control";
+export type PathControlHandleKind = "in" | "out";
+export interface PathNodeHandleInfo {
+    type: typeof PATH_NODE_HANDLE_TYPE;
+    subpathId: string;
+    nodeId: string;
+}
+export interface PathControlHandleInfo {
+    type: typeof PATH_CONTROL_HANDLE_TYPE;
+    subpathId: string;
+    nodeId: string;
+    handle: PathControlHandleKind;
+}
+export type PathHandleInfo = PathNodeHandleInfo | PathControlHandleInfo;
+export declare function createPathNodeHandleId(subpathId: string, nodeId: string): string;
+export declare function createPathControlHandleId(subpathId: string, nodeId: string, handle: PathControlHandleKind): string;
+export declare function parsePathHandle(type: string, id: string): PathHandleInfo | null;

package/_vendor/plugin-path/pathHistory.d.ts

@@ -0,0 +1,13 @@
+import { type Editor, type ShapeId } from "../canvas-core/index";
+import { type PathShapeRecord } from "./types";
+export type PathHistoryMode = "create" | "edit";
+interface PathHistorySessionOptions {
+    onApply?: (shape: PathShapeRecord) => void;
+    onBoundaryUndo?: () => boolean;
+}
+export declare function startPathHistorySession(editor: Editor, mode: PathHistoryMode, shapeId: ShapeId, options?: PathHistorySessionOptions): boolean;
+export declare function recordPathHistoryStep(editor: Editor, shapeId: ShapeId): boolean;
+export declare function replaceCurrentPathHistoryStep(editor: Editor, shapeId: ShapeId): boolean;
+export declare function endPathHistorySession(editor: Editor, mode: PathHistoryMode, shapeId: ShapeId): boolean;
+export declare function hasPathHistoryNetChanges(editor: Editor, mode: PathHistoryMode, shapeId: ShapeId): boolean;
+export {};

package/_vendor/plugin-path/pathInteractions.d.ts

@@ -0,0 +1,7 @@
+import { type Editor, type LandInteractionHandler, type SelectionHandleInteractionHandler } from "../canvas-core/index";
+import { type PathNodeOperation, type PathNodeRef } from "./pathGeometry";
+import { type PathShapeRecord } from "./types";
+export declare function deletePathEditNodes(editor: Editor, shape: PathShapeRecord, entries: readonly PathNodeRef[]): void;
+export declare function runSelectedPathNodeOperation(editor: Editor, operation: PathNodeOperation): boolean;
+export declare function createPathSelectionHandleInteractionHandler(): SelectionHandleInteractionHandler;
+export declare function createPathInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-path/pathShapeUtil.d.ts

@@ -0,0 +1,30 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushSelectInput, type ShapeBrushWrapInput, type ShapeBindingPointInput, type ShapeHandleSnapGeometry, type ShapeLineSegmentHitTestInput, type ShapePointHitTestInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionFrameInput, type ShapeSelectionOverlayInfo, type ShapeSelectionOverlayInfoInput, type ShapeSelectionResizeInput, type ShapeTerminalBindingOutline, type ShapeUpdate } from "../canvas-core/index";
+import { type PathShapeProps, type PathShapeRecord } from "./types";
+export declare class PathShapeUtil extends ShapeUtil<PathShapeRecord> {
+    readonly type: "path";
+    getDefaultProps(): PathShapeProps;
+    validateProps(props: unknown): PathShapeProps;
+    getPositionedBounds(shape: PathShapeRecord): Box;
+    getLocalBounds(shape: PathShapeRecord): Box;
+    getRenderBounds(shape: PathShapeRecord): Box;
+    getExportBounds(shape: PathShapeRecord): Box;
+    getSelectionResizeLocalBounds(shape: PathShapeRecord): Box;
+    resizeSelectionBounds(shape: PathShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    getPositionedOutlineVertices(shape: PathShapeRecord): Vec[];
+    getTerminalBindingOutlines(shape: PathShapeRecord): readonly ShapeTerminalBindingOutline[];
+    resolveBindingPoint(shape: PathShapeRecord, input: ShapeBindingPointInput): Vec;
+    getHandleSnapGeometry(shape: PathShapeRecord): ShapeHandleSnapGeometry;
+    canReceiveTerminalBinding(_shape: PathShapeRecord): boolean;
+    canEdit(_shape: PathShapeRecord): boolean;
+    canUseSelectionResizeHandles(shape: PathShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionRotateHandle(shape: PathShapeRecord, input: ShapeSelectionFrameInput): boolean;
+    getSelectionHandleAnchors(shape: PathShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+    getSelectionOverlayInfo(shape: PathShapeRecord, input: ShapeSelectionOverlayInfoInput): ShapeSelectionOverlayInfo;
+    hitTest(shape: PathShapeRecord, positionedPoint: Vec, _input?: ShapePointHitTestInput): boolean;
+    hitTestLineSegment(shape: PathShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+    isWrappedByBrush(shape: PathShapeRecord, input: ShapeBrushWrapInput): boolean;
+    canSelectByBrush(shape: PathShapeRecord, input: ShapeBrushSelectInput): boolean;
+    onEditEnd(shape: PathShapeRecord): {
+        deleteShapeIds: `shape:${string}`[];
+    } | undefined;
+}

package/_vendor/plugin-path/pathSvg.d.ts

@@ -0,0 +1,3 @@
+import type { PathSubpath } from "./types";
+export declare function getPathSvgPathFromSubpath(subpath: PathSubpath): string | null;
+export declare function getPathSvgPathFromSubpaths(subpaths: readonly PathSubpath[]): string | null;

package/_vendor/plugin-path/pathTool.d.ts

@@ -0,0 +1,42 @@
+import { StateNode, Vec, type Editor, type ShapeId } from "../canvas-core/index";
+import { type PathNode } from "./types";
+interface PathDraft {
+    shapeId: ShapeId;
+    subpathId: string;
+    lastNodeId: string;
+    createdShape: boolean;
+    previewNodeId: string | null;
+}
+interface DraggingPathNodeInfo {
+    shapeId: ShapeId;
+    subpathId: string;
+    nodeId: string;
+    originPagePoint: Vec;
+    startNode: PathNode;
+    finishOnPointerUp: boolean;
+}
+interface PathPointerModifiers {
+    altKey: boolean;
+    shiftKey: boolean;
+}
+export declare class PathTool extends StateNode {
+    draft: PathDraft | null;
+    private operation;
+    constructor(editor: Editor);
+    protected onEnter(): void;
+    protected onExit(): void;
+    isInInitialState(): boolean;
+    startOrExtend(point: Vec, modifiers: PathPointerModifiers): DraggingPathNodeInfo | null;
+    updateNodeDrag(info: DraggingPathNodeInfo, point: Vec, modifiers: PathPointerModifiers): void;
+    updatePreview(point: Vec, modifiers: Pick<PathPointerModifiers, "shiftKey">): void;
+    private canFinishDraft;
+    finishDraft(options?: {
+        switchToSelect?: boolean;
+    }): void;
+    finishDraftAndEdit(): void;
+    cancelDraft(): void;
+    hasDraft(): boolean;
+    private commitOperation;
+    private cancelOperation;
+}
+export {};

package/_vendor/plugin-path/productRuntime.d.ts

@@ -0,0 +1,15 @@
+import { type CanvasPluginSetupContext } from "../canvas-plugin-sdk/index";
+export declare const PATH_EDIT_TOOLBAR_ACTION_ID = "path.edit";
+export declare const PATH_EDIT_DONE_ACTION_ID = "path.edit.done";
+export declare const PATH_EDIT_SNAP_ACTION_ID = "path.edit.snap-nodes";
+export declare const PATH_BOOLEAN_UNION_ACTION_ID = "path.boolean.union";
+export declare const PATH_BOOLEAN_SUBTRACT_ACTION_ID = "path.boolean.subtract";
+export declare const PATH_BOOLEAN_INTERSECT_ACTION_ID = "path.boolean.intersect";
+export declare const PATH_BOOLEAN_XOR_ACTION_ID = "path.boolean.xor";
+export declare const PATH_NODE_DELETE_ACTION_ID = "path.node.delete";
+export declare const PATH_NODE_MAKE_CURVE_ACTION_ID = "path.node.make-curve";
+export declare const PATH_NODE_REMOVE_HANDLES_ACTION_ID = "path.node.remove-handles";
+export declare const PATH_NODE_MERGE_ACTION_ID = "path.node.merge";
+export declare const PATH_NODE_JOIN_ACTION_ID = "path.node.join";
+export declare const PATH_NODE_SEPARATE_ACTION_ID = "path.node.separate";
+export declare function setupPathProduct(context: CanvasPluginSetupContext): void;

package/_vendor/plugin-path/types.d.ts

@@ -0,0 +1,36 @@
+import { type BaseRecord, type ShapeColor, type ShapeRecordBase } from "../canvas-core/index";
+export declare const PATH_FILL_RULES: readonly ["nonzero", "evenodd"];
+export declare const PATH_NODE_KINDS: readonly ["corner", "smooth", "symmetric"];
+export type PathFillRule = (typeof PATH_FILL_RULES)[number];
+export type PathNodeKind = (typeof PATH_NODE_KINDS)[number];
+export interface PathHandle {
+    dx: number;
+    dy: number;
+}
+export interface PathNode {
+    id: string;
+    x: number;
+    y: number;
+    in?: PathHandle | null;
+    out?: PathHandle | null;
+    kind: PathNodeKind;
+}
+export interface PathSubpath {
+    id: string;
+    closed: boolean;
+    nodes: PathNode[];
+}
+export interface PathShapeProps {
+    subpaths: PathSubpath[];
+    fill: ShapeColor;
+    stroke: ShapeColor;
+    strokeWidth: number;
+    fillRule: PathFillRule;
+}
+export interface PathShapeRecord extends ShapeRecordBase<"path", PathShapeProps> {
+    type: "path";
+    props: PathShapeProps;
+}
+export declare function isPathShapeRecord(record: BaseRecord | null | undefined): record is PathShapeRecord;
+export declare function isPathFillRule(value: unknown): value is PathFillRule;
+export declare function isPathNodeKind(value: unknown): value is PathNodeKind;

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

@@ -0,0 +1,20 @@
+import type { ShapeColor } from "../canvas-core/index";
+import { type CanvasPluginApi, type CanvasShapeRef } from "../canvas-plugin-sdk/index";
+import type { TextShapeProps } 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 TextApi {
+    create(input: TextInput): CanvasShapeRef<"text"> | null;
+}
+export declare const textApiToken: import("../canvas-plugin-sdk/index").ProductApiToken<TextApi>;
+export declare const textPluginApi: CanvasPluginApi<TextApi>;

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

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

package/_vendor/plugin-text/capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { TextFontCatalog } from "./textFonts";
+export declare const textFontCatalogCapability: import("../canvas-plugin-sdk/index").CanvasPluginValueToken<TextFontCatalog>;

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

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

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

@@ -1,4 +1,4 @@
-import { type LandFeatureBundle } from "../canvas-react/host/index";
-import { type TextExtensionOptions } from "./textFonts";
-export declare function createTextFeatureBundle(options?: Readonly<TextExtensionOptions>): LandFeatureBundle;
-export declare const Text: import("../canvas-react/host/index").ConfigurableLandExtension<TextExtensionOptions>;
+import { type CanvasPlugin } from "../canvas-plugin-sdk/index";
+import { type TextPluginOptions } from "./textFonts";
+export declare function createTextPlugin(options?: Readonly<Partial<TextPluginOptions>>): CanvasPlugin;
+export declare const Text: CanvasPlugin<import("../canvas-plugin-sdk/index").CanvasPluginSetup<import("../canvas-plugin-sdk/index").CanvasPluginSetupContext<import("../canvas-plugin-sdk/index").CanvasPluginApiContext>>>;

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

@@ -1,8 +1,6 @@
 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_EDGE_PADDING = 16;
-export declare const GEO_LABEL_MIN_WIDTH = 16;
 export declare const GEO_LABEL_INDEX_SUFFIX = ".label";
 export interface GeoLabelBindingProps {
     normalizedAnchor: {
@@ -19,7 +17,11 @@ export declare class GeoLabelBindingUtil extends BindingUtil<GeoLabelBindingReco
     readonly type = "geo-label";
     getDefaultProps(): GeoLabelBindingProps;
     validateProps(props: unknown): GeoLabelBindingProps;
-    canBind(_editor: Editor, _binding: GeoLabelBindingRecord, context: {
+    canBind(_editor: Editor, binding: GeoLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    canUseShapeHierarchy(_binding: GeoLabelBindingRecord, context: {
         fromShape: ShapeRecord;
         toShape: ShapeRecord;
     }): boolean;
@@ -38,6 +40,7 @@ export declare class GeoLabelBindingUtil extends BindingUtil<GeoLabelBindingReco
     }): BindingUtilEffect | void;
     onBeforeDeleteBinding(editor: Editor, binding: GeoLabelBindingRecord): BindingUtilEffect | void;
     getExportShapeIds(_editor: Editor, binding: GeoLabelBindingRecord): TextShapeRecord["id"][];
+    getShapeHierarchyRootId(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"> & {

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

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

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

@@ -1,10 +1,11 @@
 import { type CSSProperties } from "react";
 import { type Editor as TiptapEditor } from "@tiptap/react";
-import type { Editor as LandEditor } from "../../canvas-core/index";
+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 {
+export interface TiptapTextEditorHandle extends TextTiptapEditorHandle {
     readonly editor: TiptapEditor;
     readonly controller: TiptapTextEditorController;
 }
@@ -15,6 +16,8 @@ export interface TiptapTextEditorProps {
     initialRichText: RichTextDocument;
     className: string;
     editorStyle: CSSProperties;
+    formattingToolbar?: boolean;
+    onTiptapEditorChange?: TextTiptapEditorChangeHandler;
     onReady(handle: TiptapTextEditorHandle): void;
     onDispose(handle: TiptapTextEditorHandle): void;
     onRichTextChange(input: {
@@ -23,4 +26,4 @@ export interface TiptapTextEditorProps {
         richText: RichTextDocument;
     }): void;
 }
-export declare function TiptapTextEditor({ landEditor, shape, fontCatalog, initialRichText, className, editorStyle, onReady, onDispose, onRichTextChange, }: TiptapTextEditorProps): import("react/jsx-runtime").JSX.Element;
+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-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-text/host/richTextRendering.d.ts

@@ -3,9 +3,8 @@ import type { RichTextDocument } from "../textTypes";
 export interface RichTextRenderLinkHandlers {
     onPointerEnter?(input: {
         href: string;
-        path: readonly number[];
         element: HTMLSpanElement;
     }): void;
     onPointerLeave?(): void;
 }
-export declare function renderRichTextDocument(richText: RichTextDocument, linkHandlers?: RichTextRenderLinkHandlers): ReactNode;
+export declare function renderRichTextDocument(richText: RichTextDocument, linkHandlers?: RichTextRenderLinkHandlers, defaultBackgroundColor?: string): ReactNode;

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

@@ -1,4 +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): CSSProperties;
+export declare function useTextEditingBoxStyle(shape: TextShapeRecord, fontCatalog: TextFontCatalog, paddingInline?: number): CSSProperties;

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

@@ -11,7 +11,7 @@ export declare function focusTextEditorWhenMounted({ editor, controller, shapeId
     onApplied?: (request: ShapeEditingEntryRequest | null) => void;
     attempt?: number;
 }): void;
-export declare function useTextEditingEntryFocus({ editor, shapeId, session, tiptapEditor, richTextController, entryRequest, consumedEntryRequestIdRef, }: {
+export declare function useTextEditingEntryFocus({ editor, shapeId, session, tiptapEditor, richTextController, entryRequest, consumedEntryRequestIdRef, onEntryFocusApplied, }: {
     editor: Editor;
     shapeId: TextShapeRecord["id"];
     session: ShapeEditingSession;
@@ -19,4 +19,5 @@ export declare function useTextEditingEntryFocus({ editor, shapeId, session, tip
     richTextController: TiptapTextEditorController | null;
     entryRequest: ShapeEditingEntryRequest | null;
     consumedEntryRequestIdRef: MutableRefObject<number | null>;
+    onEntryFocusApplied?: () => void;
 }): void;

package/_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-text/host/textMeasurement.d.ts

@@ -1,13 +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): {
+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): {
+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;

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

@@ -2,8 +2,10 @@ 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";
 export interface TextShapeRendererRuntime {
+    hasEditingSession: boolean;
     isEditingThisShape: boolean;
     editingHost: ReactNode;
 }
-export declare function useTextShapeRendererRuntime(editor: Editor, shape: TextShapeRecord, fontCatalog: TextFontCatalog): TextShapeRendererRuntime;
+export declare function useTextShapeRendererRuntime(editor: Editor, shape: TextShapeRecord, fontCatalog: TextFontCatalog, formattingToolbar?: boolean, onTiptapEditorChange?: TextTiptapEditorChangeHandler): TextShapeRendererRuntime;

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

@@ -2,12 +2,14 @@ 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;
@@ -28,8 +30,9 @@ export interface TiptapTextEditorController {
     } | undefined;
     onCompositionStateChange(listener: (isComposing: boolean) => void): () => void;
 }
-export declare function createTiptapTextEditorController({ shapeId, editor, fontCatalog, }: {
+export declare function createTiptapTextEditorController({ shapeId, editor, fontCatalog, landEditor, }: {
     shapeId: ShapeId;
     editor: TiptapEditor;
     fontCatalog: TextFontCatalog;
+    landEditor: Editor;
 }): TiptapTextEditorController;

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

@@ -1,8 +1,15 @@
-export { Text, createTextFeatureBundle } from "./feature";
-export { createTextEditorRuntimePlugin } from "./editorRuntime";
+export { Text, createTextPlugin } from "./feature";
+export { textFontCatalogCapability } from "./capabilities";
+export { textApiToken } from "./api";
+export type { TextApi, TextInput } from "./api";
+export { createTextEditorPlugin } from "./editorRuntime";
+export { createTextProductSetup } from "./productRuntime";
 export { createTextCanvasRenderPlugin } from "./canvasRender";
-export { DEFAULT_TEXT_FONT, HOST_TEXT_FONT, createDefaultTextFontCatalog, createDefaultTextExtensionOptions, } from "./textFonts";
+export { DEFAULT_TEXT_FONT, HOST_TEXT_FONT, createDefaultTextFontCatalog, createDefaultTextPluginOptions, createTextFontCatalog, } from "./textFonts";
 export { createRichTextFromPlainText, getPlainTextFromRichText, validateRichTextDocument, } from "./richTextUtils";
 export { isTextShapeRecord, updateTextShapeRichText, } from "./textShapeHelpers";
-export type { TextExtensionOptions, TextFontDefinition, TextFontFaceSource, TextFontSource, TextStylesheetFontSource, TextSystemFontSource, } from "./textFonts";
+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, TextFormattingMixed, TextFormattingSnapshot, TextFormattingTarget, TextFormattingValue, TextInlineFormat, TextTiptapEditorChangeHandler, TextTiptapEditorHandle, } from "./textFormatting";

package/_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;
+    canUseShapeHierarchy(_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"][];
+    getShapeHierarchyRootId(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-text/productRuntime.d.ts

@@ -0,0 +1,6 @@
+import { type CanvasPluginSetup } from "../canvas-plugin-sdk/index";
+import { type TextFontCatalog } from "./textFonts";
+export declare function createTextProductSetup({ fontCatalog, selectionFormattingToolbar, }?: {
+    fontCatalog?: TextFontCatalog;
+    selectionFormattingToolbar?: boolean;
+}): CanvasPluginSetup;

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

@@ -4,9 +4,15 @@ 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;
@@ -14,6 +20,7 @@ export declare function getPlainTextFromRichText(richTextDocument: RichTextDocum
 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): string | undefined;
-export declare function getRichTextMarkStyle(marks: JSONContent["marks"]): RichTextMarkStyle | undefined;
+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;