@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,43 @@
+import type { Editor, ShapeColor, ShapeId } from "./_vendor/canvas-core/index";
+import { type CanvasShapeRef } from "./_vendor/canvas-extension-contracts/index";
+import { type GeoShapeKind, type GeoShapeProps } from "./types";
+export interface GeoCreateInput {
+    kind: GeoShapeKind;
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeStyle?: GeoShapeProps["strokeStyle"];
+    strokeWidth?: number;
+    cornerRadiusPercent?: number;
+    meta?: Record<string, unknown>;
+}
+export interface GeoStylePatch {
+    kind?: GeoShapeKind;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeStyle?: GeoShapeProps["strokeStyle"];
+    strokeWidth?: number;
+    cornerRadiusPercent?: number;
+}
+export interface GeoSelectionStyle {
+    readonly kind: GeoShapeKind | null;
+    readonly fill: ShapeColor | null;
+    readonly stroke: ShapeColor | null;
+    readonly strokeStyle: GeoShapeProps["strokeStyle"] | null;
+    readonly strokeWidth: number | null;
+    readonly cornerRadiusPercent: number | null;
+}
+export interface GeoApi {
+    create(input: GeoCreateInput): CanvasShapeRef<"geo"> | null;
+    getSelectionStyle(): GeoSelectionStyle | null;
+    setSelectionStyle(patch: GeoStylePatch): readonly ShapeId[];
+    getToolDefaults(): GeoShapeProps;
+    setToolDefaults(patch: GeoStylePatch): GeoShapeProps;
+}
+export declare const geoApiToken: import("./_vendor/canvas-extension-contracts/index").CanvasApiToken<GeoApi>;
+export declare function createGeoPluginApi({ editor, }: {
+    editor: Editor;
+}): GeoApi;

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

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

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

@@ -0,0 +1,7 @@
+import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "./_vendor/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(): EditorPlugin;

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

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

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

@@ -0,0 +1,20 @@
+import { Box, type Editor, type ReadonlyValue, type Vec } from "./_vendor/canvas-core/index";
+import { type GeoShapeProps } from "./types";
+interface GeoHoverSample {
+    pagePoint: Vec;
+    timestamp: number;
+}
+export interface GeoCreationPreview {
+    bounds: Box;
+    props: GeoShapeProps;
+}
+export interface GeoCreationRuntime {
+    readonly preview: ReadonlyValue<GeoCreationPreview | null>;
+    setHover(sample: GeoHoverSample): void;
+    clearHover(): void;
+}
+export declare const geoCreationRuntimeToken: import("./_vendor/canvas-core/index").EditorRuntimeToken<GeoCreationRuntime>;
+export declare function createGeoCreationRuntime(editor: Editor): GeoCreationRuntime;
+export declare function getGeoCreationRuntime(editor: Editor): GeoCreationRuntime;
+export declare function getGeoDefaultBoundsAtTopLeft(topLeft: Vec, props: GeoShapeProps): Box;
+export {};

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

@@ -0,0 +1,64 @@
+import { Box, Vec } from "./_vendor/canvas-core/index";
+import type { GeoShapeKind } from "./types";
+export declare const GEO_ELLIPSE_SEGMENTS = 32;
+export declare const GEO_RECTANGLE_DEFAULT_CORNER_RADIUS_PERCENT = 12;
+export declare const GEO_RECTANGLE_MAX_CORNER_RADIUS_PERCENT = 50;
+export declare const GEO_RECTANGLE_CORNER_SEGMENTS = 4;
+export type GeoVisualGeometry = {
+    tag: "ellipse";
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+} | {
+    tag: "path";
+    d: string;
+    transform?: string;
+    fill?: "none";
+    vectorEffect?: "non-scaling-stroke";
+} | {
+    tag: "polygon";
+    points: Vec[];
+} | {
+    tag: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx: number;
+    ry: number;
+};
+export declare const GEO_BURST_PATH = "m19.8415 12.945 1.827 1.428h-2.26a1 1 0 0 0-.972 1.232l.676 2.828-2.462-2.204a1 1 0 0 0-1.66.624l-.386 3.152-1.548-2.838c-.417-.765-1.545-.668-1.825.158l-1.064 3.138-.215-2.358a1 1 0 0 0-1.535-.751l-1.482.95.437-1.803a1 1 0 0 0-1.099-1.228l-2.962.38 1.446-1.17a1 1 0 0 0 .036-1.525L2.1425 10.6l3.088-.791a1 1 0 0 0 .534-1.592l-2-2.513L7.7425 7.879a1 1 0 0 0 1.434-.578l.775-2.464 1.377 2.067a1 1 0 0 0 1.635.042l2.539-3.41-.115 2.574a1 1 0 0 0 1.16 1.031l2.59-.42-.804 1.34a1 1 0 0 0 .67 1.496l2.853.544-1.93 1.207a1 1 0 0 0-.085 1.636Z";
+export declare const GEO_TRAPEZOID_PATH = "M3.383 17.776A1.1 1.1 0 0 0 4.46 19.1h15.08a1.1 1.1 0 0 0 1.077-1.324l-2.5-12A1.1 1.1 0 0 0 17.04 4.9H6.96a1.1 1.1 0 0 0-1.077.876z";
+export declare const GEO_SUMMARY_PATH = "M16 15a3.2 3.2 0 0 0-1.618-2.783L14 12l.382-.217C15.382 11.213 16 10.15 16 9V7a4 4 0 0 1 4-4M16 15v2a4 4 0 0 0 4 4";
+export declare const GEO_SUMMARY_LEFT_PATH = "M7 15c0-1.151.618-2.214 1.618-2.783L9 12l-.382-.217A3.2 3.2 0 0 1 7 9V7a4 4 0 0 0-4-4M7 15v2a4 4 0 0 1-4 4";
+export declare const GEO_ARROW_LEFT_PATH = "M12.444 6.416v.9h8.265a.1.1 0 0 1 .1.1v8.455a.1.1 0 0 1-.1.1h-8.265v4.314c0 .034-.008.048-.014.056a.1.1 0 0 1-.047.036.1.1 0 0 1-.058.009c-.01-.002-.025-.005-.05-.029l-9.053-8.641a.1.1 0 0 1 0-.145l9.053-8.641c.025-.024.04-.028.05-.03a.1.1 0 0 1 .058.01.1.1 0 0 1 .047.036c.006.008.014.022.014.056z";
+export declare const GEO_ARROW_RIGHT_PATH = "M10.656 7.316h.9V3.002c0-.034.008-.048.014-.056a.1.1 0 0 1 .046-.036.1.1 0 0 1 .059-.01c.01.002.025.006.05.03l9.053 8.641a.1.1 0 0 1 0 .145l-9.053 8.641c-.025.024-.04.027-.05.029a.1.1 0 0 1-.059-.01.1.1 0 0 1-.046-.035c-.006-.008-.014-.022-.014-.056V15.97H3.29a.1.1 0 0 1-.1-.1V7.416a.1.1 0 0 1 .1-.1z";
+export declare function getGeoInteractionOutlinePoints(bounds: Box, kind: GeoShapeKind, options?: {
+    cornerRadiusPercent?: unknown;
+}): Vec[];
+export declare function getGeoEllipsePoints(bounds: Box, segments?: number): Vec[];
+export declare function normalizeGeoRectangleCornerRadiusPercent(value: unknown, fallback?: number): number;
+export declare function getGeoRectangleCornerRadius({ cornerRadiusPercent, h, w, }: {
+    cornerRadiusPercent?: unknown;
+    h: number;
+    w: number;
+}): number;
+export declare function getGeoRoundedRectanglePoints(bounds: Box, radius?: number, segments?: number): Vec[];
+export declare function getGeoMessageCirclePath(bounds: Box): string;
+export declare function getGeoSourcePathTransform(bounds: Box): string;
+export declare function getGeoBurstPathTransform(bounds: Box): string;
+export declare function getGeoSummaryPathTransform(bounds: Box, side: "left" | "right"): string;
+export declare function resolveGeoVisualGeometry(bounds: Box, kind: GeoShapeKind, options?: {
+    cornerRadiusPercent?: unknown;
+}): GeoVisualGeometry;
+export declare function getGeoHorizontalArrowGeometry(bounds: Box, direction: "left" | "right"): {
+    outline: Vec[];
+    path: string;
+};
+export declare function getGeoHorizontalArrowWidthForSelectionWidth({ direction, height, selectionWidth, }: {
+    direction: "left" | "right";
+    height: number;
+    selectionWidth: number;
+}): number;
+export declare function isPointInPolygon(point: Vec, points: readonly Vec[]): boolean;

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

@@ -0,0 +1,16 @@
+import { Box, ShapeUtil, Vec, type ShapeBindingPointInput, type ShapeHandleSnapGeometry, type ShapeLineSegmentHitTestInput, type ShapeSelectionResizeInput, type ShapeUpdate } from "./_vendor/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;
+    getLocalBounds(shape: GeoShapeRecord): Box;
+    canReceiveTerminalBinding(_shape: GeoShapeRecord): boolean;
+    getPositionedOutlineVertices(shape: GeoShapeRecord): Vec[];
+    getSelectionResizeLocalBounds(shape: GeoShapeRecord): Box;
+    resizeSelectionBounds(shape: GeoShapeRecord, input: ShapeSelectionResizeInput): ShapeUpdate;
+    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/geoStrokeStyle.d.ts

@@ -0,0 +1,2 @@
+import type { GeoStrokeStyle } from "./types";
+export declare function getGeoStrokeDasharray(strokeStyle: GeoStrokeStyle, strokeWidth: number): string | undefined;

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

@@ -0,0 +1,51 @@
+import { StateNode, type Editor } from "./_vendor/canvas-core/index";
+import type { GeoShapeKind, GeoShapeProps } from "./types";
+declare class BoxGeoTool extends StateNode {
+    private readonly kind;
+    constructor(editor: Editor, id: string, kind: GeoShapeKind);
+    getDefaultProps(): GeoShapeProps;
+    protected onEnter(): void;
+}
+export declare class RectangleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class EllipseTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class MessageCircleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class SummaryTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class SummaryLeftTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class BurstTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class RhombusTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class TriangleTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class PentagonTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class HexagonTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class StarTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class TrapezoidTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class ArrowLeftTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export declare class ArrowRightTool extends BoxGeoTool {
+    constructor(editor: Editor);
+}
+export {};

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

@@ -0,0 +1,9 @@
+export { ArrowLeftTool, ArrowRightTool, BurstTool, EllipseTool, HexagonTool, MessageCircleTool, PentagonTool, RectangleTool, RhombusTool, StarTool, SummaryLeftTool, SummaryTool, TrapezoidTool, TriangleTool, } from "./geoTools";
+export { geoApiToken } from "./api";
+export type { GeoApi, GeoCreateInput, GeoSelectionStyle, GeoStylePatch, } from "./api";
+export { GeoShapeUtil } from "./geoShapeUtil";
+export { GeoShapeSvgExporter, createGeoEditorPlugin } from "./editorRuntime";
+export { createGeoCanvasRenderPlugin } from "./canvasRender";
+export { Geo } from "./feature";
+export type { GeoShapeKind, GeoShapeProps, GeoShapeRecord, GeoStrokeStyle, } from "./types";
+export { GEO_SHAPE_KINDS, GEO_STROKE_STYLES, isGeoShapeKind, isGeoShapeRecord, isGeoStrokeStyle, } from "./types";