@yuzhouu/canvas-kit 0.1.9 → 0.1.10

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

@@ -0,0 +1,168 @@
+import type { ShapeColor, ShapeRecordBase } from "../canvas-core/index";
+export type Affine2d = readonly [
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+    e: number,
+    f: number
+];
+export type PackagingUnit = "mm" | "cm" | "m" | "in" | "pt" | "px" | "unitless";
+export type PackagingCoordinateSystem = "top-left-y-down";
+export type PackagingSurfaceSide = "outside" | "inside";
+export interface PackagingDocument {
+    schemaVersion: 1;
+    id: string;
+    revision: string;
+    name: string;
+    unit: PackagingUnit;
+    coordinateSystem: PackagingCoordinateSystem;
+    sheetBounds?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    points: PackagingPoint[];
+    edges: PackagingEdge[];
+    faces: PackagingFace[];
+    surfaces: PackagingSurfaces;
+    source?: {
+        provider?: string;
+        externalId?: string;
+        revision?: string;
+    };
+    meta?: Record<string, unknown>;
+}
+export interface PackagingPoint {
+    id: string;
+    x: number;
+    y: number;
+}
+export interface PackagingCoordinate {
+    x: number;
+    y: number;
+}
+export type PackagingEdgeOperation = "cut" | "crease" | "perforation" | "score" | "half-cut" | "kiss-cut" | "annotation" | "construction" | "custom";
+export type PackagingEdgeGeometry = {
+    type: "line";
+} | {
+    type: "quadratic";
+    control: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: "cubic";
+    control1: {
+        x: number;
+        y: number;
+    };
+    control2: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: "arc";
+    radiusX: number;
+    radiusY: number;
+    rotation: number;
+    largeArc: boolean;
+    sweep: boolean;
+};
+export interface PackagingEdge {
+    id: string;
+    fromPointId: string;
+    toPointId: string;
+    geometry: PackagingEdgeGeometry;
+    operation: PackagingEdgeOperation;
+    visible?: boolean;
+    meta?: Record<string, unknown>;
+}
+export interface PackagingDirectedEdgeRef {
+    edgeId: string;
+    direction: "forward" | "reverse";
+}
+export interface PackagingLoop {
+    edges: PackagingDirectedEdgeRef[];
+}
+export interface PackagingFace {
+    id: string;
+    name?: string;
+    role?: string;
+    outer: PackagingLoop;
+    holes?: PackagingLoop[];
+    artworkFrame?: {
+        uvToDocument: Affine2d;
+    };
+    meta?: Record<string, unknown>;
+}
+export interface PackagingPrepress {
+    bleedContours: PackagingBleedContour[];
+    safeZones: PackagingSafeZone[];
+}
+export interface PackagingSurface {
+    prepress?: PackagingPrepress;
+    meta?: Record<string, unknown>;
+}
+export interface PackagingSurfaces {
+    outside: PackagingSurface;
+    inside: PackagingSurface;
+}
+export interface PackagingBleedContour {
+    id: string;
+    name?: string;
+    cutEdgeIds: string[];
+    minimumBleed: number;
+    contour: PackagingClosedContour;
+    meta?: Record<string, unknown>;
+}
+export interface PackagingSafeZone {
+    id: string;
+    name?: string;
+    faceId: string;
+    minimumClearance: number;
+    contour: PackagingClosedContour;
+    meta?: Record<string, unknown>;
+}
+export interface PackagingClosedContour {
+    start: PackagingCoordinate;
+    segments: PackagingContourSegment[];
+}
+export type PackagingContourSegment = {
+    type: "line";
+    to: PackagingCoordinate;
+} | {
+    type: "quadratic";
+    control: PackagingCoordinate;
+    to: PackagingCoordinate;
+} | {
+    type: "cubic";
+    control1: PackagingCoordinate;
+    control2: PackagingCoordinate;
+    to: PackagingCoordinate;
+} | {
+    type: "arc";
+    radiusX: number;
+    radiusY: number;
+    rotation: number;
+    largeArc: boolean;
+    sweep: boolean;
+    to: PackagingCoordinate;
+};
+export interface PackagingShapeProps {
+    document: PackagingDocument;
+    viewSide: PackagingSurfaceSide;
+    faceFill: ShapeColor;
+    faceFillOverrides: Record<string, ShapeColor>;
+    showBleed: boolean;
+    clipToBleed: boolean;
+    dielineOnTop: boolean;
+    showSafeZones: boolean;
+    showCanvasBoundsMarks: boolean;
+}
+export type PackagingShapeRecord = ShapeRecordBase<"packaging", PackagingShapeProps>;
+export interface PackagingHoverState {
+    packagingShapeId: PackagingShapeRecord["id"];
+    faceId: string;
+}

package/_vendor/plugin-packaging/validation.d.ts

@@ -0,0 +1,3 @@
+import type { PackagingDocument } from "./types";
+export declare function parsePackagingDocument(input: unknown): PackagingDocument;
+export declare function clonePackagingDocument(document: PackagingDocument): PackagingDocument;

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

@@ -0,0 +1 @@
+export declare function PathDraftOverlay(): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1 @@
+export declare function PathEditInsertPreviewOverlay(): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,12 @@
+import { type ShapeColor, type ShapeEditingSession } from "../canvas-core/index";
+import type { PathShapeRecord } from "./types";
+interface PathShapeSvgProps {
+    shape: PathShapeRecord;
+    isHovered?: boolean;
+    shapeEditingSession?: ShapeEditingSession | null;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+}
+export declare function PathShapeSvg({ shape, isHovered, shapeEditingSession, fill, stroke, strokeWidth, }: PathShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

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

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

@@ -0,0 +1,21 @@
+import { type CanvasProductContribution } from "../canvas-plugin-sdk/index";
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import { type PathShapeRecord } from "./types";
+export declare const PATH_EDIT_TOOLBAR_ACTION_ID = "path.edit";
+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 class PathShapeSvgExporter implements ShapeSvgExporter<PathShapeRecord> {
+    readonly type: "path";
+    toSvg(shape: PathShapeRecord, context: SvgExportContext): SvgNode | null;
+}
+export declare function createPathEditorPlugin(): EditorPlugin;
+export declare function createPathProductContribution(): CanvasProductContribution;

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

@@ -0,0 +1,2 @@
+import { createPathProductContribution } from "./editorRuntime";
+export declare const Path: import("../canvas-plugin-sdk/index").CanvasPlugin<typeof createPathProductContribution>;

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

@@ -0,0 +1,7 @@
+export { createPathCanvasRenderPlugin } from "./canvasRender";
+export { PATH_BOOLEAN_INTERSECT_ACTION_ID, PATH_BOOLEAN_SUBTRACT_ACTION_ID, PATH_BOOLEAN_UNION_ACTION_ID, PATH_BOOLEAN_XOR_ACTION_ID, PATH_EDIT_TOOLBAR_ACTION_ID, PATH_EDIT_SNAP_ACTION_ID, PATH_NODE_DELETE_ACTION_ID, PATH_NODE_JOIN_ACTION_ID, PATH_NODE_MAKE_CURVE_ACTION_ID, PATH_NODE_MERGE_ACTION_ID, PATH_NODE_REMOVE_HANDLES_ACTION_ID, PATH_NODE_SEPARATE_ACTION_ID, PathShapeSvgExporter, createPathEditorPlugin, createPathProductContribution, } from "./editorRuntime";
+export { Path } from "./feature";
+export { PATH_CONTROL_HANDLE_TYPE, PATH_NODE_HANDLE_TYPE, createPathControlHandleId, createPathNodeHandleId, parsePathHandle, type PathControlHandleKind, type PathControlHandleInfo, type PathHandleInfo, type PathNodeHandleInfo, } from "./pathHandles";
+export { PathShapeUtil } from "./pathShapeUtil";
+export { PathTool } from "./pathTool";
+export { PATH_FILL_RULES, PATH_NODE_KINDS, isPathFillRule, isPathNodeKind, isPathShapeRecord, type PathFillRule, type PathHandle, type PathNode, type PathNodeKind, type PathShapeProps, type PathShapeRecord, type PathSubpath, } from "./types";

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

@@ -0,0 +1,13 @@
+import { type MultiPolygon } from "polygon-clipping";
+import { Vec } from "../canvas-core/index";
+import type { PathShapeProps, PathShapeRecord, PathSubpath } from "./types";
+export type PathBooleanOperation = "union" | "subtract" | "intersect" | "xor";
+export interface PathBooleanOperand {
+    shape: PathShapeRecord;
+    localToPage: {
+        applyToPoint(point: Vec): Vec;
+    };
+}
+export declare function getPathBooleanOperandPolygon(operand: PathBooleanOperand): MultiPolygon;
+export declare function getPathBooleanResultPageSubpaths(operation: PathBooleanOperation, operands: readonly PathBooleanOperand[]): PathSubpath[];
+export declare function getNormalizedPathBooleanResult(operation: PathBooleanOperation, operands: readonly PathBooleanOperand[], style: Pick<PathShapeProps, "fill" | "stroke" | "strokeWidth">): import("./pathGeometry").NormalizedPathShape | null;

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

@@ -0,0 +1,10 @@
+import type { PathShapeRecord, PathSubpath } from "./types";
+export interface PathDraftMeta {
+    subpathId: string | null;
+    previewNodeId: string | null;
+}
+export declare function getPathDraftMeta(shape: Pick<PathShapeRecord, "meta">): PathDraftMeta;
+export declare function getPathDraftPreviewNodeId(shape: Pick<PathShapeRecord, "meta">): string | null;
+export declare function setPathDraftMeta(meta: Record<string, unknown>, draft: PathDraftMeta): Record<string, unknown>;
+export declare function clearPathDraftMeta(meta: Record<string, unknown>): Record<string, unknown>;
+export declare function withoutPathDraftPreviewNode(subpaths: readonly PathSubpath[], previewNodeId: string | null): PathSubpath[];

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

@@ -0,0 +1,11 @@
+import { Vec, type Editor, type ShapeId } from "../canvas-core/index";
+export interface PathEditInsertPreview {
+    shapeId: ShapeId;
+    subpathId: string;
+    startNodeId: string;
+    endNodeId: string;
+    t: number;
+    pagePoint: Vec;
+}
+export declare function getPathEditInsertPreview(editor: Editor): PathEditInsertPreview | null;
+export declare function setPathEditInsertPreview(editor: Editor, preview: PathEditInsertPreview | null): void;

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

@@ -0,0 +1,24 @@
+import { type Editor, type ShapeId } from "../canvas-core/index";
+import { type PathNodeRef } from "./pathGeometry";
+import { type PathNode, type PathShapeRecord } from "./types";
+export interface PathEditSelection {
+    shapeId: ShapeId;
+    nodes: PathNodeRef[];
+    primary: PathNodeRef;
+}
+export interface SelectedPathEditNodeEntry {
+    ref: PathNodeRef;
+    node: PathNode;
+}
+export interface SelectedPathEditNodes {
+    selection: PathEditSelection;
+    shape: PathShapeRecord;
+    entries: SelectedPathEditNodeEntry[];
+}
+export declare function getPathEditSelection(editor: Editor): PathEditSelection | null;
+export declare function getSelectedPathEditNodes(editor: Editor): SelectedPathEditNodes | null;
+export declare function clearPathEditSelection(editor: Editor): void;
+export declare function setPathEditSelectionForNode(editor: Editor, shape: PathShapeRecord, subpathId: string, nodeId: string): void;
+export declare function setPathEditSelectionForNodeEntries(editor: Editor, shape: PathShapeRecord, refs: readonly PathNodeRef[], primaryRef?: PathNodeRef | null): void;
+export declare function togglePathEditSelectionForNode(editor: Editor, shape: PathShapeRecord, subpathId: string, nodeId: string): void;
+export declare function isPathEditSelectionNodeSelected(selection: PathEditSelection, subpathId: string, nodeId: string): boolean;

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

@@ -0,0 +1,6 @@
+import { type Editor } from "../canvas-core/index";
+export declare function isPathEditSnapEnabled(editor: Editor): boolean;
+export declare function setPathEditSnapEnabled(editor: Editor, enabled: boolean): boolean;
+export declare function togglePathEditSnap(editor: Editor): boolean;
+export declare function resetPathEditSnap(editor: Editor): void;
+export declare function setupPathEditLifecycle(editor: Editor): () => void;

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/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,28 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushSelectInput, type ShapeBrushWrapInput, type ShapeHandleSnapGeometry, type ShapeLineSegmentHitTestInput, type ShapePointHitTestInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionFrameInput, type ShapeSelectionOverlayInfo, type ShapeSelectionOverlayInfoInput, type ShapeSelectionResizeInput, 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[];
+    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,39 @@
+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;
+    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;
+}
+export {};

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/arrowLabelBindingUtil.d.ts

@@ -15,7 +15,11 @@ export declare class ArrowLabelBindingUtil extends BindingUtil<ArrowLabelBinding
     readonly type = "arrow-label";
     getDefaultProps(): ArrowLabelBindingProps;
     validateProps(props: unknown): ArrowLabelBindingProps;
-    canBind(_editor: Editor, _binding: ArrowLabelBindingRecord, context: {
+    canBind(_editor: Editor, binding: ArrowLabelBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    canUseShapeHierarchy(_binding: ArrowLabelBindingRecord, context: {
         fromShape: ShapeRecord;
         toShape: ShapeRecord;
     }): boolean;
@@ -34,6 +38,7 @@ export declare class ArrowLabelBindingUtil extends BindingUtil<ArrowLabelBinding
     }): BindingUtilEffect | void;
     onBeforeDeleteBinding(_editor: Editor, binding: ArrowLabelBindingRecord): BindingUtilEffect | void;
     getExportShapeIds(_editor: Editor, binding: ArrowLabelBindingRecord): TextShapeRecord["id"][];
+    getShapeHierarchyRootId(binding: ArrowLabelBindingRecord, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
     getSelectionCompanionFrameGeometries(editor: Editor, binding: ArrowLabelBindingRecord, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
     private syncLabelPosition;
 }

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/editorRuntime.d.ts

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

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").CanvasProductFactory>;

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

@@ -19,7 +19,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 +42,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

@@ -3,8 +3,9 @@ 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 {
+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;