@yuzhouu/canvas-kit 0.1.2 → 0.1.3

package/_vendor/plugin-arrow/arrowTerminalBindingResolver.d.ts

@@ -0,0 +1,21 @@
+import { Vec, type Editor, type ResolvedArrowTerminalBinding, type ShapeId, type ShapeRecord } from "../canvas-core/index";
+import { type ArrowPoint, type ArrowShapeRecord } from "./types";
+export declare function resolveArrowBindingPagePoint(editor: Editor, target: ShapeRecord, normalizedAnchor: ArrowPoint, oppositePagePoint: Vec): Vec;
+export declare function resolveArrowTerminalBindingAtPoint(editor: Editor, { terminal, rawPagePoint, oppositePagePoint, excludeShapeId, ignoreTargets, }: {
+    terminal: "start" | "end";
+    rawPagePoint: Vec;
+    oppositePagePoint: Vec;
+    excludeShapeId?: ShapeId;
+    ignoreTargets?: boolean;
+}): ResolvedArrowTerminalBinding;
+export declare function resolveArrowTerminalBindingAtStartPoint(editor: Editor, { terminal, rawPagePoint, ignoreTargets, }: {
+    terminal: "start" | "end";
+    rawPagePoint: Vec;
+    ignoreTargets?: boolean;
+}): ResolvedArrowTerminalBinding;
+export declare function resolveArrowTerminalBindingForArrow(editor: Editor, { arrow, terminal, rawPagePoint, ignoreTargets, }: {
+    arrow: ArrowShapeRecord;
+    terminal: "start" | "end";
+    rawPagePoint: Vec;
+    ignoreTargets?: boolean;
+}): ResolvedArrowTerminalBinding;

package/_vendor/plugin-arrow/arrowTerminalCommands.d.ts

@@ -0,0 +1,12 @@
+import { Vec, type ChangeSource, type Editor, type PageId, type ResolvedArrowTerminalBinding, type ShapeId, type ArrowBindingTargetInput } from "../canvas-core/index";
+import { type ArrowShapeRecord, type ArrowShapeProps, type ArrowTerminal } from "./types";
+export interface CreateArrowInput {
+    startPagePoint: Vec;
+    endPagePoint: Vec;
+    startBinding?: ArrowBindingTargetInput | null;
+    endBinding?: ArrowBindingTargetInput | null;
+    props?: Partial<ArrowShapeProps>;
+    parentId?: PageId;
+}
+export declare function createArrow(editor: Editor, input: CreateArrowInput, source?: ChangeSource): ArrowShapeRecord;
+export declare function applyResolvedArrowTerminalBinding(editor: Editor, shapeId: ShapeId | null, terminal: ArrowTerminal, resolvedBinding: ResolvedArrowTerminalBinding, source?: ChangeSource): ArrowShapeRecord | null;

package/_vendor/plugin-arrow/canvas.d.ts

@@ -0,0 +1,2 @@
+import type { LandCanvasPlugin } from "../canvas-plugin-api/index";
+export declare function createArrowCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-arrow/core.d.ts

@@ -0,0 +1,7 @@
+import { type LandCorePlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
+import type { ArrowShapeRecord } from "./types";
+export declare class ArrowShapeSvgExporter implements ShapeSvgExporter<ArrowShapeRecord> {
+    readonly type: "arrow";
+    toSvg(shape: ArrowShapeRecord, context: SvgExportContext): SvgNode;
+}
+export declare function createArrowCorePlugin(): LandCorePlugin;

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-plugin-api/index";
+export declare function createArrowFeatureBundle(): LandFeatureBundle;
+export declare const Arrow: import("../canvas-plugin-api/index").ConfigurableLandExtension<Record<string, never>>;

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

@@ -0,0 +1,11 @@
+export { ArrowBindingUtil } from "./ArrowBindingUtil";
+export { ArrowShapeUtil } from "./ArrowShapeUtil";
+export { ArrowTool } from "./ArrowTool";
+export { ArrowShapeSvgExporter, createArrowCorePlugin } from "./core";
+export { createArrowCanvasPlugin } from "./canvas";
+export { Arrow, createArrowFeatureBundle } from "./feature";
+export { isArrowBindingRecord, isArrowShapeRecord, type ArrowBindingProps, type ArrowBindingRecord, type ArrowPoint, type ArrowShapeProps, type ArrowShapeRecord, type ArrowTerminal, } from "./types";
+export { resolveArrowBindingPagePoint, resolveArrowTerminalBindingAtPoint, resolveArrowTerminalBindingAtStartPoint, resolveArrowTerminalBindingForArrow, } from "./arrowTerminalBindingResolver";
+export { createArrow } from "./arrowTerminalCommands";
+export { getArrowTerminalPagePoint } from "./arrowGeometry";
+export { createArrowInteractionHandler, createArrowSelectionHandleInteractionHandler, } from "./selectionHandleInteractions";

package/_vendor/plugin-arrow/selectionHandleInteractions.d.ts

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

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

@@ -0,0 +1,31 @@
+import type { BaseRecord, BindingRecordBase, ShapeRecordBase } from "../canvas-core/index";
+export interface ArrowPoint {
+    x: number;
+    y: number;
+}
+export type ArrowTerminal = "start" | "end";
+export interface ArrowShapeProps {
+    w: number;
+    h: number;
+    start: ArrowPoint;
+    end: ArrowPoint;
+    bend: number;
+    stroke: string;
+    strokeWidth: number;
+    headStart: "none" | "arrow";
+    headEnd: "none" | "arrow";
+}
+export interface ArrowShapeRecord extends ShapeRecordBase<"arrow", ArrowShapeProps> {
+    type: "arrow";
+    props: ArrowShapeProps;
+}
+export interface ArrowBindingProps {
+    terminal: ArrowTerminal;
+    normalizedAnchor: ArrowPoint;
+}
+export interface ArrowBindingRecord extends BindingRecordBase<"arrow", ArrowBindingProps> {
+    type: "arrow";
+    props: ArrowBindingProps;
+}
+export declare function isArrowShapeRecord(record: BaseRecord | null | undefined): record is ArrowShapeRecord;
+export declare function isArrowBindingRecord(record: BaseRecord | null | undefined): record is ArrowBindingRecord;

package/_vendor/plugin-draw/DrawShapeRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { DrawShapeRecord } from "./types";
+interface DrawShapeSvgProps {
+    shape: DrawShapeRecord;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export declare function DrawShapeSvg({ shape, stroke, strokeWidth, }: DrawShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/_vendor/plugin-draw/DrawShapeUtil.d.ts

@@ -0,0 +1,21 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushWrapInput, type ShapeBrushSelectInput, type ShapeLineSegmentHitTestInput, type ShapeSelectionFlipInput, type ShapeSelectionOverlayInfo, type ShapeSelectionResizeInput, type ShapeUpdate } from "../canvas-core/index";
+import type { DrawShapeProps, DrawShapeRecord } from "./types";
+export declare class DrawShapeUtil extends ShapeUtil<DrawShapeRecord> {
+    readonly type: "draw";
+    getDefaultProps(): DrawShapeProps;
+    validateProps(props: unknown): DrawShapeProps;
+    getBounds(shape: DrawShapeRecord): Box;
+    getLocalBounds(shape: DrawShapeRecord): Box;
+    getRenderBounds(shape: DrawShapeRecord): Box;
+    getExportBounds(shape: DrawShapeRecord): Box;
+    getSelectionResizeLocalBounds(shape: DrawShapeRecord): Box;
+    resizeSelectionBounds(shape: DrawShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    flipSelectionBounds(shape: DrawShapeRecord, input: ShapeSelectionFlipInput): ShapeUpdate;
+    getSelectionOverlayInfo(_shape: DrawShapeRecord): ShapeSelectionOverlayInfo;
+    isWrappedByBrush(shape: DrawShapeRecord, input: ShapeBrushWrapInput): boolean;
+    canSelectByBrush(shape: DrawShapeRecord, input: ShapeBrushSelectInput): boolean;
+    getPositionedOutlineVertices(shape: DrawShapeRecord): Vec[];
+    hitTest(shape: DrawShapeRecord, positionedPoint: Vec): boolean;
+    hitTestLineSegment(shape: DrawShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+    repairLoadedShape(shape: DrawShapeRecord): DrawShapeRecord | null;
+}

package/_vendor/plugin-draw/DrawTool.d.ts

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

package/_vendor/plugin-draw/canvas.d.ts

@@ -0,0 +1,2 @@
+import type { LandCanvasPlugin } from "../canvas-plugin-api/index";
+export declare function createDrawCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-draw/core.d.ts

@@ -0,0 +1,7 @@
+import { type LandCorePlugin, type ShapeSvgExporter, type SvgNode } from "../canvas-core/index";
+import { type DrawShapeRecord } from "./types";
+export declare class DrawShapeSvgExporter implements ShapeSvgExporter<DrawShapeRecord> {
+    readonly type: "draw";
+    toSvg(shape: DrawShapeRecord): SvgNode | null;
+}
+export declare function createDrawCorePlugin(): LandCorePlugin;

package/_vendor/plugin-draw/drawGeometry.d.ts

@@ -0,0 +1,45 @@
+import { Box, Vec } from "../canvas-core/index";
+import { type DrawSelectionFlipInput, type DrawSelectionResizeInput } from "./drawSelectionTransform";
+import { getDrawPointGeometry, getDrawSegmentGeometry, type DrawShapeGeometry, type DrawShapeSamplingStats } from "./drawShapeGeometry";
+import type { DrawShapePoint, DrawShapeRecord, DrawShapeSegment } from "./types";
+export { getDrawPointGeometry, getDrawSegmentGeometry };
+export type { DrawShapeGeometry, DrawShapeSamplingStats, } from "./drawShapeGeometry";
+type DrawLocalGeometryCacheKey = Pick<DrawShapeRecord, "props">;
+type DrawPositionedGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "props">;
+type DrawPageGeometryCacheKey = Pick<DrawShapeRecord, "x" | "y" | "rotation" | "scaleX" | "scaleY" | "props">;
+export interface DrawShapeDiagnostics extends DrawShapeSamplingStats {
+    hasPath: boolean;
+    hasSelectionPath: boolean;
+    outlineVertexCount: number;
+}
+export interface NormalizedDrawShape {
+    x: number;
+    y: number;
+    segments: DrawShapeSegment[];
+    pointBounds: Box;
+    localBounds: Box;
+    renderBounds: Box;
+    path: string | null;
+    selectionPath: string | null;
+    fillPath: string | null;
+    outlineVertices: Vec[];
+    outlinePolygons: Vec[][];
+    sampling: DrawShapeSamplingStats;
+}
+export declare function getDrawShapeLocalGeometry(shape: DrawLocalGeometryCacheKey): DrawShapeGeometry;
+export declare function normalizeDrawShapeFromSegmentSet(segments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPointSet(points: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPagePoints(pagePoints: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromPageSegments(pageSegments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function getDrawShapePositionedSegments(shape: Pick<DrawShapeRecord, "x" | "y" | "props">): DrawShapeSegment[];
+export declare function getDrawShapePositionedPoints(shape: Pick<DrawShapeRecord, "x" | "y" | "props">): DrawShapePoint[];
+export declare function getDrawShapePositionedGeometry(shape: DrawPositionedGeometryCacheKey): DrawShapeGeometry;
+export declare function getDrawShapePagePoints(shape: DrawShapeRecord): DrawShapePoint[];
+export declare function getDrawShapePageSegments(shape: DrawShapeRecord): DrawShapeSegment[];
+export declare function normalizeTransformedDrawShape(shape: DrawShapeRecord): NormalizedDrawShape;
+export declare function getDrawShapePageGeometry(shape: DrawPageGeometryCacheKey): DrawShapeGeometry;
+export declare function resizeDrawShapeToSelectionBounds(shape: DrawShapeRecord, input: DrawSelectionResizeInput): NormalizedDrawShape;
+export declare function flipDrawShapeInSelectionBounds(shape: DrawShapeRecord, input: DrawSelectionFlipInput): NormalizedDrawShape;
+export declare function resizeDrawShapeToPageBounds(shape: Pick<DrawShapeRecord, "x" | "y" | "props">, nextPageBounds: Box): NormalizedDrawShape;
+export declare function cloneDrawShapeSegmentsForUpdate(segments: readonly DrawShapeSegment[]): DrawShapeSegment[];
+export declare function getDrawShapeDiagnostics(shape: DrawLocalGeometryCacheKey): DrawShapeDiagnostics;

package/_vendor/plugin-draw/drawHitTest.d.ts

@@ -0,0 +1,11 @@
+import { Vec } from "../canvas-core/index";
+import type { DrawShapeGeometry } from "./drawShapeGeometry";
+interface DrawShapeHitTestOptions {
+    fill?: string;
+    isClosed?: boolean;
+}
+export declare function hitTestDrawShapeGeometry(geometry: Pick<DrawShapeGeometry, "outlinePolygons" | "outlineVertices" | "normalizedPoints">, strokeWidth: number, point: Vec, options?: DrawShapeHitTestOptions): boolean;
+export declare function hitTestDrawShapeLineSegmentGeometry(geometry: Pick<DrawShapeGeometry, "outlinePolygons" | "outlineVertices" | "normalizedPoints">, strokeWidth: number, start: Vec, end: Vec, options?: DrawShapeHitTestOptions & {
+    margin?: number;
+}): boolean;
+export {};

package/_vendor/plugin-draw/drawInterpolation.d.ts

@@ -0,0 +1,5 @@
+import type { DrawShapeRecord } from "./types";
+export interface DrawShapeInterpolationOptions {
+    pointCount?: number;
+}
+export declare function interpolateDrawShapeRecords(from: DrawShapeRecord, to: DrawShapeRecord, t: number, options?: DrawShapeInterpolationOptions): DrawShapeRecord;

package/_vendor/plugin-draw/drawPath.d.ts

@@ -0,0 +1,37 @@
+import { Vec } from "../canvas-core/index";
+import type { DrawShapePoint, DrawShapeSegment } from "./types";
+export interface DrawPointSamplingOptions {
+    minPointDistance: number;
+    positionBlend: number;
+    pressureBlend: number;
+    maxPointCount: number;
+}
+export interface DrawInputPointGuardOptions {
+    minPointDistance: number;
+    pressureDeltaThreshold: number;
+    softMaxPointCount: number;
+    hardMaxPointCount: number;
+    maxDistanceMultiplier: number;
+}
+export interface DrawPointSamplingResult {
+    points: DrawShapePoint[];
+    rawPointCount: number;
+    sampledPointCount: number;
+    maxPointCount: number;
+    reduced: boolean;
+    capped: boolean;
+}
+export declare function getDrawPointSamplingLimit(isPen: boolean): number;
+export declare function getDrawSegmentPointLimit(isPen: boolean): number;
+export declare function drawPointToVec(point: DrawShapePoint): Vec;
+export declare function cloneDrawPoint(point: DrawShapePoint): DrawShapePoint;
+export declare function cloneDrawSegment(segment: DrawShapeSegment): DrawShapeSegment;
+export declare function getFlattenedDrawSegmentPoints(segments: readonly DrawShapeSegment[]): DrawShapePoint[];
+export declare function getDrawSegmentsFromPoints(points: readonly DrawShapePoint[]): DrawShapeSegment[];
+export declare function getDrawInputPointGuardOptions(strokeWidth: number, isPen: boolean): DrawInputPointGuardOptions;
+export declare function appendGuardedDrawPoint(points: DrawShapePoint[], point: DrawShapePoint, options: DrawInputPointGuardOptions): void;
+export declare function sampleDrawPoints(points: readonly DrawShapePoint[], options: DrawPointSamplingOptions): DrawPointSamplingResult;
+export declare function getDrawCenterlinePathFromPoints(points: readonly DrawShapePoint[]): string | null;
+export declare function getClosedDrawCenterlinePathFromPoints(points: readonly DrawShapePoint[]): string | null;
+export declare function getClosedSvgPathFromVecs(points: readonly Vec[]): string | null;
+export declare function getSmoothClosedSvgPathFromVecs(points: readonly Vec[]): string | null;

package/_vendor/plugin-draw/drawSegments.d.ts

@@ -0,0 +1,11 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { DrawShapePoint, DrawShapeSegment } from "./types";
+export declare function cloneDrawPoints(points: readonly DrawShapePoint[]): DrawShapePoint[];
+export declare function cloneDrawSegments(segments: readonly DrawShapeSegment[]): DrawShapeSegment[];
+export declare function cloneDrawSegment(segment: DrawShapeSegment): DrawShapeSegment;
+export declare function translateDrawPoints(points: readonly DrawShapePoint[], dx: number, dy: number): DrawShapePoint[];
+export declare function translateDrawSegments(segments: readonly DrawShapeSegment[], dx: number, dy: number): DrawShapeSegment[];
+export declare function mapDrawPointCoordinates(points: readonly DrawShapePoint[], mapper: (point: Vec, index: number) => Vec): DrawShapePoint[];
+export declare function mapDrawSegmentCoordinates(segments: readonly DrawShapeSegment[], mapper: (point: Vec, segmentIndex: number, pointIndex: number) => Vec): DrawShapeSegment[];
+export declare function mapDrawShapePointsToBounds(points: readonly DrawShapePoint[], fromBounds: Box, toBounds: Box): DrawShapePoint[];
+export declare function mapDrawShapeSegmentsToBounds(segments: readonly DrawShapeSegment[], fromBounds: Box, toBounds: Box): DrawShapeSegment[];

package/_vendor/plugin-draw/drawSelectionTransform.d.ts

@@ -0,0 +1,18 @@
+import { Box, Vec, type SelectionMirrorAxis } from "../canvas-core/index";
+import type { DrawShapeSegment } from "./types";
+export interface DrawSelectionRotationTransform {
+    selectionRotation: number;
+    selectionRotationCenter: Vec;
+}
+export interface DrawSelectionResizeInput extends DrawSelectionRotationTransform {
+    targetSelectionStrokeBounds: Box;
+    scaleX: number;
+    scaleY: number;
+}
+export interface DrawSelectionFlipInput extends DrawSelectionRotationTransform {
+    axis: SelectionMirrorAxis;
+    selectionMirrorBounds: Box;
+}
+export declare function mapPageDrawSegmentsToSelectionLocal(segments: readonly DrawShapeSegment[], input: DrawSelectionRotationTransform): DrawShapeSegment[];
+export declare function mapSelectionLocalDrawSegmentsToPage(segments: readonly DrawShapeSegment[], input: DrawSelectionRotationTransform): DrawShapeSegment[];
+export declare function mirrorSelectionLocalDrawSegments(segments: readonly DrawShapeSegment[], input: DrawSelectionFlipInput): DrawShapeSegment[];

package/_vendor/plugin-draw/drawShapeGeometry.d.ts

@@ -0,0 +1,33 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { DrawShapePoint, DrawShapeSegment } from "./types";
+export interface DrawShapeSamplingStats {
+    rawPointCount: number;
+    sampledPointCount: number;
+    sampledPointLimit: number;
+    reduced: boolean;
+    capped: boolean;
+}
+export interface DrawShapeGeometry {
+    normalizedSegments: DrawShapeSegment[];
+    normalizedPoints: DrawShapePoint[];
+    pointBounds: Box;
+    path: string | null;
+    selectionPath: string | null;
+    fillPath: string | null;
+    localBounds: Box;
+    renderBounds: Box;
+    outlineVertices: Vec[];
+    outlinePolygons: Vec[][];
+    sampling: DrawShapeSamplingStats;
+}
+export declare function createDrawGeometryFromDerivedData({ segments, outlineVertices, outlinePolygons, strokeWidth, sampling, isClosed, }: {
+    segments: readonly DrawShapeSegment[];
+    outlineVertices: readonly Vec[];
+    outlinePolygons?: readonly Vec[][];
+    strokeWidth: number;
+    sampling: DrawShapeSamplingStats;
+    isClosed: boolean;
+}): DrawShapeGeometry;
+export declare function createTranslatedDrawGeometry(geometry: DrawShapeGeometry, strokeWidth: number, dx: number, dy: number, isClosed: boolean): DrawShapeGeometry;
+export declare function getDrawPointGeometry(points: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): DrawShapeGeometry;
+export declare function getDrawSegmentGeometry(segments: readonly DrawShapeSegment[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): DrawShapeGeometry;

package/_vendor/plugin-draw/drawStrokeGeometry.d.ts

@@ -0,0 +1,17 @@
+import { Vec } from "../canvas-core/index";
+import type { DrawShapePoint } from "./types";
+export interface DrawStrokeDerivedPoint {
+    point: Vec;
+    direction: Vec;
+    pressure: number;
+    radius: number;
+    runningLength: number;
+}
+export declare function createStrokeDerivedPoints(points: readonly DrawShapePoint[], strokeWidth: number, isPen: boolean, isClosed: boolean, options?: {
+    taperStart?: boolean;
+    taperEnd?: boolean;
+}): DrawStrokeDerivedPoint[];
+export declare function getStrokeOutlineVertices(points: readonly DrawStrokeDerivedPoint[], isClosed: boolean, options?: {
+    capStart?: boolean;
+    capEnd?: boolean;
+}): Vec[];

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-plugin-api/index";
+export declare function createDrawFeatureBundle(): LandFeatureBundle;
+export declare const Draw: import("../canvas-plugin-api/index").ConfigurableLandExtension<Record<string, never>>;

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

@@ -0,0 +1,13 @@
+export { DrawTool } from "./DrawTool";
+export { DrawShapeUtil } from "./DrawShapeUtil";
+export { DrawShapeSvgExporter, createDrawCorePlugin } from "./core";
+export { DrawShapeSvg } from "./DrawShapeRenderer";
+export { createDrawCanvasPlugin } from "./canvas";
+export { Draw, createDrawFeatureBundle } from "./feature";
+export { flipDrawShapeInSelectionBounds, getDrawShapeDiagnostics, getDrawShapePageSegments, getDrawShapePagePoints, normalizeTransformedDrawShape, } from "./drawGeometry";
+export { interpolateDrawShapeRecords } from "./drawInterpolation";
+export type { DrawShapePoint, DrawShapeProps, DrawShapeRecord, DrawShapeSegment, } from "./types";
+export { isDrawShapeRecord } from "./types";
+export type { DrawShapeDiagnostics, DrawShapeSamplingStats, } from "./drawGeometry";
+export type { DrawShapeInterpolationOptions } from "./drawInterpolation";
+export type { DrawSelectionFlipInput, DrawSelectionResizeInput, DrawSelectionRotationTransform, } from "./drawSelectionTransform";

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

@@ -0,0 +1,23 @@
+import { type BaseRecord, type ShapeRecordBase } from "../canvas-core/index";
+export interface DrawShapePoint {
+    x: number;
+    y: number;
+    pressure?: number;
+    segment?: "straight";
+}
+export interface DrawShapeSegment {
+    points: DrawShapePoint[];
+}
+export interface DrawShapeProps {
+    segments: DrawShapeSegment[];
+    stroke: string;
+    strokeWidth: number;
+    fill: string;
+    isClosed: boolean;
+    isPen?: boolean;
+}
+export interface DrawShapeRecord extends ShapeRecordBase<"draw", DrawShapeProps> {
+    type: "draw";
+    props: DrawShapeProps;
+}
+export declare function isDrawShapeRecord(record: BaseRecord | null | undefined): record is DrawShapeRecord;

package/_vendor/plugin-eraser/EraserTool.d.ts

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

package/_vendor/plugin-eraser/canvas.d.ts

@@ -0,0 +1,2 @@
+import { type LandCanvasPlugin } from "../canvas-plugin-api/index";
+export declare function createEraserCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-eraser/core.d.ts

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

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-plugin-api/index";
+export declare function createEraserFeatureBundle(): LandFeatureBundle;
+export declare const Eraser: import("../canvas-plugin-api/index").ConfigurableLandExtension<Record<string, never>>;

package/_vendor/plugin-frame/FrameShapeUtil.d.ts

@@ -0,0 +1,22 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushSelectInput, type ShapeLineSegmentHitTestInput, type ShapeRecordBase } from "../canvas-core/index";
+export interface FrameShapeProps {
+    w: number;
+    h: number;
+    name: string;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+}
+export type FrameShapeRecord = ShapeRecordBase<"frame", FrameShapeProps>;
+export declare class FrameShapeUtil extends ShapeUtil<FrameShapeRecord> {
+    readonly type: "frame";
+    getDefaultProps(): FrameShapeProps;
+    validateProps(props: unknown): FrameShapeProps;
+    getBounds(shape: FrameShapeRecord): Box;
+    canReceiveChildren(_shape: FrameShapeRecord): boolean;
+    shouldRotateDescendants(_shape: FrameShapeRecord): boolean;
+    getChildClipLocalBounds(shape: FrameShapeRecord): Box | null;
+    canSelectByBrush(shape: FrameShapeRecord, input: ShapeBrushSelectInput): boolean;
+    hitTest(shape: FrameShapeRecord, positionedPoint: Vec): boolean;
+    hitTestLineSegment(shape: FrameShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+}

package/_vendor/plugin-frame/FrameTool.d.ts

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

package/_vendor/plugin-frame/canvas.d.ts

@@ -0,0 +1,8 @@
+import type { LandCanvasPlugin } from "../canvas-plugin-api/index";
+import type { FrameShapeRecord } from "./FrameShapeUtil";
+interface FrameShapeSvgProps {
+    shape: FrameShapeRecord;
+}
+export declare function createFrameCanvasPlugin(): LandCanvasPlugin;
+export declare function FrameShapeSvg({ shape }: FrameShapeSvgProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_vendor/plugin-frame/core.d.ts

@@ -0,0 +1,7 @@
+import { type LandCorePlugin, type ShapeSvgExporter, type SvgNode } from "../canvas-core/index";
+import { type FrameShapeRecord } from "./FrameShapeUtil";
+export declare class FrameShapeSvgExporter implements ShapeSvgExporter<FrameShapeRecord> {
+    readonly type: "frame";
+    toSvg(shape: FrameShapeRecord): SvgNode;
+}
+export declare function createFrameCorePlugin(): LandCorePlugin;

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-plugin-api/index";
+export declare function createFrameFeatureBundle(): LandFeatureBundle;
+export declare const Frame: import("../canvas-plugin-api/index").ConfigurableLandExtension<Record<string, never>>;

package/_vendor/plugin-geo/GeoShapeUtil.d.ts

@@ -0,0 +1,13 @@
+import { Box, ShapeUtil, Vec, type ShapeBindingPointInput, type ShapeHandleSnapGeometry, type ShapeLineSegmentHitTestInput } from "../canvas-core/index";
+import type { GeoShapeProps, GeoShapeRecord } from "./types";
+export declare class GeoShapeUtil extends ShapeUtil<GeoShapeRecord> {
+    readonly type: "geo";
+    getDefaultProps(): GeoShapeProps;
+    validateProps(props: unknown): GeoShapeProps;
+    getBounds(shape: GeoShapeRecord): Box;
+    getPositionedOutlineVertices(shape: GeoShapeRecord): Vec[];
+    getHandleSnapGeometry(shape: GeoShapeRecord): ShapeHandleSnapGeometry;
+    hitTest(shape: GeoShapeRecord, positionedPoint: Vec): boolean;
+    hitTestLineSegment(shape: GeoShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+    resolveBindingPoint(shape: GeoShapeRecord, input: ShapeBindingPointInput): Vec;
+}

package/_vendor/plugin-geo/GeoTools.d.ts

@@ -0,0 +1,17 @@
+import { StateNode, type Editor } from "../canvas-core/index";
+import type { GeoShapeKind, GeoShapeProps } from "./types";
+declare class BoxGeoTool extends StateNode {
+    private readonly geo;
+    constructor(editor: Editor, id: string, geo: GeoShapeKind);
+    getDefaultProps(): GeoShapeProps;
+}
+export declare class RectangleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class EllipseTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class DiamondTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export {};

package/_vendor/plugin-geo/canvas.d.ts

@@ -0,0 +1,11 @@
+import type { LandCanvasPlugin } from "../canvas-plugin-api/index";
+import type { GeoShapeRecord } from "./types";
+interface GeoShapeSvgProps {
+    shape: GeoShapeRecord;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export declare function createGeoCanvasPlugin(): LandCanvasPlugin;
+export declare function GeoShapeSvg({ shape, fill, stroke, strokeWidth, }: GeoShapeSvgProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/_vendor/plugin-geo/core.d.ts

@@ -0,0 +1,7 @@
+import { type LandCorePlugin, type ShapeSvgExporter, type SvgNode } from "../canvas-core/index";
+import { type GeoShapeRecord } from "./types";
+export declare class GeoShapeSvgExporter implements ShapeSvgExporter<GeoShapeRecord> {
+    readonly type: "geo";
+    toSvg(shape: GeoShapeRecord): SvgNode;
+}
+export declare function createGeoCorePlugin(): LandCorePlugin;

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-plugin-api/index";
+export declare function createGeoFeatureBundle(): LandFeatureBundle;
+export declare const Geo: import("../canvas-plugin-api/index").ConfigurableLandExtension<Record<string, never>>;

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

@@ -0,0 +1,15 @@
+import { type BaseRecord, type ShapeRecordBase } from "../canvas-core/index";
+export type GeoShapeKind = "rectangle" | "ellipse" | "diamond";
+export interface GeoShapeProps {
+    w: number;
+    h: number;
+    geo: GeoShapeKind;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+}
+export interface GeoShapeRecord extends ShapeRecordBase<"geo", GeoShapeProps> {
+    type: "geo";
+    props: GeoShapeProps;
+}
+export declare function isGeoShapeRecord(record: BaseRecord | null | undefined): record is GeoShapeRecord;

package/_vendor/plugin-group/GroupShapeUtil.d.ts

@@ -0,0 +1,15 @@
+import { Box, ShapeUtil, type Vec, type ShapeRecordBase } from "../canvas-core/index";
+export interface GroupShapeProps {
+    w: number;
+    h: number;
+}
+export type GroupShapeRecord = ShapeRecordBase<"group", GroupShapeProps>;
+export declare class GroupShapeUtil extends ShapeUtil<GroupShapeRecord> {
+    readonly type: "group";
+    getDefaultProps(): GroupShapeProps;
+    validateProps(props: unknown): GroupShapeProps;
+    getBounds(shape: GroupShapeRecord): Box;
+    hitTest(_shape: GroupShapeRecord, _positionedPoint: Vec): boolean;
+    shouldTransformDescendants(_shape: GroupShapeRecord): boolean;
+    canReceiveChildren(_shape: GroupShapeRecord): boolean;
+}

package/_vendor/plugin-group/canvas.d.ts

@@ -0,0 +1,10 @@
+import type { LandCanvasPlugin } from "../canvas-plugin-api/index";
+import type { GroupShapeRecord } from "./GroupShapeUtil";
+interface GroupShapeSvgProps {
+    shape: GroupShapeRecord;
+}
+export declare function createGroupCanvasPlugin(): LandCanvasPlugin;
+export declare function GroupShapeSvg({ shape, isSelected, }: GroupShapeSvgProps & {
+    isSelected?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/_vendor/plugin-group/core.d.ts

@@ -0,0 +1,7 @@
+import { type LandCorePlugin, type ShapeSvgExporter, type SvgNode } from "../canvas-core/index";
+import { type GroupShapeRecord } from "./GroupShapeUtil";
+export declare class GroupShapeSvgExporter implements ShapeSvgExporter<GroupShapeRecord> {
+    readonly type: "group";
+    toSvg(_shape: GroupShapeRecord): SvgNode;
+}
+export declare function createGroupCorePlugin(): LandCorePlugin;

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-plugin-api/index";
+export declare function createGroupFeatureBundle(): LandFeatureBundle;
+export declare const Group: import("../canvas-plugin-api/index").ConfigurableLandExtension<Record<string, never>>;

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

@@ -0,0 +1,10 @@
+import { Box, ShapeUtil, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors } from "../canvas-core/index";
+import type { ImageShapeProps, ImageShapeRecord } from "./types";
+export declare class ImageShapeUtil extends ShapeUtil<ImageShapeRecord> {
+    readonly type: "image";
+    getDefaultProps(): ImageShapeProps;
+    validateProps(props: unknown): ImageShapeProps;
+    getBounds(shape: ImageShapeRecord): Box;
+    canEdit(_shape: ImageShapeRecord): boolean;
+    getSelectionHandleAnchors(shape: ImageShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+}

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

@@ -0,0 +1,2 @@
+import type { LandCanvasPlugin } from "../canvas-plugin-api/index";
+export declare function createImageCanvasPlugin(): LandCanvasPlugin;

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

@@ -0,0 +1,16 @@
+import { type LandCorePlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode, type ToolbarContext } from "../canvas-core/index";
+import { type ImageShapeRecord } from "./types";
+export declare const IMAGE_REPLACE_TOOLBAR_ACTION_ID = "image.replace";
+export declare const IMAGE_DOWNLOAD_TOOLBAR_ACTION_ID = "image.download-original";
+export declare const IMAGE_INSERT_TOOLBAR_ACTION_ID = "image.insert";
+export declare const IMAGE_CROP_TOOLBAR_ACTION_ID = "image.crop";
+export declare const IMAGE_CROP_DONE_TOOLBAR_ACTION_ID = "image.crop.done";
+export declare const IMAGE_CROP_ZOOM_TOOLBAR_ACTION_ID = "image.crop.zoom";
+export declare const IMAGE_CROP_ASPECT_RATIO_TOOLBAR_ACTION_ID = "image.crop.aspect-ratio";
+export declare const IMAGE_CROP_RESET_TOOLBAR_ACTION_ID = "image.crop.reset";
+export declare class ImageShapeSvgExporter implements ShapeSvgExporter<ImageShapeRecord> {
+    readonly type: "image";
+    toSvg(shape: ImageShapeRecord, context: SvgExportContext): SvgNode | null;
+}
+export declare function createImageCorePlugin(): LandCorePlugin;
+export declare function isImageCropToolbarSession(context: ToolbarContext): boolean;