@yuzhouu/canvas-kit 0.1.9 → 0.1.11

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

@@ -0,0 +1,74 @@
+import { type PageId, type ShapeColor, type ShapeId } from "../canvas-core/index";
+import { type CanvasPluginApi, type CanvasShapeRef } from "../canvas-plugin-sdk/index";
+import { type PackagingPdfExportOptions, type PackagingPdfExportResult } from "./packagingPdfExporter";
+import { type PackagingDxfImportOptions } from "./packagingDxf";
+import type { PackagingDocument, PackagingSurfaceSide } from "./types";
+export interface PackagingInput {
+    x: number;
+    y: number;
+    document: PackagingDocument;
+    viewSide?: PackagingSurfaceSide;
+    faceFill?: ShapeColor;
+    faceFillOverrides?: Record<string, ShapeColor>;
+    showBleed?: boolean;
+    clipToBleed?: boolean;
+    dielineOnTop?: boolean;
+    showSafeZones?: boolean;
+    showCanvasBoundsMarks?: boolean;
+    meta?: Record<string, unknown>;
+}
+export interface PackagingDxfImportInput {
+    source: string;
+    fileName?: string;
+    pagePoint?: {
+        x: number;
+        y: number;
+    };
+    options?: Omit<PackagingDxfImportOptions, "fileName">;
+}
+export interface PackagingApi {
+    create(input: PackagingInput): CanvasShapeRef<"packaging"> | null;
+    importDxf(input: PackagingDxfImportInput): CanvasShapeRef<"packaging"> | null;
+    updateDocument(input: {
+        packagingId: ShapeId;
+        document: PackagingDocument;
+        expectedRevision?: string;
+    }): CanvasShapeRef<"packaging"> | null;
+    getDocument(packagingId: ShapeId): PackagingDocument | null;
+    exportPdf(input: {
+        packagingId: ShapeId;
+        options?: PackagingPdfExportOptions;
+    }): Promise<PackagingPdfExportResult | null>;
+    attachShapes(input: {
+        packagingId: ShapeId;
+        shapeIds: ShapeId[];
+    }): ShapeId[];
+    detachShapes(input: {
+        packagingId: ShapeId;
+        shapeIds: ShapeId[];
+        destinationPageId?: PageId;
+    }): ShapeId[];
+    hitTestFace(input: {
+        packagingId: ShapeId;
+        pagePoint: {
+            x: number;
+            y: number;
+        };
+    }): {
+        faceId: string;
+        localPoint: {
+            x: number;
+            y: number;
+        };
+        faceUv: {
+            x: number;
+            y: number;
+        } | null;
+    } | null;
+    getCoveredFaces(input: {
+        packagingId: ShapeId;
+        shapeId: ShapeId;
+    }): string[];
+}
+export declare const packagingApiToken: import("../canvas-plugin-sdk/index").ProductApiToken<PackagingApi>;
+export declare const packagingPluginApi: CanvasPluginApi<PackagingApi>;

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+export { createPackagingCanvasRenderPlugin } from "./canvasRender";
+export { createPackagingEditorPlugin } from "./editorRuntime";
+export { Packaging } from "./feature";
+export { packagingApiToken } from "./api";
+export type { PackagingApi, PackagingDxfImportInput, PackagingInput, } from "./api";
+export { getPackagingArtworkPlacementMeta, getPackagingArtworkSide, PACKAGING_ARTWORK_SIDE_META_KEY, } from "./packagingArtwork";
+export { applyAffine2d, compilePackagingContour, compilePackagingGeometry, doesPackagingSegmentHitFace, getCompiledPackagingGeometry, getCoveredPackagingFaceIds, getPackagingFaceUv, getPackagingCanvasBoundsMarkPaths, getPackagingStrokeDasharray, hitTestPackagingFace, invertAffine2d, isPointInPackagingFace, } from "./packagingGeometry";
+export type { CompiledPackagingEdge, CompiledPackagingFace, CompiledPackagingContour, CompiledPackagingGeometry, PackagingMultiPolygon, PackagingPolygon, PackagingRing, PackagingSpatialIndex, } from "./packagingGeometry";
+export { getPackagingRuntime, packagingRuntimeToken } from "./packagingRuntime";
+export type { PackagingRuntime } from "./packagingRuntime";
+export { getPackagingFaceFill, getPackagingVisualBounds, PackagingShapeUtil, } from "./packagingShapeUtil";
+export { PackagingShapeSvgExporter } from "./packagingSvgExporter";
+export { parsePackagingDxf } from "./packagingDxf";
+export type { PackagingDxfImportOptions } from "./packagingDxf";
+export { exportPackagingPdf, getPackagingPointsPerUnit, } from "./packagingPdfExporter";
+export type { PackagingPdfExportOptions, PackagingPdfExportResult, } from "./packagingPdfExporter";
+export { setupPackagingProduct } from "./productRuntime";
+export { clonePackagingDocument, parsePackagingDocument, } from "./validation";
+export type { Affine2d, PackagingBleedContour, PackagingClosedContour, PackagingContourSegment, PackagingCoordinate, PackagingCoordinateSystem, PackagingDirectedEdgeRef, PackagingDocument, PackagingEdge, PackagingEdgeGeometry, PackagingEdgeOperation, PackagingFace, PackagingHoverState, PackagingLoop, PackagingPoint, PackagingPrepress, PackagingSafeZone, PackagingShapeProps, PackagingShapeRecord, PackagingSurface, PackagingSurfaceSide, PackagingSurfaces, PackagingUnit, } from "./types";

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

@@ -0,0 +1,5 @@
+import type { ShapeRecordBase } from "../canvas-core/index";
+import type { PackagingSurfaceSide } from "./types";
+export declare const PACKAGING_ARTWORK_SIDE_META_KEY = "land.packaging.artworkSide";
+export declare function getPackagingArtworkSide(shape: ShapeRecordBase): PackagingSurfaceSide | null;
+export declare function getPackagingArtworkPlacementMeta(shape: ShapeRecordBase, side: PackagingSurfaceSide): Record<string, unknown>;

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

@@ -0,0 +1,9 @@
+import type { PackagingDocument, PackagingEdgeOperation } from "./types";
+export interface PackagingDxfImportOptions {
+    fileName?: string;
+    documentId?: string;
+    revision?: string;
+    defaultOperation?: PackagingEdgeOperation;
+    operationByLayer?: Readonly<Record<string, PackagingEdgeOperation>>;
+}
+export declare function parsePackagingDxf(source: string, options?: PackagingDxfImportOptions): PackagingDocument;

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

@@ -0,0 +1,74 @@
+import { Box, Vec, type ShapeSnapPoint } from "../canvas-core/index";
+import type { Affine2d, PackagingBleedContour, PackagingClosedContour, PackagingDocument, PackagingEdge, PackagingFace, PackagingLoop, PackagingSafeZone, PackagingSurfaceSide } from "./types";
+export type PackagingRing = readonly Vec[];
+export type PackagingPolygon = readonly PackagingRing[];
+export type PackagingMultiPolygon = readonly PackagingPolygon[];
+export interface CompiledPackagingEdge {
+    edge: PackagingEdge;
+    from: Vec;
+    to: Vec;
+    path: string;
+    bounds: Box;
+    midpoint: Vec;
+    extrema: readonly Vec[];
+    samples: readonly Vec[];
+    pointAt(t: number): Vec;
+}
+export interface CompiledPackagingFace {
+    face: PackagingFace;
+    bounds: Box;
+    center: Vec;
+    outerPath: string;
+    holePaths: readonly string[];
+    outer: PackagingRing;
+    holes: readonly PackagingRing[];
+    outerEdges: readonly CompiledPackagingEdge[];
+    holeEdges: readonly (readonly CompiledPackagingEdge[])[];
+}
+export interface CompiledPackagingContour<TSource = unknown> {
+    source: TSource;
+    path: string;
+    samples: readonly Vec[];
+    bounds: Box;
+}
+export interface PackagingSpatialIndex {
+    searchPoint(point: Vec): string[];
+    searchBounds(bounds: Box): string[];
+}
+export interface CompiledPackagingGeometry {
+    bounds: Box;
+    outerBounds: Box;
+    dielineBounds: Box | null;
+    pointsById: Map<string, Vec>;
+    edgesById: Map<string, CompiledPackagingEdge>;
+    facesById: Map<string, CompiledPackagingFace>;
+    facePaths: Map<string, string>;
+    facePolygons: Map<string, PackagingMultiPolygon>;
+    holePaths: Map<string, string[]>;
+    edgePaths: Map<string, string>;
+    faceCenters: Map<string, Vec>;
+    snapPoints: ShapeSnapPoint[];
+    spatialIndex: PackagingSpatialIndex;
+    holeEdgeIds: ReadonlySet<string>;
+    bleedContoursById: Map<string, CompiledPackagingContour<PackagingBleedContour>>;
+    safeZonesById: Map<string, CompiledPackagingContour<PackagingSafeZone>>;
+}
+export declare const PACKAGING_SAFE_ZONE_STROKE_DASHARRAY = "1 3";
+export declare function getCompiledPackagingGeometry(document: PackagingDocument, side: PackagingSurfaceSide): CompiledPackagingGeometry;
+export declare function compilePackagingGeometry(document: PackagingDocument, side: PackagingSurfaceSide): CompiledPackagingGeometry;
+export declare function compilePackagingContour(contour: PackagingClosedContour): CompiledPackagingContour<PackagingClosedContour>;
+export declare function compilePackagingContour<TSource>(contour: PackagingClosedContour, source: TSource): CompiledPackagingContour<TSource>;
+export declare function flattenPackagingLoop(loop: PackagingLoop, edgesById: ReadonlyMap<string, CompiledPackagingEdge>): Vec[];
+export declare function getPackagingLoopPath(loop: PackagingLoop, edgesById: ReadonlyMap<string, CompiledPackagingEdge>): string;
+export declare function hitTestPackagingFace(geometry: CompiledPackagingGeometry, localPoint: Vec): CompiledPackagingFace | null;
+export declare function isPointInPackagingFace(point: Vec, face: Pick<CompiledPackagingFace, "outer" | "holes">): boolean;
+export declare function getPackagingFaceUv(face: PackagingFace, localPoint: Vec): Vec | null;
+export declare function getCoveredPackagingFaceIds(geometry: CompiledPackagingGeometry, localOutline: readonly Vec[]): string[];
+export declare function doesPackagingSegmentHitFace(geometry: CompiledPackagingGeometry, localStart: Vec, localEnd: Vec, margin?: number): boolean;
+export declare function getPackagingCanvasBoundsMarkPaths(bounds: Box | null, layout: {
+    horizontalLength: number;
+    verticalLength: number;
+}): string[];
+export declare function getPackagingStrokeDasharray(operation: PackagingEdge["operation"], lineWidth: number): string;
+export declare function applyAffine2d(matrix: Affine2d, point: Vec): Vec;
+export declare function invertAffine2d(matrix: Affine2d): Affine2d | null;

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

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

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

@@ -0,0 +1,25 @@
+import type { PackagingDocument, PackagingSurfaceSide, PackagingUnit } from "./types";
+export interface PackagingPdfExportOptions {
+    side?: PackagingSurfaceSide;
+    includeBleed?: boolean;
+    includeSafeZones?: boolean;
+    includeAnnotations?: boolean;
+    mirror?: boolean;
+    marginInDocumentUnits?: number;
+    lineWidthPoints?: number;
+    unitlessPointsPerUnit?: number;
+}
+export interface PackagingPdfExportResult {
+    bytes: Uint8Array;
+    filename: string;
+    side: PackagingSurfaceSide;
+    page: {
+        width: number;
+        height: number;
+        unit: PackagingUnit;
+        widthPoints: number;
+        heightPoints: number;
+    };
+}
+export declare function exportPackagingPdf(input: PackagingDocument, options?: PackagingPdfExportOptions): Promise<PackagingPdfExportResult>;
+export declare function getPackagingPointsPerUnit(unit: PackagingUnit, unitlessPointsPerUnit?: number): number;

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

@@ -0,0 +1,11 @@
+import { type Editor } from "../canvas-core/index";
+import { type Signal } from "../signals/index";
+import type { PackagingHoverState } from "./types";
+export interface PackagingRuntime {
+    readonly hoverSignal: Signal<PackagingHoverState | null>;
+    setHover(hover: PackagingHoverState | null): void;
+    clear(): void;
+}
+export declare const packagingRuntimeToken: import("../canvas-core/index").EditorRuntimeToken<PackagingRuntime>;
+export declare function createPackagingRuntime(): PackagingRuntime;
+export declare function getPackagingRuntime(editor: Editor): PackagingRuntime;

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

@@ -0,0 +1,34 @@
+import { Box, ShapeUtil, Vec, type ShapeBoundsSnapGeometry, type ShapeBrushSelectInput, type ShapeLineSegmentHitTestInput, type ShapePointHitTestInput, type ShapeRecordBase, type ShapeSelectionResizeInput, type ShapeSelectionResizeModesInput, type ShapeSelectionTransformCapabilityInput, type ShapeUpdate } from "../canvas-core/index";
+import { type CompiledPackagingGeometry } from "./packagingGeometry";
+import type { PackagingShapeProps, PackagingShapeRecord } from "./types";
+export declare class PackagingShapeUtil extends ShapeUtil<PackagingShapeRecord> {
+    readonly type: "packaging";
+    getDefaultProps(): PackagingShapeProps;
+    validateProps(props: unknown): PackagingShapeProps;
+    getLocalBounds(shape: PackagingShapeRecord): Box;
+    getRenderBounds(shape: PackagingShapeRecord): Box;
+    getExportBounds(shape: PackagingShapeRecord): Box;
+    getChildClipLocalBounds(shape: PackagingShapeRecord): Box | null;
+    getChildClipLocalPolygons(shape: PackagingShapeRecord): readonly (readonly Vec[])[] | null;
+    getChildExportClipLocalPolygons(shape: PackagingShapeRecord): readonly (readonly Vec[])[] | null;
+    getPositionedOutlineVertices(shape: PackagingShapeRecord): Vec[];
+    getSelectionFramePositionedOutlineVertices(shape: PackagingShapeRecord): Vec[];
+    getBoundsSnapGeometry(shape: PackagingShapeRecord): ShapeBoundsSnapGeometry;
+    canReceiveChildren(_shape: PackagingShapeRecord): boolean;
+    canReceiveChild(_shape: PackagingShapeRecord, child: ShapeRecordBase): boolean;
+    isChildVisible(shape: PackagingShapeRecord, child: ShapeRecordBase): boolean;
+    getChildPlacementMeta(shape: PackagingShapeRecord, child: ShapeRecordBase, input: {
+        reason: "create" | "reparent";
+    }): Record<string, unknown>;
+    canSnapChildrenToSelf(_shape: PackagingShapeRecord): boolean;
+    shouldRotateDescendants(_shape: PackagingShapeRecord): boolean;
+    getAllowedSelectionResizeModes(_shape: PackagingShapeRecord, _input: ShapeSelectionResizeModesInput): readonly ["aspect_ratio_locked"];
+    canParticipateInSelectionRotation(_shape: PackagingShapeRecord, _input: ShapeSelectionTransformCapabilityInput): boolean;
+    resizeSelectionBounds(shape: PackagingShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    canSelectByBrush(shape: PackagingShapeRecord, input: ShapeBrushSelectInput): boolean;
+    hitTest(shape: PackagingShapeRecord, positionedPoint: Vec, _input?: ShapePointHitTestInput): boolean;
+    hitTestLineSegment(shape: PackagingShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+    private doesBrushIntersectFace;
+}
+export declare function getPackagingVisualBounds(shape: PackagingShapeRecord, geometry?: CompiledPackagingGeometry): Box;
+export declare function getPackagingFaceFill(shape: PackagingShapeRecord, faceId: string): PackagingShapeProps["faceFill"];

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

@@ -0,0 +1,10 @@
+export declare const PACKAGING_RENDER_STYLE: {
+    readonly lineWidth: 0.5;
+    readonly holeFill: import("../canvas-core/index").CustomShapeColorRef;
+    readonly cutStroke: import("../canvas-core/index").CustomShapeColorRef;
+    readonly creaseStroke: import("../canvas-core/index").CustomShapeColorRef;
+    readonly bleedStroke: import("../canvas-core/index").CustomShapeColorRef;
+    readonly safeZoneStroke: import("../canvas-core/index").CustomShapeColorRef;
+    readonly annotationStroke: import("../canvas-core/index").CustomShapeColorRef;
+    readonly canvasBoundsMarkColor: import("../canvas-core/index").CustomShapeColorRef;
+};

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

@@ -0,0 +1,7 @@
+import { type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { PackagingShapeRecord } from "./types";
+export declare class PackagingShapeSvgExporter implements ShapeSvgExporter<PackagingShapeRecord> {
+    readonly type: "packaging";
+    toSvg(shape: PackagingShapeRecord, context: SvgExportContext): SvgNode;
+    toSvgForeground(shape: PackagingShapeRecord, context: SvgExportContext): SvgNode;
+}

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

@@ -0,0 +1,2 @@
+import { type CanvasPluginSetupContext } from "../canvas-plugin-sdk/index";
+export declare function setupPackagingProduct(context: CanvasPluginSetupContext): void;

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,15 @@
+import { type ShapeColor, type ShapeEditingSession } from "../canvas-core/index";
+import type { PathShapeRecord } from "./types";
+interface PathShapeSvgProps {
+    shape: PathShapeRecord;
+    shapeEditingSession?: ShapeEditingSession | null;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+}
+export declare function PathShapeSvg({ shape, shapeEditingSession, fill, stroke, strokeWidth, }: PathShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function PathShapeHoverSvg({ shape, strokeWidth, }: {
+    shape: PathShapeRecord;
+    strokeWidth: number;
+}): 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,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { PathShapeRecord } from "./types";
+export declare class PathShapeSvgExporter implements ShapeSvgExporter<PathShapeRecord> {
+    readonly type: "path";
+    toSvg(shape: PathShapeRecord, context: SvgExportContext): SvgNode | null;
+}
+export declare function createPathEditorPlugin(): EditorPlugin;

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

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

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

@@ -0,0 +1,8 @@
+export { createPathCanvasRenderPlugin } from "./canvasRender";
+export { PathShapeSvgExporter, createPathEditorPlugin, } from "./editorRuntime";
+export { PATH_BOOLEAN_INTERSECT_ACTION_ID, PATH_BOOLEAN_SUBTRACT_ACTION_ID, PATH_BOOLEAN_UNION_ACTION_ID, PATH_BOOLEAN_XOR_ACTION_ID, PATH_EDIT_DONE_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, setupPathProduct, } from "./productRuntime";
+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;