@yuzhouu/canvas-standard 0.1.0

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

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

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

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

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

@@ -0,0 +1,2 @@
+import type { CanvasPlugin } from "@yuzhouu/canvas-kit";
+export declare const Group: CanvasPlugin;

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

@@ -0,0 +1,35 @@
+import { Box, ShapeUtil, type Vec, type ShapeLineSegmentHitTestInput, type ShapeGroupingInput, type ShapeRecordBase } from "./_vendor/canvas-core/index";
+export interface GroupShapeProps {
+    /** Intrinsic width of the group's parent-local frame. */
+    readonly w: number;
+    /** Intrinsic height of the group's parent-local frame. */
+    readonly h: number;
+}
+export type GroupShapeRecord = ShapeRecordBase<"group", GroupShapeProps>;
+export declare class GroupShapeUtil extends ShapeUtil<GroupShapeRecord> {
+    readonly type: "group";
+    getGroupingShapeCreateInput({ parentId, parentLocalBounds, }: ShapeGroupingInput): {
+        type: "group";
+        x: number;
+        y: number;
+        parentId: import("./_vendor/canvas-core/index").ShapeParentId;
+        props: {
+            w: number;
+            h: number;
+        };
+    };
+    getDefaultProps(): GroupShapeProps;
+    validateProps(props: unknown): GroupShapeProps;
+    getLocalBounds(shape: GroupShapeRecord): Box;
+    hitTest(_shape: GroupShapeRecord, _positionedPoint: Vec): boolean;
+    hitTestLineSegment(_shape: GroupShapeRecord, _input: ShapeLineSegmentHitTestInput): boolean;
+    isSelectionTransformContainer(_shape: GroupShapeRecord): boolean;
+    canUngroupChildren(_shape: GroupShapeRecord): boolean;
+    shouldResizeDescendants(_shape: GroupShapeRecord): boolean;
+    getResizeToFitDescendantsProps(shape: GroupShapeRecord, descendantBounds: Box): GroupShapeProps;
+    getMinimumChildCount(_shape: GroupShapeRecord): number;
+    contributesToExportBounds(_shape: GroupShapeRecord): boolean;
+    canReceiveChildren(_shape: GroupShapeRecord): boolean;
+    canAutomaticallyReceiveChildren(_shape: GroupShapeRecord): boolean;
+    canBeDirectlyBrushSelected(_shape: GroupShapeRecord): boolean;
+}

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

@@ -0,0 +1,5 @@
+export { GroupShapeUtil } from "./groupShapeUtil";
+export type { GroupShapeProps, GroupShapeRecord } from "./groupShapeUtil";
+export { GroupShapeSvgExporter, createGroupEditorPlugin } from "./editorRuntime";
+export { createGroupCanvasRenderPlugin } from "./canvasRender";
+export { Group } from "./feature";

package/_vendor/plugin-html/_vendor/canvas-core/bindings/bindingManager.d.ts

@@ -0,0 +1,33 @@
+import type { ChangeSource } from "../../store/index";
+import { type BindingId, type BindingRecord, type ShapeId, type ShapeRecord } from "../schema/records";
+import type { Editor } from "../editor/editor";
+declare const SYNCHRONOUS_CALLBACK_ERROR = "Binding reaction scope callbacks must be synchronous";
+type SynchronousCallbackGuard<T> = T extends PromiseLike<unknown> ? [error: typeof SYNCHRONOUS_CALLBACK_ERROR] : [];
+export interface ShapeChangeEntry {
+    before: ShapeRecord;
+    after: ShapeRecord;
+}
+export declare class BindingManager {
+    private readonly editor;
+    private suppressedReactionIds;
+    constructor(editor: Editor);
+    getSuppressedReactionIds(): ReadonlySet<BindingId>;
+    runWithSuppressedReactions<T>(bindingIds: Iterable<BindingId>, callback: () => T, ..._synchronousCallbackGuard: SynchronousCallbackGuard<T>): T;
+    getConflictingBindings(binding: BindingRecord): BindingRecord[];
+    canBind(binding: BindingRecord): boolean;
+    syncCreatedBinding(binding: BindingRecord, source: ChangeSource): void;
+    syncUpdatedBinding(before: BindingRecord, after: BindingRecord, source: ChangeSource): void;
+    repairLoadedBindings(source: ChangeSource): void;
+    handleShapeChanges(changes: ShapeChangeEntry[], source: ChangeSource): void;
+    getShapeCompanionRootId(shapeId: ShapeId): ShapeId;
+    getShapeCompanionRootIds(shapeIds: readonly ShapeId[], bindings?: readonly BindingRecord[]): ReadonlyMap<ShapeId, ShapeId>;
+    getShapeCompanionMemberIds(shapeIds: readonly ShapeId[]): ShapeId[];
+    cleanupBindingsForDeletedShapes(ids: ShapeId[], source: ChangeSource): void;
+    cleanupBindings(ids: BindingId[], source: ChangeSource): void;
+    private applyEffect;
+    private syncShapeCompanionState;
+    private getShapeCompanionContext;
+    private getAllBindings;
+    private getExclusiveBindingKey;
+}
+export {};

package/_vendor/plugin-html/_vendor/canvas-core/bindings/bindingUtil.d.ts

@@ -0,0 +1,69 @@
+import type { Editor } from "../editor/editor";
+import type { SelectionOverlayFrameGeometryState } from "../editor/selection/selection";
+import type { Vec } from "../geometry/vec";
+import type { BindingId, BindingRecord, BindingRecordBase, ShapeRecord } from "../schema/records";
+export interface BindingUtilEffect {
+    shapes?: ShapeRecord[];
+    bindings?: BindingRecord[];
+    deleteShapeIds?: ShapeRecord["id"][];
+    deleteBindingIds?: BindingId[];
+    /** Suppress these bindings while applying this effect and its derived writes. */
+    suppressBindingIds?: BindingId[];
+}
+export interface BindingShapeChangeContext {
+    before: ShapeRecord;
+    after: ShapeRecord;
+    role: "from" | "to";
+    reason: "self" | "ancestry";
+}
+export interface BindingShapeDeleteContext {
+    shape: ShapeRecord;
+    role: "from" | "to";
+}
+export interface BindingEndpointContext {
+    fromShape: ShapeRecord;
+    toShape: ShapeRecord;
+}
+export interface BindingSelectionCompanionFrameContext {
+    selectedShape: ShapeRecord;
+}
+export interface BindingShapeGeometryDependencyContext {
+    shape: ShapeRecord;
+    role: "from" | "to";
+}
+export interface BindingTargetShapeContentCutoutContext {
+    fromShape: ShapeRecord;
+    toShape: ShapeRecord;
+}
+export declare abstract class BindingUtil<B extends BindingRecordBase = BindingRecordBase> {
+    abstract readonly type: B["type"];
+    abstract getDefaultProps(): B["props"];
+    abstract validateProps(props: unknown): B["props"];
+    canBind?(editor: Editor, binding: B, context: BindingEndpointContext): boolean;
+    getExclusiveBindingKey?(binding: B): string | null;
+    onBindingCreate?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onBindingUpdate?(editor: Editor, before: B, after: B): BindingUtilEffect | void;
+    onBindingLoad?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onInvalidBindingLoad?(editor: Editor, binding: B): BindingUtilEffect | void;
+    onAfterShapeChange?(editor: Editor, binding: B, context: BindingShapeChangeContext): BindingUtilEffect | void;
+    onBeforeDeleteShape?(editor: Editor, binding: B, context: BindingShapeDeleteContext): BindingUtilEffect | void;
+    onBeforeDeleteBinding?(editor: Editor, binding: B): BindingUtilEffect | void;
+    getExportShapeIds?(editor: Editor, binding: B): ShapeRecord["id"][];
+    /**
+     * Map a companion shape (for example, a bound label) to the owner shape that
+     * controls its grouping lifecycle and selection semantics.
+     */
+    getShapeCompanionRootId?(binding: B, shapeId: ShapeRecord["id"]): ShapeRecord["id"] | null;
+    canUseShapeCompanion?(binding: B, context: BindingEndpointContext): boolean;
+    getGeometryDependentShapeIds?(editor: Editor, binding: B, context: BindingShapeGeometryDependencyContext): ShapeRecord["id"][];
+    /**
+     * Return polygons in the target shape's local space that should be removed
+     * from its rendered content. This lets a binding-owned companion such as a
+     * text label create a transparent gap without coupling the target plugin to
+     * the companion shape implementation.
+     */
+    getTargetShapeContentCutoutLocalPolygons?(editor: Editor, binding: B, context: BindingTargetShapeContentCutoutContext): readonly (readonly Vec[])[];
+    getSelectionCompanionFrameGeometries?(editor: Editor, binding: B, context: BindingSelectionCompanionFrameContext): SelectionOverlayFrameGeometryState[];
+}
+export declare function resolveShapeCompanionRootId(shapeId: ShapeRecord["id"], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ShapeRecord["id"];
+export declare function resolveShapeCompanionRootIds(shapeIds: readonly ShapeRecord["id"][], bindings: readonly BindingRecord[], getBindingUtil: (binding: BindingRecord) => BindingUtil): ReadonlyMap<ShapeRecord["id"], ShapeRecord["id"]>;

package/_vendor/plugin-html/_vendor/canvas-core/bindings/bindingUtilRegistry.d.ts

@@ -0,0 +1,8 @@
+import type { BindingRecordBase } from "../schema/records";
+import { BindingUtil } from "./bindingUtil";
+export declare class BindingUtilRegistry {
+    private readonly registry;
+    register<B extends BindingRecordBase>(util: BindingUtil<B>): void;
+    values(): IterableIterator<BindingUtil>;
+    get<B extends BindingRecordBase>(type: B["type"]): BindingUtil<B>;
+}

package/_vendor/plugin-html/_vendor/canvas-core/bindings/terminalBinding.d.ts

@@ -0,0 +1,28 @@
+import { Vec } from "../geometry/vec";
+import type { Editor } from "../editor/editor";
+import type { BindingPreviewState } from "../editor/selection/selection";
+import type { ShapeId } from "../schema/records";
+export interface ConnectionPoint {
+    x: number;
+    y: number;
+}
+export type ConnectionTerminal = "start" | "end";
+export interface TerminalBindingTargetInput {
+    targetShapeId: ShapeId;
+    normalizedAnchor: ConnectionPoint;
+}
+export interface ResolvedTerminalBinding {
+    pagePoint: Vec;
+    binding: TerminalBindingTargetInput | null;
+    preview: BindingPreviewState | null;
+}
+export interface TerminalBindingResolverInput {
+    terminal: ConnectionTerminal;
+    rawPagePoint: Vec;
+    oppositePagePoint: Vec;
+    excludeShapeId?: ShapeId;
+    ignoreTargets?: boolean;
+}
+export type TerminalBindingResolver = (editor: Editor, input: TerminalBindingResolverInput) => ResolvedTerminalBinding;
+export declare function getFreeTerminalBinding({ rawPagePoint, }: TerminalBindingResolverInput): ResolvedTerminalBinding;
+export declare function resolveTerminalBindingAtPoint(editor: Editor, input: TerminalBindingResolverInput): ResolvedTerminalBinding;