@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

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

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

@@ -0,0 +1,3 @@
+import { type LandFeatureBundle } from "../canvas-react/host/index";
+export declare function createDrawFeatureBundle(): LandFeatureBundle;
+export declare const Draw: import("../canvas-react/host/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, createDrawEditorPlugin } from "./editor";
+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 ShapeColor, 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: ShapeColor;
+    strokeWidth: number;
+    fill: ShapeColor;
+    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/canvas.d.ts

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

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

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

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

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

package/_vendor/plugin-eraser/{index.ts → index.d.ts}

@@ -1,4 +1,4 @@
-export { EraserTool } from "./EraserTool";
+export { EraserTool } from "./eraserTool";
 export { createEraserCanvasPlugin } from "./canvas";
-export { createEraserCorePlugin } from "./core";
+export { createEraserEditorPlugin } from "./editor";
 export { Eraser, createEraserFeatureBundle } from "./feature";

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

@@ -0,0 +1,9 @@
+import { type LandCanvasPlugin } from "../canvas-react/host/index";
+import type { FrameShapeRecord } from "./frameShapeUtil";
+interface FrameShapeSvgProps {
+    shape: FrameShapeRecord;
+    isHovered?: boolean;
+}
+export declare function createFrameCanvasPlugin(): LandCanvasPlugin;
+export declare function FrameShapeSvg({ shape, isHovered }: FrameShapeSvgProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

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

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

@@ -0,0 +1,23 @@
+import { Box, ShapeUtil, Vec, type ShapeColor, type ShapeBrushSelectInput, type ShapeLineSegmentHitTestInput, type ShapeRecordBase } from "../canvas-core/index";
+export interface FrameShapeProps {
+    w: number;
+    h: number;
+    name: string;
+    fill: ShapeColor;
+    stroke: ShapeColor;
+    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;
+    getPointHitTestBounds(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/index.d.ts

@@ -0,0 +1,6 @@
+export { FrameShapeUtil } from "./frameShapeUtil";
+export type { FrameShapeProps, FrameShapeRecord } from "./frameShapeUtil";
+export { FrameTool } from "./frameTool";
+export { FrameShapeSvgExporter, createFrameEditorPlugin } from "./editor";
+export { createFrameCanvasPlugin } from "./canvas";
+export { Frame, createFrameFeatureBundle } from "./feature";

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { GeoShapeKind } from "./types";
+export declare const GEO_ELLIPSE_SEGMENTS = 32;
+export declare function getGeoOutlinePoints(bounds: Box, geo: GeoShapeKind): Vec[];
+export declare function getGeoEllipsePoints(bounds: Box, segments?: number): Vec[];
+export declare function getGeoPolygonPoints(bounds: Box, geo: Exclude<GeoShapeKind, "ellipse">): Vec[];
+export declare function getGeoPolygonPoints(bounds: Box, geo: GeoShapeKind): Vec[];
+export declare function isPointInPolygon(point: Vec, points: readonly Vec[]): boolean;

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,26 @@
+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 declare class TriangleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class HexagonTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class StarTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export {};

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

@@ -0,0 +1,7 @@
+export { DiamondTool, EllipseTool, HexagonTool, RectangleTool, StarTool, TriangleTool, } from "./geoTools";
+export { GeoShapeUtil } from "./geoShapeUtil";
+export { GeoShapeSvgExporter, createGeoEditorPlugin } from "./editor";
+export { GeoShapeSvg, createGeoCanvasPlugin } from "./canvas";
+export { Geo, createGeoFeatureBundle } from "./feature";
+export type { GeoShapeKind, GeoShapeProps, GeoShapeRecord } from "./types";
+export { GEO_SHAPE_KINDS, isGeoShapeKind, isGeoShapeRecord } from "./types";

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

@@ -0,0 +1,17 @@
+import { type ShapeColor, type BaseRecord, type ShapeRecordBase } from "../canvas-core/index";
+export declare const GEO_SHAPE_KINDS: readonly ["rectangle", "ellipse", "diamond", "triangle", "hexagon", "star"];
+export type GeoShapeKind = (typeof GEO_SHAPE_KINDS)[number];
+export interface GeoShapeProps {
+    w: number;
+    h: number;
+    geo: GeoShapeKind;
+    fill: ShapeColor;
+    stroke: ShapeColor;
+    strokeWidth: number;
+}
+export interface GeoShapeRecord extends ShapeRecordBase<"geo", GeoShapeProps> {
+    type: "geo";
+    props: GeoShapeProps;
+}
+export declare function isGeoShapeRecord(record: BaseRecord | null | undefined): record is GeoShapeRecord;
+export declare function isGeoShapeKind(value: unknown): value is GeoShapeKind;

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

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

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

@@ -0,0 +1,7 @@
+import { type LandEditorPlugin, 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 createGroupEditorPlugin(): LandEditorPlugin;

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

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

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

@@ -0,0 +1,5 @@
+export { GroupShapeUtil } from "./groupShapeUtil";
+export type { GroupShapeProps, GroupShapeRecord } from "./groupShapeUtil";
+export { GroupShapeSvgExporter, createGroupEditorPlugin } from "./editor";
+export { createGroupCanvasPlugin } from "./canvas";
+export { Group, createGroupFeatureBundle } from "./feature";

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

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

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

@@ -0,0 +1,112 @@
+import { Vec, type SelectionResizeHandleId, type ShapeUpdate } from "../canvas-core/index";
+import type { ImageShapeCrop, ImageShapeRecord } from "./types";
+export declare const IMAGE_CROP_HANDLE_TYPE = "image.crop";
+export declare const IMAGE_CROP_HISTORY_MARK_PREFIX = "image.crop:";
+export declare const IMAGE_CROP_HANDLE_HISTORY_MARK = "image.crop.handle";
+export declare const IMAGE_CROP_TRANSLATE_HISTORY_MARK = "image.crop.translate";
+export declare const IMAGE_CROP_MODE_ENTRY_MARK_PREFIX = "image.crop:edit:";
+export declare const IMAGE_CROP_ASPECT_RATIO_PRESETS: readonly [{
+    readonly label: "1:1";
+    readonly value: "1:1";
+    readonly ratio: 1;
+}, {
+    readonly label: "4:3";
+    readonly value: "4:3";
+    readonly ratio: number;
+}, {
+    readonly label: "16:9";
+    readonly value: "16:9";
+    readonly ratio: number;
+}];
+export type ImageCropAspectRatioPresetValue = (typeof IMAGE_CROP_ASPECT_RATIO_PRESETS)[number]["value"];
+export interface ImageCropRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface ImageCropPlacement {
+    imageX: number;
+    imageY: number;
+    imageWidth: number;
+    imageHeight: number;
+    rect: ImageCropRect;
+}
+export interface ImageCropCustomHandleAnchor {
+    kind: "custom";
+    type: typeof IMAGE_CROP_HANDLE_TYPE;
+    id: SelectionResizeHandleId;
+    point: Vec;
+    cursor: string;
+}
+interface UncroppedImageSpace {
+    w: number;
+    h: number;
+}
+export declare function normalizeImageShapeCrop(value: unknown): ImageShapeCrop | null;
+export declare function getImageCropRect(crop: ImageShapeCrop | null | undefined): ImageCropRect | null;
+export declare function getDefaultImageCrop(): ImageShapeCrop;
+export declare function getImageCropRectOrDefault(crop: ImageShapeCrop | null | undefined): ImageCropRect;
+export declare function getUncroppedImageSize({ crop, shape, }: {
+    crop: ImageShapeCrop | null | undefined;
+    shape: ImageShapeRecord;
+}): UncroppedImageSpace;
+export declare function getImageCropAspectRatioPresetValue(shape: ImageShapeRecord): ImageCropAspectRatioPresetValue | null;
+export declare function isImageCropModeForShape(shape: ImageShapeRecord, markId: string | null | undefined): boolean;
+export declare function getImageCropModeMarkId(shapeId: ImageShapeRecord["id"]): string;
+export declare function getImageCropHandleIds(): readonly SelectionResizeHandleId[];
+export declare function isImageCropHandleId(value: string): value is SelectionResizeHandleId;
+export declare function getImageCropHandleCursor(handleId: SelectionResizeHandleId): string;
+export declare function getImageCropHandleAnchors({ localToPage, shape, }: {
+    crop: ImageShapeCrop | null | undefined;
+    localToPage: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+}): ImageCropCustomHandleAnchor[];
+export declare function getImageCropUpdateFromHandleDrag({ handleId, pageToLocal, shape, startCrop, startPagePoint, currentPagePoint, }: {
+    handleId: SelectionResizeHandleId;
+    pageToLocal: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+    startPagePoint: Vec;
+    currentPagePoint: Vec;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromContentDrag({ currentPagePoint, pageToLocal, shape, startCrop, startPagePoint, shiftKey, }: {
+    currentPagePoint: Vec;
+    pageToLocal: {
+        applyToPoint(point: Vec): Vec;
+    };
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+    startPagePoint: Vec;
+    shiftKey: boolean;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromContentNudge({ pageDelta, shape, startCrop, }: {
+    pageDelta: Vec;
+    shape: ImageShapeRecord;
+    startCrop: ImageShapeCrop | null | undefined;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromZoom({ direction, shape, }: {
+    direction: "in" | "out";
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropUpdateFromAspectRatioPreset({ preset, shape, }: {
+    preset: ImageCropAspectRatioPresetValue;
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropResetUpdate({ baselineShape, shape, }: {
+    baselineShape: ImageShapeRecord;
+    shape: ImageShapeRecord;
+}): ShapeUpdate | null;
+export declare function getImageCropPlacement({ crop, shapeHeight, shapeWidth, }: {
+    crop: ImageShapeCrop | null | undefined;
+    shapeHeight: number;
+    shapeWidth: number;
+}): ImageCropPlacement | null;
+export declare function formatImageCropViewBox(rect: ImageCropRect): string;
+export {};

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

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

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

@@ -0,0 +1,4 @@
+import type { ImageShapeRecord } from "./types";
+export declare function rememberImageCropSessionBaseline(shape: ImageShapeRecord): void;
+export declare function getImageCropSessionBaseline(shapeId: ImageShapeRecord["id"]): ImageShapeRecord | null;
+export declare function clearImageCropSessionBaseline(shapeId: ImageShapeRecord["id"]): void;

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

@@ -0,0 +1,16 @@
+import { type LandEditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode, type CanvasActionContext } 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 createImageEditorPlugin(): LandEditorPlugin;
+export declare function isImageCropToolbarSession(context: CanvasActionContext): boolean;

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

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

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

@@ -0,0 +1,11 @@
+import { Box, ShapeUtil, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionResizeAspectRatioLockInput } 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;
+    getSelectionResizeAspectRatioLock(_shape: ImageShapeRecord, input: ShapeSelectionResizeAspectRatioLockInput): boolean | null;
+    canEdit(_shape: ImageShapeRecord): boolean;
+    getSelectionHandleAnchors(shape: ImageShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+}