@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-draw/_vendor/canvas-react/components/useCanvasDomEvents.d.ts

@@ -0,0 +1,23 @@
+import { type MouseEvent as ReactMouseEvent, type PointerEvent as ReactPointerEvent, type RefObject } from "react";
+import { type Editor, type ShapeEditingSession } from "../../canvas-core/index";
+import type { CanvasContextMenuRequest } from "../contextMenuRequest";
+import type { CanvasDomEventGuards } from "../host/canvasRenderBindings";
+export interface CanvasDomEventHandlers {
+    onPointerDown: (event: ReactPointerEvent<HTMLDivElement>) => void;
+    onAuxClick: (event: ReactMouseEvent<HTMLDivElement>) => void;
+    onContextMenu: (event: ReactMouseEvent<HTMLDivElement>) => void;
+}
+export interface CanvasDomEventState {
+    containerRef: RefObject<HTMLDivElement | null>;
+    handlers: CanvasDomEventHandlers;
+    isPointerActive: boolean;
+    isCameraPanning: boolean;
+    surfaceCursor: string | undefined;
+}
+export declare function useCanvasDomEvents({ activeDomEventGuards, activeToolId, editor, onContextMenuRequest, shapeEditingSession, }: {
+    activeDomEventGuards: CanvasDomEventGuards;
+    activeToolId: string;
+    editor: Editor;
+    onContextMenuRequest?: (request: CanvasContextMenuRequest) => void;
+    shapeEditingSession: ShapeEditingSession | null;
+}): CanvasDomEventState;

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

@@ -0,0 +1,19 @@
+import type { ShapeId, ShapeRecordBase, Vec } from "../canvas-core/index";
+export type CanvasContextMenuTarget = {
+    type: "canvas";
+} | {
+    type: "shape";
+    shapeId: ShapeId;
+    shapeType: ShapeRecordBase["type"];
+    selected: boolean;
+} | {
+    type: "selection";
+    selectedShapeIds: readonly ShapeId[];
+};
+export interface CanvasContextMenuRequest {
+    anchor: {
+        screenPoint: Vec;
+        pagePoint: Vec;
+    };
+    target: CanvasContextMenuTarget;
+}

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

@@ -0,0 +1,10 @@
+import { Vec, type Editor } from "../canvas-core/index";
+export declare const CANVAS_SURFACE_DATA_UI = "canvas-surface";
+export declare const CANVAS_SURFACE_SELECTOR = "[data-ui=\"canvas-surface\"]";
+export declare function getEditableEventTarget(target: EventTarget | null): HTMLElement | null;
+export declare function isEditableEventTarget(target: EventTarget | null): boolean;
+export declare function getCanvasSurfaceElement(root?: ParentNode): HTMLElement | null;
+export declare function getCanvasSurfaceElementForNode(node: Node | null | undefined): HTMLElement | null;
+export declare function forwardWheelEventToCanvasSurface(event: WheelEvent, source: Node, root?: ParentNode): boolean;
+export declare function getCanvasSurfaceScreenPoint(point: Pick<MouseEvent, "clientX" | "clientY">, surface?: HTMLElement | null): Vec;
+export declare function getCanvasSurfacePagePoint(editor: Editor, point: Pick<MouseEvent, "clientX" | "clientY">, surface?: HTMLElement | null): Vec;

package/_vendor/plugin-draw/_vendor/canvas-react/hooks/useEditor.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "../../canvas-core/index";
+export declare const EditorContext: import("react").Context<Editor | null>;
+export declare function useEditor(): Editor;

package/_vendor/plugin-draw/_vendor/canvas-react/hooks/useValue.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyValue } from "../../canvas-core/index";
+export declare function useValue<T>(signal: ReadonlyValue<T>): T;

package/_vendor/plugin-draw/_vendor/canvas-react/host/canvasRenderBindings.d.ts

@@ -0,0 +1,21 @@
+import type { Editor, ReadonlyValue, SelectionCustomHandle, ShapeId, ShapeRecordBase } from "../../canvas-core/index";
+import type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasDomEventGuardCursorInput, CanvasDomEventGuardInput, CanvasOverlayContribution, CanvasRenderPlugin, CanvasRenderPluginComponent } from "./canvasRenderPlugin";
+export interface CanvasRendererLookup {
+    getShapeRenderer(type: ShapeRecordBase["type"]): AnyRegisteredShapeRenderer | null;
+    getShapeOpacityValue(editor: Editor, shapeId: ShapeId): ReadonlyValue<number>;
+}
+export interface CanvasOverlayLookup {
+    getCanvasOverlays(): readonly CanvasOverlayContribution[];
+    getSelectionCustomHandleRenderer(type: SelectionCustomHandle["type"]): AnyRegisteredSelectionCustomHandleRenderer | null;
+}
+export interface CanvasDomEventGuards {
+    handle(input: CanvasDomEventGuardInput): "continue" | "handled";
+    getCursor(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export interface CanvasRenderBindings {
+    readonly canvasComponents: readonly CanvasRenderPluginComponent[];
+    readonly renderers: CanvasRendererLookup;
+    readonly overlays: CanvasOverlayLookup;
+    readonly domEventGuards: CanvasDomEventGuards;
+}
+export declare function createCanvasRenderBindings(plugins: readonly CanvasRenderPlugin[]): CanvasRenderBindings;

package/_vendor/plugin-draw/_vendor/canvas-react/host/canvasRenderBindingsContext.d.ts

@@ -0,0 +1,5 @@
+import { type CanvasOverlayLookup, type CanvasRenderBindings, type CanvasRendererLookup } from "./canvasRenderBindings";
+export declare const CanvasRenderBindingsContext: import("react").Context<CanvasRenderBindings>;
+export declare function useCanvasRenderBindings(): CanvasRenderBindings;
+export declare function useCanvasRenderers(): CanvasRendererLookup;
+export declare function useCanvasOverlays(): CanvasOverlayLookup;

package/_vendor/plugin-draw/_vendor/canvas-react/host/canvasRenderPlugin.d.ts

@@ -0,0 +1,81 @@
+import type { ComponentType } from "react";
+import type { Editor, ReadonlyValue, SelectionCustomHandle, ShapeEditingSession, ShapeRecordBase } from "../../canvas-core/index";
+export interface ShapeRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    isSelected: boolean;
+    shapeEditingSession: ShapeEditingSession | null;
+}
+/**
+ * Rendered inside the shape's render-bounds host. SVG coordinates should match
+ * the shape util's `getRenderBounds()` coordinate space.
+ */
+export interface ShapeHoverRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    /** Local-space width that renders as the standard hover width on screen. */
+    strokeWidth: number;
+}
+export declare const SHAPE_HOVER_STROKE = "var(--land-shape-hover, var(--land-selection, #2563eb))";
+/** Standard hover stroke width in screen pixels. */
+export declare const SHAPE_HOVER_STROKE_WIDTH = 2;
+export interface RegisteredShapeRenderer<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    component: ComponentType<ShapeRendererProps<S>>;
+    hoverComponent?: ComponentType<ShapeHoverRendererProps<S>>;
+    foregroundComponent?: ComponentType<ShapeRendererProps<S>>;
+}
+export type AnyRegisteredShapeRenderer = RegisteredShapeRenderer<any>;
+export interface SelectionCustomHandleRendererProps<H extends SelectionCustomHandle = SelectionCustomHandle> {
+    handle: H;
+    strokeWidth: number;
+}
+export interface RegisteredSelectionCustomHandleRenderer<H extends SelectionCustomHandle = SelectionCustomHandle> {
+    type: H["type"];
+    component: ComponentType<SelectionCustomHandleRendererProps<H>>;
+}
+export type AnyRegisteredSelectionCustomHandleRenderer = RegisteredSelectionCustomHandleRenderer<any>;
+export interface CanvasOverlayContribution {
+    id: string;
+    component: ComponentType;
+    order?: number;
+}
+export interface CanvasRenderPluginComponent {
+    id: string;
+    component: ComponentType;
+}
+export interface ShapeOpacityModifier {
+    id: string;
+    getOpacityValue(editor: Editor, shapeId: ShapeRecordBase["id"]): ReadonlyValue<number>;
+}
+export type CanvasDomEventGuardName = "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel" | "wheel" | "key_down" | "key_up";
+export type CanvasDomEventGuardDecision = "continue" | "handled";
+export interface CanvasDomEventGuardInput {
+    name: CanvasDomEventGuardName;
+    event: Event;
+    editor: Editor;
+    container: HTMLElement;
+}
+export interface CanvasDomEventGuardCursorInput {
+    element: Element | null;
+    editor: Editor;
+    container: HTMLElement;
+    clientPoint: {
+        x: number;
+        y: number;
+    } | null;
+}
+export interface CanvasDomEventGuard {
+    id: string;
+    handle(input: CanvasDomEventGuardInput): CanvasDomEventGuardDecision;
+    getCursor?(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export interface CanvasRenderPlugin {
+    id: string;
+    shapeRenderers?: readonly AnyRegisteredShapeRenderer[];
+    canvasOverlays?: readonly CanvasOverlayContribution[];
+    selectionCustomHandleRenderers?: readonly AnyRegisteredSelectionCustomHandleRenderer[];
+    domEventGuards?: readonly CanvasDomEventGuard[];
+    canvasComponents?: readonly CanvasRenderPluginComponent[];
+    shapeOpacityModifiers?: readonly ShapeOpacityModifier[];
+}

package/_vendor/plugin-draw/_vendor/canvas-react/host/index.d.ts

@@ -0,0 +1,5 @@
+export { CanvasRenderBindingsContext, useCanvasOverlays, useCanvasRenderBindings, useCanvasRenderers, } from "./canvasRenderBindingsContext";
+export type { CanvasDomEventGuards, CanvasOverlayLookup, CanvasRendererLookup, } from "./canvasRenderBindings";
+export type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasOverlayContribution, CanvasDomEventGuard, CanvasDomEventGuardCursorInput, CanvasDomEventGuardDecision, CanvasDomEventGuardInput, CanvasDomEventGuardName, CanvasRenderPluginComponent, CanvasRenderPlugin, RegisteredSelectionCustomHandleRenderer, RegisteredShapeRenderer, SelectionCustomHandleRendererProps, ShapeHoverRendererProps, ShapeRendererProps, ShapeOpacityModifier, } from "./canvasRenderPlugin";
+export { SHAPE_HOVER_STROKE, SHAPE_HOVER_STROKE_WIDTH, } from "./canvasRenderPlugin";
+export { createCanvasRenderBindings, type CanvasRenderBindings, } from "./canvasRenderBindings";

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

@@ -0,0 +1,5 @@
+export { Canvas, DefaultGrid, PageSpace } from "./components";
+export type { CanvasContextMenuRequest, CanvasContextMenuTarget, } from "./contextMenuRequest";
+export { CANVAS_SURFACE_DATA_UI, CANVAS_SURFACE_SELECTOR, forwardWheelEventToCanvasSurface, getCanvasSurfaceElement, getCanvasSurfaceElementForNode, getCanvasSurfacePagePoint, getCanvasSurfaceScreenPoint, getEditableEventTarget, isEditableEventTarget, } from "./dom";
+export { useEditor, EditorContext } from "./hooks/useEditor";
+export { useValue } from "./hooks/useValue";

package/_vendor/plugin-draw/_vendor/signals/atom.d.ts

@@ -0,0 +1,11 @@
+import type { SignalGraph } from "./core";
+import type { Signal } from "./types";
+export interface AtomOptions<T> {
+    isEqual?: (left: T, right: T) => boolean;
+}
+export interface Atom<T> extends Signal<T> {
+    set(value: T): T;
+    update(updater: (value: T) => T): T;
+}
+export declare function createAtom<T>(graph: SignalGraph, name: string, initialValue: T, options?: AtomOptions<T>): Atom<T>;
+export declare function isAtom(value: unknown): value is Atom<unknown>;

package/_vendor/plugin-draw/_vendor/signals/computed.d.ts

@@ -0,0 +1,13 @@
+import type { SignalGraph } from "./core";
+import type { Signal } from "./types";
+declare const UNINITIALIZED_VALUE: unique symbol;
+export type UNINITIALIZED = typeof UNINITIALIZED_VALUE;
+export { UNINITIALIZED_VALUE as UNINITIALIZED };
+export interface ComputedOptions<T> {
+    isEqual?: (left: T, right: T) => boolean;
+}
+export interface Computed<T> extends Signal<T> {
+    readonly isComputed: true;
+}
+export declare function createComputed<T>(graph: SignalGraph, name: string, derive: (previous: T | UNINITIALIZED) => T, options?: ComputedOptions<T>): Computed<T>;
+export declare function isComputed(value: unknown): value is Computed<unknown>;

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

@@ -0,0 +1,35 @@
+import { type Atom, type AtomOptions } from "./atom";
+import { type Computed, type ComputedOptions, type UNINITIALIZED } from "./computed";
+import { type EffectSchedulerOptions } from "./effect";
+import type { InternalSignal, ReactiveConsumer } from "./types";
+interface InternalAtom<T> extends InternalSignal<T> {
+    __unsafe__isEqual(left: T, right: T): boolean;
+    __unsafe__restore(value: T, lastChangedEpoch: number): void;
+}
+export declare class SignalGraph {
+    private epoch;
+    private currentTransaction;
+    private captureStack;
+    readonly atom: <T>(name: string, initialValue: T, options?: AtomOptions<T>) => Atom<T>;
+    readonly computed: <T>(name: string, derive: (previous: T | UNINITIALIZED) => T, options?: ComputedOptions<T>) => Computed<T>;
+    readonly effect: (name: string, fn: () => void, options?: EffectSchedulerOptions) => (() => void);
+    readonly transact: (fn: () => void) => void;
+    getEpoch(): number;
+    isComputingSignal(): boolean;
+    /** @internal */
+    advanceEpoch(): number;
+    /** @internal */
+    noteInitialValue<T>(atom: InternalAtom<T>, previousValue: T, previousLastChangedEpoch: number): void;
+    /** @internal */
+    startCapture(consumer: ReactiveConsumer): void;
+    /** @internal */
+    stopCapture(): Set<InternalSignal<any>>;
+    /** @internal */
+    trackDependency(dependency: InternalSignal<any>): void;
+    /** @internal */
+    atomDidChange(atom: InternalAtom<any>): void;
+    private restoreInitialAtomSnapshots;
+    private flushChanges;
+}
+export declare function createSignalGraph(): SignalGraph;
+export {};

package/_vendor/plugin-draw/_vendor/signals/effect.d.ts

@@ -0,0 +1,5 @@
+import type { SignalGraph } from "./core";
+export interface EffectSchedulerOptions {
+    scheduleEffect?: (execute: () => void) => void;
+}
+export declare function createEffect(graph: SignalGraph, name: string, fn: () => void, options?: EffectSchedulerOptions): () => void;

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

@@ -0,0 +1,8 @@
+export { isAtom } from "./atom";
+export type { Atom, AtomOptions } from "./atom";
+export { isComputed, UNINITIALIZED } from "./computed";
+export type { Computed, ComputedOptions } from "./computed";
+export type { EffectSchedulerOptions } from "./effect";
+export { createSignalGraph, SignalGraph } from "./core";
+export { RESET_VALUE } from "./types";
+export type { Signal } from "./types";

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

@@ -0,0 +1,22 @@
+import type { SignalGraph } from "./core";
+/** A readable node owned by one reactive graph. */
+export interface Signal<T> {
+    readonly graph: SignalGraph;
+    readonly name: string;
+    get(): T;
+    peek(): T;
+}
+/** @internal */
+export interface InternalSignal<T> extends Signal<T> {
+    lastChangedEpoch: number;
+    consumers: Set<ReactiveConsumer>;
+}
+export type ReactiveConsumer = {
+    type: "computed";
+    signal: InternalSignal<any>;
+} | {
+    type: "effect";
+    notify(): void;
+};
+export declare const RESET_VALUE: unique symbol;
+export type RESET_VALUE = typeof RESET_VALUE;

package/_vendor/plugin-draw/_vendor/store/diff.d.ts

@@ -0,0 +1,9 @@
+import type { RecordsDiff, StoreRecord } from "./types";
+export declare function createEmptyRecordsDiff<TRecord extends StoreRecord>(): RecordsDiff<TRecord>;
+export declare function isRecordsDiffEmpty<TRecord extends StoreRecord>(diff: RecordsDiff<TRecord>): boolean;
+export declare function getRecordMap<TRecord extends StoreRecord>(records: Map<string, TRecord> | Iterable<TRecord>): Map<string, TRecord>;
+export declare function getRecordsDiff<TRecord extends StoreRecord>(before: Map<string, TRecord> | Iterable<TRecord>, after: Map<string, TRecord> | Iterable<TRecord>): RecordsDiff<TRecord>;
+export declare function invertRecordsDiff<TRecord extends StoreRecord>(diff: RecordsDiff<TRecord>): RecordsDiff<TRecord>;
+export declare function composeRecordsDiff<TRecord extends StoreRecord, TNextRecord extends TRecord>(left: RecordsDiff<TRecord>, right: RecordsDiff<TNextRecord>): RecordsDiff<TRecord | TNextRecord>;
+export declare function squashRecordsDiffs<TRecord extends StoreRecord, TNextRecord extends TRecord>(diffs: Iterable<RecordsDiff<TRecord> | RecordsDiff<TNextRecord>>): RecordsDiff<TRecord | TNextRecord>;
+export declare function filterRecordsDiff<TRecord extends StoreRecord, TFilteredRecord extends TRecord>(diff: RecordsDiff<TRecord>, predicate: (record: TRecord) => record is TFilteredRecord): RecordsDiff<TFilteredRecord>;

package/_vendor/plugin-draw/_vendor/store/history.d.ts

@@ -0,0 +1,22 @@
+import type { RecordsDiff, StoreRecord } from "./types";
+export interface StoreHistoryEntry<TRecord extends StoreRecord = StoreRecord> {
+    forward: RecordsDiff<TRecord>;
+    inverse: RecordsDiff<TRecord>;
+    label: string;
+}
+export declare function createStoreHistoryEntry<TRecord extends StoreRecord>(label: string, forward: RecordsDiff<TRecord>): StoreHistoryEntry<TRecord>;
+export declare class StoreHistoryBuffer<TRecord extends StoreRecord = StoreRecord> {
+    private readonly undoStack;
+    private readonly redoStack;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    clear(): void;
+    append(diff: RecordsDiff<TRecord>, label?: string): void;
+    undo(): StoreHistoryEntry<TRecord> | null;
+    redo(): StoreHistoryEntry<TRecord> | null;
+    /** Restores only the cursor movement performed by undo(). */
+    rollbackUndo(entry: StoreHistoryEntry<TRecord>): void;
+    /** Restores only the cursor movement performed by redo(). */
+    rollbackRedo(entry: StoreHistoryEntry<TRecord>): void;
+    getEntries(): readonly StoreHistoryEntry<TRecord>[];
+}

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

@@ -0,0 +1,5 @@
+export { composeRecordsDiff, createEmptyRecordsDiff, filterRecordsDiff, getRecordMap, getRecordsDiff, invertRecordsDiff, isRecordsDiffEmpty, squashRecordsDiffs, } from "./diff";
+export { createStoreHistoryEntry, StoreHistoryBuffer, } from "./history";
+export { Store, type StoreOptions } from "./store";
+export type { ChangeSource, RecordUpdate, RecordsDiff, ScopedStoreRecord, StoreRecord, StoreChange, StoreScopeOf, StoreSnapshot, } from "./types";
+export type { StoreHistoryEntry } from "./history";

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

@@ -0,0 +1,40 @@
+import { type Signal, type SignalGraph } from "../signals/index";
+import type { ChangeSource, RecordsDiff, ScopedStoreRecord, StoreChange, StoreRecord, StoreScopeOf } from "./types";
+type StoreListener<TRecord extends StoreRecord> = (change: StoreChange<TRecord>) => void;
+export interface StoreOptions<TRecord extends StoreRecord> {
+    signals?: SignalGraph;
+    writeGuard?: (change: StoreChange<TRecord>) => void;
+}
+type ScopedRecord<TRecord extends StoreRecord> = Extract<TRecord, ScopedStoreRecord>;
+export declare class Store<TRecord extends StoreRecord = StoreRecord> {
+    readonly signals: SignalGraph;
+    private readonly records;
+    private activeTransaction;
+    private readonly recordAtoms;
+    private readonly revisionAtom;
+    private readonly draftRevisionAtom;
+    private readonly listeners;
+    private readonly writeGuard?;
+    constructor(initialRecords: TRecord[], options?: StoreOptions<TRecord>);
+    get(id: string): TRecord | undefined;
+    getRevision(): number;
+    getActiveTransactionRevision(): number | null;
+    getActiveTransactionDiff(): RecordsDiff<TRecord>;
+    getRecordSignal(id: string): Signal<TRecord | undefined>;
+    getAll(): TRecord[];
+    getByScope<TScope extends StoreScopeOf<ScopedRecord<TRecord>>>(scope: TScope): Array<Extract<ScopedRecord<TRecord>, {
+        scope: TScope;
+    }>>;
+    listen(listener: StoreListener<TRecord>): () => void;
+    atomic(fn: () => void, source?: ChangeSource): void;
+    put(records: TRecord[], source?: ChangeSource): void;
+    remove(ids: string[], source?: ChangeSource): void;
+    applyDiff<TChangeRecord extends TRecord>(diff: RecordsDiff<TChangeRecord>, source?: ChangeSource): void;
+    private stageRecord;
+    private getReadableRecords;
+    private requireActiveTransaction;
+    private bumpDraftRevision;
+    private restoreTransactionSignals;
+    private notifyListeners;
+}
+export {};

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

@@ -0,0 +1,27 @@
+export type ChangeSource = "user" | "system" | "history";
+export interface StoreRecord {
+    id: string;
+}
+export interface ScopedStoreRecord<TScope extends string = string> extends StoreRecord {
+    scope: TScope;
+}
+export type StoreScopeOf<TRecord> = TRecord extends {
+    scope: infer TScope extends string;
+} ? TScope : never;
+export interface StoreSnapshot<TRecord extends StoreRecord = StoreRecord, TSchemaVersion extends number = number> {
+    schemaVersion: TSchemaVersion;
+    records: TRecord[];
+}
+export interface RecordUpdate<TRecord extends StoreRecord = StoreRecord> {
+    before: TRecord;
+    after: TRecord;
+}
+export interface RecordsDiff<TRecord extends StoreRecord = StoreRecord> {
+    added: TRecord[];
+    updated: RecordUpdate<TRecord>[];
+    removed: TRecord[];
+}
+export interface StoreChange<TRecord extends StoreRecord = StoreRecord> {
+    source: ChangeSource;
+    diff: RecordsDiff<TRecord>;
+}

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

@@ -0,0 +1,13 @@
+import type { Editor, ShapeId } from "./_vendor/canvas-core/index";
+import { type DrawShapeProps } from "./types";
+export type DrawStylePatch = Partial<Pick<DrawShapeProps, "fill" | "stroke" | "strokeWidth" | "isClosed">>;
+export interface DrawApi {
+    getSelectionStyle(): DrawStylePatch | null;
+    setSelectionStyle(patch: DrawStylePatch): readonly ShapeId[];
+    getToolDefaults(): DrawShapeProps;
+    setToolDefaults(patch: DrawStylePatch): DrawShapeProps;
+}
+export declare const drawApiToken: import("./_vendor/canvas-extension-contracts/index").CanvasApiToken<DrawApi>;
+export declare function createDrawPluginApi({ editor, }: {
+    editor: Editor;
+}): DrawApi;

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

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

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

@@ -0,0 +1,42 @@
+import { Box, Vec } from "./_vendor/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">;
+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 normalizeDrawShapeFromPoints(pagePoints: readonly DrawShapePoint[], strokeWidth: number, isPen?: boolean, isClosed?: boolean): NormalizedDrawShape;
+export declare function normalizeDrawShapeFromSegments(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 getDrawShapeParentPoints(shape: DrawShapeRecord): DrawShapePoint[];
+export declare function getDrawShapeParentSegments(shape: DrawShapeRecord): DrawShapeSegment[];
+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, type ShapeColor } from "./_vendor/canvas-core/index";
+import type { DrawShapeGeometry } from "./drawShapeGeometry";
+interface DrawShapeHitTestOptions {
+    fill?: ShapeColor;
+    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,43 @@
+import { Vec } from "./_vendor/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 DrawInputPointGuardState {
+    anchorPoint: DrawShapePoint;
+    hasProvisionalPoint: boolean;
+}
+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, state: DrawInputPointGuardState, appendOptions?: {
+    force?: boolean;
+}): DrawInputPointGuardState;
+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 "./_vendor/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 "./_vendor/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 "./_vendor/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 "./_vendor/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;
+    getPositionedBounds(shape: DrawShapeRecord): Box;
+    getLocalBounds(shape: DrawShapeRecord): Box;
+    getRenderBounds(shape: DrawShapeRecord): Box;
+    getExportBounds(shape: DrawShapeRecord): Box;
+    canReceiveTerminalBinding(_shape: DrawShapeRecord): boolean;
+    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;
+}