@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/_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-path/api.d.ts

@@ -0,0 +1,37 @@
+import { type Editor, type ShapeColor, type ShapeId } from "./_vendor/canvas-core/index";
+import { type PathNodeOperation } from "./pathGeometry";
+import { type PathBooleanOperation } from "./pathBoolean";
+import { type PathShapeProps } from "./types";
+export type PathStylePatch = Partial<Pick<PathShapeProps, "fill" | "stroke" | "strokeWidth">>;
+export interface PathSelectionStyle {
+    readonly fill: ShapeColor | null;
+    readonly stroke: ShapeColor | null;
+    readonly strokeWidth: number | null;
+}
+export interface PathApi {
+    getSelectionStyle(): PathSelectionStyle | null;
+    setSelectionStyle(patch: PathStylePatch): readonly ShapeId[];
+    getToolDefaults(): PathShapeProps;
+    setToolDefaults(patch: PathStylePatch): PathShapeProps;
+    canBeginEdit(): boolean;
+    beginEdit(): boolean;
+    isEditing(): boolean;
+    completeEdit(): boolean;
+    isNodeSnapEnabled(): boolean;
+    canToggleNodeSnap(): boolean;
+    toggleNodeSnap(): boolean;
+    canDeleteSelectedNodes(): boolean;
+    deleteSelectedNodes(): boolean;
+    canMakeSelectedNodesCurve(): boolean;
+    makeSelectedNodesCurve(): boolean;
+    canRemoveSelectedNodeHandles(): boolean;
+    removeSelectedNodeHandles(): boolean;
+    canRunSelectedNodeOperation(operation: PathNodeOperation): boolean;
+    runSelectedNodeOperation(operation: PathNodeOperation): boolean;
+    canRunBooleanOperation(): boolean;
+    runBooleanOperation(operation: PathBooleanOperation): ShapeId | null;
+}
+export declare const pathApiToken: import("./_vendor/canvas-extension-contracts/index").CanvasApiToken<PathApi>;
+export declare function createPathPluginApi({ editor, }: {
+    editor: Editor;
+}): PathApi;

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

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

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

@@ -0,0 +1,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "./_vendor/canvas-core/index";
+import type { PathShapeRecord } from "./types";
+export declare class PathShapeSvgExporter implements ShapeSvgExporter<PathShapeRecord> {
+    readonly type: "path";
+    toSvg(shape: PathShapeRecord, context: SvgExportContext): SvgNode | null;
+}
+export declare function createPathEditorPlugin(): EditorPlugin;

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

@@ -0,0 +1,3 @@
+import type { CanvasPlugin } from "@yuzhouu/canvas-kit";
+import type { PathApi } from "./api";
+export declare const Path: CanvasPlugin<PathApi>;

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

@@ -0,0 +1,11 @@
+export { createPathCanvasRenderPlugin } from "./canvasRender";
+export { PathShapeSvgExporter, createPathEditorPlugin, } from "./editorRuntime";
+export { Path } from "./feature";
+export { pathApiToken } from "./api";
+export type { PathApi, PathSelectionStyle, PathStylePatch, } from "./api";
+export type { PathBooleanOperation } from "./pathBoolean";
+export type { PathNodeOperation } from "./pathGeometry";
+export { PATH_CONTROL_HANDLE_TYPE, PATH_NODE_HANDLE_TYPE, createPathControlHandleId, createPathNodeHandleId, parsePathHandle, type PathControlHandleKind, type PathControlHandleInfo, type PathHandleInfo, type PathNodeHandleInfo, } from "./pathHandles";
+export { PathShapeUtil } from "./pathShapeUtil";
+export { PathTool } from "./pathTool";
+export { PATH_FILL_RULES, PATH_NODE_KINDS, isPathFillRule, isPathNodeKind, isPathShapeRecord, type PathFillRule, type PathHandle, type PathNode, type PathNodeKind, type PathShapeProps, type PathShapeRecord, type PathSubpath, } from "./types";

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,74 @@
+import { Box, Vec } from "./_vendor/canvas-core/index";
+import type { PathHandle, PathNode, PathShapeProps, PathShapeRecord, PathSubpath } from "./types";
+export interface FlattenedPathSubpath {
+    id: string;
+    closed: boolean;
+    points: Vec[];
+}
+export interface PathSegmentHit {
+    subpathId: string;
+    startNodeId: string;
+    endNodeId: string;
+    t: number;
+    point: Vec;
+    distance: number;
+}
+export interface PathNodeRef {
+    subpathId: string;
+    nodeId: string;
+}
+export type PathNodeOperation = "merge" | "join" | "separate";
+export interface PathNodeOperationResult {
+    subpaths: PathSubpath[];
+    selectedNodes: PathNodeRef[];
+    primaryNode: PathNodeRef | null;
+}
+export interface PathShapeGeometry {
+    path: string | null;
+    pointBounds: Box;
+    localBounds: Box;
+    renderBounds: Box;
+    outlineVertices: Vec[];
+    flattenedSubpaths: FlattenedPathSubpath[];
+}
+export interface NormalizedPathShape {
+    x: number;
+    y: number;
+    subpaths: PathSubpath[];
+    geometry: PathShapeGeometry;
+}
+export declare function clonePathHandle(handle: PathHandle): PathHandle;
+export declare function clonePathNode(node: PathNode): PathNode;
+export declare function clonePathSubpath(subpath: PathSubpath): PathSubpath;
+export declare function clonePathSubpaths(subpaths: readonly PathSubpath[]): PathSubpath[];
+export declare function getNodePoint(node: PathNode): Vec;
+export declare function getNodeInPoint(node: PathNode): Vec;
+export declare function getNodeOutPoint(node: PathNode): Vec;
+export declare function flattenPathSubpath(subpath: PathSubpath): FlattenedPathSubpath;
+export declare function getPathShapeLocalGeometry(shape: Pick<PathShapeRecord, "props">): PathShapeGeometry;
+export declare function translatePathSubpaths(subpaths: readonly PathSubpath[], dx: number, dy: number): PathSubpath[];
+export declare function mapPathSubpaths(subpaths: readonly PathSubpath[], mapPoint: (point: Vec) => Vec): PathSubpath[];
+export declare function normalizePathShapeFromPageSubpaths(pageSubpaths: readonly PathSubpath[], props: Pick<PathShapeProps, "strokeWidth" | "fill" | "stroke" | "fillRule">): NormalizedPathShape;
+export declare function resizePathShapeToLocalBounds(shape: PathShapeRecord, targetBounds: Box): PathSubpath[];
+export declare function getPathShapePageSubpaths(shape: PathShapeRecord, localToPage: {
+    applyToPoint(point: Vec): Vec;
+}): PathSubpath[];
+export declare function getPathShapePagePath(shape: PathShapeRecord, localToPage: {
+    applyToPoint(point: Vec): Vec;
+}): string | null;
+export declare function hitTestPathStroke(flattenedSubpaths: readonly FlattenedPathSubpath[], point: Vec, margin: number): boolean;
+export declare function findPathSegmentAtLocalPoint(subpaths: readonly PathSubpath[], point: Vec, margin: number): PathSegmentHit | null;
+export declare function hitTestPathFill(flattenedSubpaths: readonly FlattenedPathSubpath[], point: Vec, fillRule: "nonzero" | "evenodd"): boolean;
+export declare function getPathSubpathById(subpaths: readonly PathSubpath[], subpathId: string): PathSubpath | null;
+export declare function getPathNodeById(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string): PathNode | null;
+export declare function updatePathNode(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string, update: (node: PathNode) => PathNode): PathSubpath[];
+export declare function updatePathNodeEntries(subpaths: readonly PathSubpath[], entries: readonly PathNodeRef[], update: (node: PathNode) => PathNode): PathSubpath[];
+export declare function setPathNodeCurveHandles(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string): PathSubpath[];
+export declare function removePathNodeHandles(subpaths: readonly PathSubpath[], subpathId: string, nodeId: string): PathSubpath[];
+export declare function removePathNodeEntries(subpaths: readonly PathSubpath[], entries: readonly PathNodeRef[]): PathSubpath[];
+export declare function canApplyPathNodeOperation(subpaths: readonly PathSubpath[], refs: readonly PathNodeRef[], operation: PathNodeOperation): boolean;
+export declare function applyPathNodeOperation(subpaths: readonly PathSubpath[], refsInput: readonly PathNodeRef[], operation: PathNodeOperation, primaryRef?: PathNodeRef | null): PathNodeOperationResult | null;
+export declare function insertPathNodeAfter(subpaths: readonly PathSubpath[], subpathId: string, afterNodeId: string, node: PathNode): PathSubpath[];
+export declare function insertPathNodeAtSegment(subpaths: readonly PathSubpath[], hit: PathSegmentHit, nodeId: string): PathSubpath[];
+export declare function arePathSubpathsEmpty(subpaths: readonly PathSubpath[]): boolean;
+export declare function sanitizePathSubpaths(subpaths: readonly PathSubpath[]): PathSubpath[];