@yuzhouu/canvas-standard 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# @yuzhouu/canvas-standard
+
+The exclusive standard Land canvas aggregation. It includes and reexports every first-party plugin except `@yuzhouu/plugin-packaging`, and returns matching plugin and minimal CanvasAction arrays for CanvasKit. Product React UI is owned by the consuming app.
+
+`createStandardCanvasKitProfile({ shortcutOverrides })` applies product-level
+shortcut overrides while composing the profile. Omitted entries keep the
+standard binding, a replacement chord (or chord array) overrides it, and
+`null` disables it. The resulting actions are passed to `CanvasKitRoot`; they
+are not part of the Runtime.
+
+```tsx
+import { CanvasKitRoot } from "@yuzhouu/canvas-kit";
+import { createStandardCanvasKitProfile } from "@yuzhouu/canvas-standard";
+
+const profile = createStandardCanvasKitProfile();
+
+function StandardCanvas() {
+  return (
+    <CanvasKitRoot
+      actions={profile.actions}
+      options={{ persistence: null, plugins: profile.plugins }}
+    />
+  );
+}
+```
+
+Connector is enabled by default and follows Geo; setting `geo: false` removes both Geo and Connector so the plugin graph remains valid. Packaging must always be composed separately.
+
+Connector and Flow port affordances can be configured independently:
+
+```ts
+createStandardCanvasKitProfile({
+  connector: { visiblePortIds: ["top", "right", "bottom", "left"] },
+  flow: { visiblePortIds: ["left", "right"] },
+});
+```
+
+The HTML plugin is enabled by default. Pass `html: false` to omit sandboxed
+HTML embeds from a profile.

package/_vendor/plugin-arrow/_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-arrow/_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-arrow/_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-arrow/_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;

package/_vendor/plugin-arrow/_vendor/canvas-core/bindings/terminalPorts.d.ts

@@ -0,0 +1,67 @@
+import type { Editor } from "../editor/editor";
+import { Vec } from "../geometry/vec";
+import type { ShapeRecord } from "../schema/records";
+export type TerminalBindingPortId = "top" | "right" | "bottom" | "left" | (string & {});
+export interface ShapeTerminalBindingPort {
+    id: TerminalBindingPortId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    outwardNormal: {
+        x: number;
+        y: number;
+    };
+}
+export interface ResolvedShapeTerminalBindingPort {
+    id: TerminalBindingPortId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+    pagePoint: Vec;
+    pageOutwardNormal: Vec;
+}
+export declare const DEFAULT_TERMINAL_BINDING_PORTS: readonly [{
+    readonly id: "top";
+    readonly normalizedAnchor: {
+        readonly x: 0.5;
+        readonly y: 0;
+    };
+    readonly outwardNormal: {
+        readonly x: 0;
+        readonly y: -1;
+    };
+}, {
+    readonly id: "right";
+    readonly normalizedAnchor: {
+        readonly x: 1;
+        readonly y: 0.5;
+    };
+    readonly outwardNormal: {
+        readonly x: 1;
+        readonly y: 0;
+    };
+}, {
+    readonly id: "bottom";
+    readonly normalizedAnchor: {
+        readonly x: 0.5;
+        readonly y: 1;
+    };
+    readonly outwardNormal: {
+        readonly x: 0;
+        readonly y: 1;
+    };
+}, {
+    readonly id: "left";
+    readonly normalizedAnchor: {
+        readonly x: 0;
+        readonly y: 0.5;
+    };
+    readonly outwardNormal: {
+        readonly x: -1;
+        readonly y: 0;
+    };
+}];
+export declare function getResolvedShapeTerminalBindingPorts(editor: Editor, shape: ShapeRecord): ResolvedShapeTerminalBindingPort[];
+export declare function getResolvedShapeTerminalBindingPort(editor: Editor, shape: ShapeRecord, portId: TerminalBindingPortId): ResolvedShapeTerminalBindingPort | null;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/clipboard.d.ts

@@ -0,0 +1,43 @@
+import type { ChangeSource } from "../../store/index";
+import { Vec } from "../geometry/vec";
+import type { AssetId, AssetRecord, BindingRecord, ShapeId, ShapeRecord } from "../schema/records";
+import type { Editor } from "./editor";
+export interface EditorClipboardPayload {
+    type: "land/clipboard";
+    version: 2;
+    source: {
+        app: "land";
+        documentId?: string;
+    };
+    rootShapeIds: readonly ShapeId[];
+    records: {
+        shapes: readonly ShapeRecord[];
+        bindings: readonly BindingRecord[];
+        assets: readonly AssetRecord[];
+    };
+    bounds: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface ClipboardAssetSidecar {
+    assetId: AssetId;
+    kind: "local-image-blob";
+    storageKey: string;
+}
+export interface PasteClipboardPayloadInput {
+    payload: EditorClipboardPayload;
+    pagePoint?: Vec;
+    offset?: Vec;
+    source?: ChangeSource;
+}
+export interface DuplicateSelectionInput {
+    offset?: Vec;
+    source?: ChangeSource;
+}
+export declare function isEditorClipboardPayload(value: unknown): value is EditorClipboardPayload;
+export declare function createEditorClipboardPayloadFromSelection(editor: Editor): EditorClipboardPayload | null;
+export declare function pasteEditorClipboardPayload(editor: Editor, input: PasteClipboardPayloadInput): ShapeId[];
+export declare function duplicateEditorSelection(editor: Editor, input?: DuplicateSelectionInput): ShapeId[];

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/clipboardAssets.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "./editor";
+import type { AssetId, AssetRecord, ShapeRecord } from "../schema/records";
+export declare function getClipboardAssets(editor: Editor, shapes: readonly ShapeRecord[]): AssetRecord[];
+export declare function remapAssetIdsInRecord(record: object, assetIdMap: ReadonlyMap<AssetId, AssetId>): Record<string, unknown>;
+export declare function cloneRecordObject(value: object): Record<string, unknown>;
+export declare function cloneSerializableRecord<T>(value: T): T;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/assetCommands.d.ts

@@ -0,0 +1,7 @@
+import type { AssetId, AssetRecord } from "../../schema/records";
+import type { CreateAssetInput, EditorCommandOptions, UpdateAssetInput } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function createAsset(editor: Editor, input: CreateAssetInput, options?: EditorCommandOptions): AssetRecord;
+export declare function createAssetsFromRecords(editor: Editor, records: AssetRecord[], options?: EditorCommandOptions): AssetRecord[];
+export declare function updateAsset(editor: Editor, input: UpdateAssetInput, options?: EditorCommandOptions): AssetRecord | null;
+export declare function deleteAsset(editor: Editor, id: AssetId, options?: EditorCommandOptions): boolean;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/bindingCommands.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeSource } from "../../../store/index";
+import type { BindingId, BindingRecord, ShapeId } from "../../schema/records";
+import type { CreateBindingInput, EditorCommandOptions, UpdateBindingInput } from "./commandTypes";
+import type { Editor } from "../editor";
+type RepairMinimumChildContainers = (containerIds: Iterable<ShapeId>, deletedIds: Set<ShapeId>, source: ChangeSource) => void;
+interface BindingCommandSet {
+    createBinding(input: CreateBindingInput, options?: EditorCommandOptions): BindingRecord;
+    updateBinding(input: UpdateBindingInput, options?: EditorCommandOptions): BindingRecord | null;
+    deleteBinding(id: BindingId, options?: EditorCommandOptions): boolean;
+}
+export declare function createBindingCommandSet(editor: Editor, repairMinimumChildContainers: RepairMinimumChildContainers): BindingCommandSet;
+export {};

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/commandTypes.d.ts

@@ -0,0 +1,149 @@
+import type { ChangeSource } from "../../../store/index";
+import type { AssetId, AssetRecord, AssetRecordBase, BindingId, BindingRecord, BindingRecordBase, Camera, DocumentMetadataRecord, PageId, PageRecord, ShapeEditingEntryMode, ShapeId, ShapeParentId, ShapeRecord, ShapeRecordBase } from "../../schema/records";
+export interface EditorCommandOptions {
+    source?: ChangeSource;
+}
+export type ShapePropsPatch = Record<string, unknown>;
+export interface CreateShapesOptions extends EditorCommandOptions {
+    /** Defer spatial containment until an interactive creation gesture completes. */
+    autoReparent?: boolean;
+    /** Internal: allow a container to receive children later in the same atomic command. */
+    deferMinimumChildRepair?: boolean;
+}
+export interface UpdateShapesOptions extends EditorCommandOptions {
+    /** Suppress these bindings while applying this update and its derived writes. */
+    suppressBindingIds?: ReadonlySet<BindingId>;
+}
+export interface CreateShapeInput {
+    type: ShapeRecordBase["type"];
+    x: number;
+    y: number;
+    props?: Record<string, unknown>;
+    parentId?: ShapeParentId;
+    index?: string;
+    opacity?: number;
+    isHidden?: boolean;
+    rotation?: number;
+    scaleX?: number;
+    scaleY?: number;
+    isLocked?: boolean;
+    meta?: Record<string, unknown>;
+}
+export interface CreateAssetInput {
+    id?: AssetId;
+    type: AssetRecordBase["type"];
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface UpdateAssetInput {
+    id: AssetId;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface ShapeUpdate {
+    id: ShapeId;
+    x?: number;
+    y?: number;
+    rotation?: number;
+    scaleX?: number;
+    scaleY?: number;
+    opacity?: number;
+    isHidden?: boolean;
+    isLocked?: boolean;
+    parentId?: ShapeParentId;
+    index?: string;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface ReparentShapesInput {
+    ids: ShapeId[];
+    parentId: ShapeParentId;
+}
+export interface StartEditingShapeInput {
+    shapeId: ShapeId;
+    entryMode?: ShapeEditingEntryMode;
+    caretPagePoint?: {
+        x: number;
+        y: number;
+    };
+    operationKind?: string;
+    reuseActiveOperation?: boolean;
+    preserveInteraction?: boolean;
+}
+export interface CreateBindingInput {
+    id?: BindingId;
+    type: BindingRecordBase["type"];
+    fromId: ShapeId;
+    toId: ShapeId;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface UpdateBindingInput {
+    id: BindingId;
+    fromId?: ShapeId;
+    toId?: ShapeId;
+    props?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+export interface CreatePageInput {
+    name?: string;
+    index?: string;
+    meta?: Record<string, unknown>;
+}
+export interface RenamePageInput {
+    id: PageId;
+    name: string;
+}
+export interface UpdateDocumentMetaInput {
+    patch: Record<string, unknown>;
+}
+export interface UpdatePageMetaInput {
+    id: PageId;
+    patch: Record<string, unknown>;
+}
+export interface MovePageInput {
+    id: PageId;
+    toIndex: number;
+}
+export interface SetCameraInput {
+    pageId?: PageId;
+    camera: Partial<Camera>;
+}
+export interface EditorCommands {
+    createPage(input?: CreatePageInput, options?: EditorCommandOptions): PageRecord;
+    deletePage(id: PageId, options?: EditorCommandOptions): boolean;
+    renamePage(input: RenamePageInput, options?: EditorCommandOptions): void;
+    updateDocumentMeta(input: UpdateDocumentMetaInput, options?: EditorCommandOptions): DocumentMetadataRecord;
+    updatePageMeta(input: UpdatePageMetaInput, options?: EditorCommandOptions): PageRecord | null;
+    movePage(input: MovePageInput, options?: EditorCommandOptions): void;
+    createShapes(inputs: CreateShapeInput[], options?: CreateShapesOptions): ShapeRecord[];
+    /**
+     * Persist already-built shape records (with their existing ids) through the
+     * command pipeline. Used by paste/duplicate where ids must be assigned before
+     * parent/binding remapping. Prefer `createShapes` for fresh shapes.
+     */
+    createShapesFromRecords(records: ShapeRecord[], options?: EditorCommandOptions): ShapeRecord[];
+    updateShapes(updates: ShapeUpdate[], options?: UpdateShapesOptions): void;
+    /**
+     * Move shapes to a new parent, appending shapes that are entering that parent
+     * to the end of its child order in the order provided by `ids`.
+     */
+    reparentShapes(input: ReparentShapesInput, options?: EditorCommandOptions): boolean;
+    deleteShapes(ids: ShapeId[], options?: EditorCommandOptions): void;
+    createAsset(input: CreateAssetInput, options?: EditorCommandOptions): AssetRecord;
+    /**
+     * Persist already-built asset records (with their existing ids) through the
+     * command pipeline. Used by paste/duplicate. Prefer `createAsset` otherwise.
+     */
+    createAssetsFromRecords(records: AssetRecord[], options?: EditorCommandOptions): AssetRecord[];
+    updateAsset(input: UpdateAssetInput, options?: EditorCommandOptions): AssetRecord | null;
+    deleteAsset(id: AssetId, options?: EditorCommandOptions): boolean;
+    createBinding(input: CreateBindingInput, options?: EditorCommandOptions): BindingRecord;
+    updateBinding(input: UpdateBindingInput, options?: EditorCommandOptions): BindingRecord | null;
+    deleteBinding(id: BindingId, options?: EditorCommandOptions): boolean;
+    setCurrentPageId(id: PageId, options?: EditorCommandOptions): void;
+    setCamera(input: SetCameraInput, options?: EditorCommandOptions): void;
+    setSelectedShapeIds(ids: ShapeId[], options?: EditorCommandOptions): void;
+    setActiveTool(toolId: string, options?: EditorCommandOptions): void;
+    setToolLocked(locked: boolean, options?: EditorCommandOptions): void;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/commands.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from "../editor";
+import type { EditorCommands } from "./commandTypes";
+export declare function createEditorCommands(editor: Editor): EditorCommands;
+export { reparentShapeToContainingParent } from "./shapeCommands";
+export type * from "./commandTypes";

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/documentCommands.d.ts

@@ -0,0 +1,9 @@
+import type { DocumentMetadataRecord, PageId, PageRecord } from "../../schema/records";
+import type { CreatePageInput, EditorCommandOptions, MovePageInput, RenamePageInput, UpdateDocumentMetaInput, UpdatePageMetaInput } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function createPage(editor: Editor, input?: CreatePageInput, options?: EditorCommandOptions): PageRecord;
+export declare function deletePage(editor: Editor, id: PageId, options?: EditorCommandOptions): boolean;
+export declare function renamePage(editor: Editor, input: RenamePageInput, options?: EditorCommandOptions): void;
+export declare function updateDocumentMeta(editor: Editor, input: UpdateDocumentMetaInput, options?: EditorCommandOptions): DocumentMetadataRecord;
+export declare function updatePageMeta(editor: Editor, input: UpdatePageMetaInput, options?: EditorCommandOptions): PageRecord | null;
+export declare function movePage(editor: Editor, input: MovePageInput, options?: EditorCommandOptions): void;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/sessionCommands.d.ts

@@ -0,0 +1,13 @@
+import type { ChangeSource } from "../../../store/index";
+import { type PageId, type SessionRecord, type ShapeId } from "../../schema/records";
+import type { EditorCommandOptions, SetCameraInput } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function updateSession(editor: Editor, partial: Partial<SessionRecord>, source?: ChangeSource): void;
+export declare function setCurrentPageId(editor: Editor, id: PageId, options?: EditorCommandOptions): void;
+export declare function setCamera(editor: Editor, input: SetCameraInput, options?: EditorCommandOptions): void;
+export declare function setSelectedShapeIds(editor: Editor, ids: ShapeId[], options?: EditorCommandOptions): void;
+export declare function setActiveTool(editor: Editor, toolId: string, options?: EditorCommandOptions): void;
+export declare function setToolLocked(editor: Editor, locked: boolean, options?: EditorCommandOptions): void;
+export declare function ensurePageState(editor: Editor, pageId: PageId, source?: ChangeSource): void;
+export declare function removePageState(editor: Editor, pageId: PageId, nextCurrentPageId: PageId, source?: ChangeSource): void;
+export declare function syncToolStateFromSession(editor: Editor, source: ChangeSource): void;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/shapeCommands.d.ts

@@ -0,0 +1,9 @@
+import { type ShapeId, type ShapeRecord } from "../../schema/records";
+import type { CreateShapeInput, CreateShapesOptions, EditorCommandOptions, ReparentShapesInput, ShapeUpdate, UpdateShapesOptions } from "./commandTypes";
+import type { Editor } from "../editor";
+export declare function createShapes(editor: Editor, inputs: CreateShapeInput[], options?: CreateShapesOptions): ShapeRecord[];
+export declare function createShapesFromRecords(editor: Editor, records: ShapeRecord[], options?: EditorCommandOptions): ShapeRecord[];
+export declare function reparentShapeToContainingParent(editor: Editor, shapeId: ShapeId, options?: EditorCommandOptions): void;
+export declare function updateShapes(editor: Editor, updates: ShapeUpdate[], options?: UpdateShapesOptions): void;
+export declare function reparentShapes(editor: Editor, input: ReparentShapesInput, options?: EditorCommandOptions): boolean;
+export declare function deleteShapes(editor: Editor, ids: ShapeId[], options?: EditorCommandOptions): void;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/shapeFlags.d.ts

@@ -0,0 +1,10 @@
+import type { ChangeSource } from "../../../store/index";
+import type { ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+type ShapeBooleanFlag = "isHidden" | "isLocked";
+export declare function setShapeBooleanFlag(editor: Editor, ids: readonly ShapeId[], input: {
+    flag: ShapeBooleanFlag;
+    value: boolean;
+    source: ChangeSource;
+}): ShapeId[];
+export {};

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/shapeRemoval.d.ts

@@ -0,0 +1,10 @@
+import type { ChangeSource } from "../../../store/index";
+import { type AssetId, type ShapeId } from "../../schema/records";
+import type { Editor } from "../editor";
+interface RemoveShapeRecordsOptions {
+    source: ChangeSource;
+    afterRemove?: (removedIds: readonly ShapeId[]) => void;
+}
+export declare function getUnreferencedAssetIdsAfterShapeDelete(editor: Editor, shapeIds: readonly ShapeId[]): AssetId[];
+export declare function removeShapeRecords(editor: Editor, ids: readonly ShapeId[], options: RemoveShapeRecordsOptions): ShapeId[];
+export {};

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/commands/shapeRepair.d.ts

@@ -0,0 +1,11 @@
+import type { ChangeSource } from "../../../store/index";
+import { type ShapeId, type ShapeParentId, type ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+export declare function syncTransformDescendantAncestorBounds(editor: Editor, changes: Array<{
+    before: ShapeRecord;
+    after: ShapeRecord;
+}>, source: ChangeSource): void;
+export declare function syncTransformDescendantAncestorBoundsByIds(editor: Editor, ancestorIds: Iterable<ShapeId>, source: ChangeSource, excludedIds?: ReadonlySet<ShapeId>): void;
+export declare function getCurrentChildShapes(editor: Editor, parentId: ShapeParentId): ShapeRecord[];
+export declare function collectTransformDescendantAncestorIdsForShapes(editor: Editor, ids: readonly ShapeId[]): Set<ShapeId>;
+export declare function repairMinimumChildContainers(editor: Editor, ancestorIds: Iterable<ShapeId>, deletedIds: Set<ShapeId>, source: ChangeSource): ShapeId[];

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/createEditor.d.ts

@@ -0,0 +1,6 @@
+import { type EditorPlugin } from "../plugins/editorRuntimePlugin";
+import { Editor, type EditorOptions } from "./editor";
+export interface CreateEditorOptions extends Omit<EditorOptions, "shapeUtils" | "shapeSvgExporters" | "bindingUtils"> {
+    plugins?: readonly EditorPlugin[];
+}
+export declare function createEditor(options?: CreateEditorOptions): Editor;