@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/signals/types.d.ts

@@ -0,0 +1,15 @@
+/** A reactive signal that holds subscribers */
+export interface Signal<T> {
+    readonly name: string;
+    get(): T;
+    __unsafe__getWithoutCapture(): T;
+    lastChangedEpoch: number;
+    children: Set<Child>;
+}
+export interface Child {
+    type: "computed" | "effect";
+    notify(): void;
+    source?: Signal<any>;
+}
+export declare const RESET_VALUE: unique symbol;
+export type RESET_VALUE = typeof RESET_VALUE;

package/_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 hasRecordsDiff<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/store/history.d.ts

@@ -0,0 +1,37 @@
+import { type Signal } from "../signals/index";
+import type { RecordsDiff, StoreRecord } from "./types";
+export interface StoreHistoryMark<TRecord extends StoreRecord = StoreRecord> {
+    id: string;
+    forward: RecordsDiff<TRecord>;
+    parentIds: readonly string[];
+}
+export interface StoreHistoryEntry<TRecord extends StoreRecord = StoreRecord> {
+    forward: RecordsDiff<TRecord>;
+    inverse: RecordsDiff<TRecord>;
+    label: string;
+}
+export interface StoreHistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+    undoDepth: number;
+    redoDepth: number;
+}
+export declare function createStoreHistoryMark<TRecord extends StoreRecord>(id: string, parentIds?: readonly string[]): StoreHistoryMark<TRecord>;
+export declare function appendStoreHistoryMark<TRecord extends StoreRecord, TNextRecord extends TRecord>(mark: StoreHistoryMark<TRecord>, diff: RecordsDiff<TNextRecord>): StoreHistoryMark<TRecord | TNextRecord>;
+export declare function createStoreHistoryEntry<TRecord extends StoreRecord>(label: string, forward: RecordsDiff<TRecord>): StoreHistoryEntry<TRecord>;
+export declare class StoreHistoryBuffer<TRecord extends StoreRecord = StoreRecord> {
+    private readonly marks;
+    private readonly undoStack;
+    private readonly redoStack;
+    private readonly _state;
+    readonly state: Signal<StoreHistoryState>;
+    clear(): void;
+    mark(id: string): void;
+    append(diff: RecordsDiff<TRecord>): void;
+    bailToMark(id: string): RecordsDiff<TRecord> | null;
+    squashToMark(id: string, label?: string): StoreHistoryEntry<TRecord> | null;
+    undo(): StoreHistoryEntry<TRecord> | null;
+    redo(): StoreHistoryEntry<TRecord> | null;
+    getEntries(): readonly StoreHistoryEntry<TRecord>[];
+    private publishState;
+}

package/_vendor/store/index.d.ts

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

package/_vendor/store/store.d.ts

@@ -0,0 +1,32 @@
+import { type Atom, type Signal } from "../signals/index";
+import type { ChangeSource, RecordsDiff, ScopedStoreRecord, StoreChange, StoreRecord, StoreScopeOf } from "./types";
+type StoreListener<TRecord extends StoreRecord> = (change: StoreChange<TRecord>) => void;
+type ScopedRecord<TRecord extends StoreRecord> = Extract<TRecord, ScopedStoreRecord>;
+export declare class Store<TRecord extends StoreRecord = StoreRecord> {
+    readonly recordsSignal: Atom<Map<string, TRecord>>;
+    private readonly recordSignals;
+    private readonly listeners;
+    private transactionDepth;
+    private draftRecords;
+    private pendingSource;
+    constructor(initialRecords: TRecord[]);
+    get(id: string): TRecord | undefined;
+    /**
+     * Per-record reactive read that still respects draft records during atomic
+     * mutations. Use this inside computed values instead of wrapping `get(id)`.
+     */
+    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;
+    replaceAll(records: TRecord[], source?: ChangeSource): void;
+    applyDiff<TChangeRecord extends TRecord>(diff: RecordsDiff<TChangeRecord>, source?: ChangeSource): void;
+    private getMutableRecords;
+    private getReadableRecords;
+}
+export {};

package/_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/browser/localSnapshotRestore.d.ts

@@ -0,0 +1,13 @@
+import { type Editor, type StoreSnapshot } from "../_vendor/canvas-core/index";
+import type { ProductPersistenceRestoreResult } from "../core/runtime/productDefinition";
+export interface PersistedEditorSnapshots {
+    documentSnapshot: unknown | null;
+    sessionSnapshot: unknown | null;
+}
+export interface LocalSnapshotRestoreResult extends ProductPersistenceRestoreResult {
+    preservedUnsupportedRecords: readonly unknown[];
+}
+export declare function restorePersistedEditorSnapshots(editor: Editor, { documentSnapshot, sessionSnapshot }: PersistedEditorSnapshots): LocalSnapshotRestoreResult;
+export declare function getDocumentSnapshotWithPreservedRecords(editor: Editor, preservedRecords: readonly unknown[]): StoreSnapshot<{
+    id: string;
+}>;

package/browser/persistence.d.ts

@@ -0,0 +1,46 @@
+import type { Editor, StoreSnapshot } from "../_vendor/canvas-core/index";
+import type { ProductPersistenceAdapter } from "../core/runtime/productDefinition";
+import { type PersistedEditorSnapshots } from "./localSnapshotRestore";
+export declare const LAND_DOCUMENT_INDEXEDDB_NAME = "land.canvas.persistence";
+export declare const LAND_DOCUMENT_INDEXEDDB_STORE = "snapshots";
+export declare const LAND_IMAGE_BLOB_INDEXEDDB_STORE = "imageBlobs";
+export declare const LAND_DOCUMENT_STORAGE_KEY = "land.canvas.document";
+export declare const LAND_SESSION_STORAGE_KEY = "land.canvas.session";
+export declare const LAND_DOCUMENT_INDEXEDDB_VERSION = 2;
+export interface LocalSnapshotPersistenceOptions {
+    storageNamespace?: string;
+}
+export declare function createLocalSnapshotPersistence(options?: LocalSnapshotPersistenceOptions): ProductPersistenceAdapter;
+export declare class PersistenceManager {
+    private readonly editor;
+    private static readonly SAVE_DELAY_MS;
+    private readonly getDocumentSnapshot;
+    private readonly options;
+    private unsubscribe;
+    private saveTimeoutId;
+    private hasPendingSave;
+    private isSaving;
+    private saveAgainAfterCurrentSave;
+    constructor(editor: Editor, { getDocumentSnapshot, options, }?: {
+        getDocumentSnapshot?: () => StoreSnapshot<{
+            id: string;
+        }>;
+        options?: LocalSnapshotPersistenceOptions;
+    });
+    start(): void;
+    stop(): void;
+    flush(): void;
+    private save;
+    private scheduleSave;
+    private cancelScheduledSave;
+    private readonly flushWhenHidden;
+    private readonly flushWhenPageIsLeaving;
+}
+export declare function persistEditorSnapshot(editor: Editor, options?: LocalSnapshotPersistenceOptions, { documentSnapshot, }?: {
+    documentSnapshot?: StoreSnapshot<{
+        id: string;
+    }>;
+}): Promise<void>;
+export declare function readPersistedEditorSnapshots(options?: LocalSnapshotPersistenceOptions): Promise<PersistedEditorSnapshots>;
+export declare function readPersistedDocumentSnapshot(): Promise<unknown | null>;
+export declare function readPersistedSessionSnapshot(): Promise<unknown | null>;

package/builtins/controller/createBuiltInCanvasController.d.ts

@@ -0,0 +1,16 @@
+import type { ShapeId } from "../../_vendor/canvas-core/index";
+import type { CanvasProductController, CanvasProductControllerSnapshot, CanvasProductControllerOptions, CanvasProductSessionSnapshot } from "../../core/controller";
+import { type BuiltInCanvasShapeCreationControllers } from "./shapeCreationController";
+import { type BuiltInCanvasLayerNode } from "./layerController";
+export interface BuiltInCanvasControllerSnapshot<TToolId extends string = string> extends CanvasProductControllerSnapshot<TToolId> {
+    productId: string;
+    session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface BuiltInCanvasController<TToolId extends string = string> extends CanvasProductController<TToolId>, BuiltInCanvasShapeCreationControllers {
+    snapshot(): BuiltInCanvasControllerSnapshot<TToolId>;
+    getLayerTree(pageId?: string): BuiltInCanvasLayerNode[];
+    getLayerNode(id: ShapeId): BuiltInCanvasLayerNode | null;
+}
+export declare function createBuiltInCanvasController<TToolId extends string = string>(options: CanvasProductControllerOptions<TToolId>): BuiltInCanvasController<TToolId>;
+export declare function useBuiltInCanvasController<TToolId extends string = string>(options: CanvasProductControllerOptions<TToolId>): BuiltInCanvasController<TToolId>;
+export type { BuiltInCanvasLayerNode } from "./layerController";

package/builtins/controller/layerController.d.ts

@@ -0,0 +1,9 @@
+import type { AssetId, Editor } from "../../_vendor/canvas-core/index";
+import type { GeoShapeKind } from "../../_vendor/plugin-geo/index";
+import type { CanvasProductLayerNode } from "../../core/controller";
+export interface BuiltInCanvasLayerNode extends CanvasProductLayerNode {
+    geoKind?: GeoShapeKind;
+    imageAssetId?: AssetId | null;
+    imageThumbnailSrc?: string | null;
+}
+export declare function withBuiltInLayerNames(editor: Editor, node: CanvasProductLayerNode): BuiltInCanvasLayerNode;

package/builtins/controller/shapeCreationController.d.ts

@@ -0,0 +1,74 @@
+import type { Editor, ShapeColor, ShapeId } from "../../_vendor/canvas-core/index";
+import { type ArrowShapeProps } from "../../_vendor/plugin-arrow/index";
+import { type TextShapeProps } from "../../_vendor/plugin-text/index";
+import type { CanvasProductShapeRef } from "../../core/controller";
+export interface BuiltInCanvasShapeInput {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+}
+export interface BuiltInCanvasTextInput {
+    x: number;
+    y: number;
+    text: string;
+    w?: number;
+    h?: number;
+    color?: ShapeColor;
+    size?: TextShapeProps["size"];
+}
+export interface BuiltInCanvasFrameInput extends BuiltInCanvasShapeInput {
+    name?: string;
+}
+export interface BuiltInCanvasArrowBindingInput {
+    targetShapeId: ShapeId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+}
+export interface BuiltInCanvasArrowInput {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    bend?: number;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+    headStart?: ArrowShapeProps["headStart"];
+    headEnd?: ArrowShapeProps["headEnd"];
+    startBinding?: BuiltInCanvasArrowBindingInput | null;
+    endBinding?: BuiltInCanvasArrowBindingInput | null;
+}
+export interface BuiltInGeoController {
+    createRectangle(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createEllipse(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createDiamond(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createTriangle(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createHexagon(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createStar(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+}
+export interface BuiltInTextController {
+    create(input: BuiltInCanvasTextInput): CanvasProductShapeRef | null;
+}
+export interface BuiltInFrameController {
+    create(input: BuiltInCanvasFrameInput): CanvasProductShapeRef | null;
+    moveShapesToFrame(ids: ShapeId[], frameId: ShapeId): ShapeId[];
+}
+export interface BuiltInArrowController {
+    create(input: BuiltInCanvasArrowInput): CanvasProductShapeRef | null;
+}
+export interface BuiltInCanvasShapeCreationControllers {
+    arrow: BuiltInArrowController;
+    geo: BuiltInGeoController;
+    text: BuiltInTextController;
+    frame: BuiltInFrameController;
+}
+export declare function createBuiltInShapeCreationControllers(editor: Editor): BuiltInCanvasShapeCreationControllers;

package/builtins/extensions.d.ts

@@ -0,0 +1,15 @@
+export interface BuiltInCanvasExtensionOptions {
+    arrow?: boolean;
+    draw?: boolean;
+    eraser?: boolean;
+    frame?: boolean;
+    geo?: boolean;
+    group?: boolean;
+    image?: boolean;
+    laser?: boolean;
+    text?: boolean;
+}
+export declare const builtInCanvasExtensions: readonly [import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>];
+export type BuiltInCanvasExtension = (typeof builtInCanvasExtensions)[number];
+export declare function createBuiltInCanvasExtensions(options?: BuiltInCanvasExtensionOptions): readonly BuiltInCanvasExtension[];
+export declare function hasBuiltInCanvasExtension(extensions: readonly BuiltInCanvasExtension[], name: keyof BuiltInCanvasExtensionOptions): boolean;

package/builtins/index.d.ts

@@ -0,0 +1,5 @@
+export { builtInCanvasExtensions, createBuiltInCanvasExtensions, hasBuiltInCanvasExtension, } from "./extensions";
+export type { BuiltInCanvasExtension, BuiltInCanvasExtensionOptions, } from "./extensions";
+export { createBuiltInCanvasController, useBuiltInCanvasController, } from "./controller/createBuiltInCanvasController";
+export type { BuiltInCanvasController, BuiltInCanvasControllerSnapshot, BuiltInCanvasLayerNode, } from "./controller/createBuiltInCanvasController";
+export type { BuiltInArrowController, BuiltInCanvasArrowBindingInput, BuiltInCanvasArrowInput, BuiltInCanvasFrameInput, BuiltInCanvasShapeCreationControllers, BuiltInCanvasShapeInput, BuiltInCanvasTextInput, BuiltInFrameController, BuiltInGeoController, BuiltInTextController, } from "./controller/shapeCreationController";

package/chrome/CanvasKitFloatingToolbarLayer.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export declare function CanvasKitFloatingToolbarLayer({ children, className, dataUi, }: {
+    children: ReactNode;
+    className?: string;
+    dataUi?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/chrome/FloatingSelectionToolbarPageSpace.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { ToolbarSurfaces } from "./bindings/useToolbarSurfaces";
+export declare function FloatingSelectionToolbarPageSpace({ children, className, dataUi, offset, surfaces, }: {
+    children: ReactNode;
+    className?: string;
+    dataUi?: string;
+    offset?: number;
+    surfaces: ToolbarSurfaces;
+}): import("react/jsx-runtime").JSX.Element | null;

package/chrome/bindings/useCanvasKitChromeControls.d.ts

@@ -0,0 +1,27 @@
+import type { Editor, PageId, PageRecord } from "../../_vendor/canvas-core/index";
+export interface HistoryControls {
+    canUndo: boolean;
+    canRedo: boolean;
+    undo(): void;
+    redo(): void;
+}
+export interface PageControls {
+    pages: readonly PageRecord[];
+    currentPage: PageRecord | null;
+    currentPageId: PageId;
+    canDeleteCurrentPage: boolean;
+    createPage(): void;
+    deleteCurrentPage(): void;
+    renameCurrentPage(nextName: string): void;
+    selectPage(pageId: PageId): void;
+}
+export interface ZoomControlsState {
+    zoom: number;
+    label: string;
+    zoomIn(): void;
+    zoomOut(): void;
+    resetZoom(): void;
+}
+export declare function useHistoryControls(editor: Editor): HistoryControls;
+export declare function usePageControls(editor: Editor): PageControls;
+export declare function useZoomControls(editor: Editor): ZoomControlsState;

package/chrome/bindings/useContextMenuSurface.d.ts

@@ -0,0 +1,12 @@
+import type { ContextMenuContext, ActiveContextMenu, ContextMenuSection, Editor } from "../../_vendor/canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../_vendor/canvas-react/host/index";
+export interface ContextMenuSurface {
+    context: ContextMenuContext | null;
+    activeContextMenu: ActiveContextMenu | null;
+    sections: readonly ContextMenuSection[];
+}
+export declare function useContextMenuSurface({ editor, activeContextMenu, pluginHostRuntime, }: {
+    editor: Editor;
+    activeContextMenu: ActiveContextMenu | null;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): ContextMenuSurface;

package/chrome/bindings/useSvgExport.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from "react";
+import type { Editor, ShapeId } from "../../_vendor/canvas-core/index";
+import { type ExportStatus as ProductExportStatus, type SvgAssetInliner as ProductSvgAssetInliner, type SvgExportResult as ProductSvgExportResult } from "../../core";
+export type ExportStatus = ProductExportStatus;
+export type SvgAssetInliner = ProductSvgAssetInliner;
+export type SvgExportResult = ProductSvgExportResult;
+export interface SvgExportControls {
+    status: ExportStatus | null;
+    exportSvg(shapeIds: readonly ShapeId[]): Promise<SvgExportResult>;
+}
+export declare function useSvgExport({ assetInliners, editor, themeRootRef, }: {
+    assetInliners?: readonly SvgAssetInliner[];
+    editor: Editor;
+    themeRootRef?: RefObject<HTMLElement | null>;
+}): SvgExportControls;

package/chrome/bindings/useToolbarSurfaces.d.ts

@@ -0,0 +1,26 @@
+import type { Editor, CanvasActionContext, ToolbarGroup } from "../../_vendor/canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../_vendor/canvas-react/host/index";
+export interface FloatingSelectionToolbarPageAnchor {
+    x: number;
+    y: number;
+}
+export interface ToolbarSurfaces {
+    context: CanvasActionContext;
+    activeToolId: string;
+    activeToolLabel: string;
+    isToolLocked: boolean;
+    selectionCount: number;
+    hasMixedSelectionRotation: boolean;
+    toolChromeToolbarGroups: readonly ToolbarGroup[];
+    contextToolbarGroups: readonly ToolbarGroup[];
+    floatingSelectionToolbarGroups: readonly ToolbarGroup[];
+    floatingSelectionToolbarPageAnchor: FloatingSelectionToolbarPageAnchor | null;
+    contextToolbarTitle: string;
+    showContextToolbar: boolean;
+    showFloatingSelectionToolbar: boolean;
+}
+export declare function useToolbarSurfaces({ canShowContextToolbarDuringEditing, editor, pluginHostRuntime, }: {
+    canShowContextToolbarDuringEditing?: (context: CanvasActionContext) => boolean;
+    editor: Editor;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): ToolbarSurfaces;

package/chrome/types.d.ts

@@ -0,0 +1,66 @@
+import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+import type { BuiltInCanvasLayerNode } from "../builtins";
+import type { ActiveContextMenu, EditorSelectionState, ShapeId, CanvasActionValue, CanvasActionContext } from "../_vendor/canvas-core/index";
+import type { HistoryControls, PageControls, ZoomControlsState } from "./bindings/useCanvasKitChromeControls";
+import type { ContextMenuSurface } from "./bindings/useContextMenuSurface";
+import type { SvgExportControls } from "./bindings/useSvgExport";
+import type { ToolbarSurfaces } from "./bindings/useToolbarSurfaces";
+import type { ProductPersistenceStatus } from "../core";
+export type { ContextMenuCommandItem, ContextMenuItem, ContextMenuSection, EditorSelectionState, ShapeId, CanvasActionValue, CanvasActionContext, ToolbarGroup, ToolbarItem, } from "../_vendor/canvas-core/index";
+export type { HistoryControls, PageControls, ZoomControlsState, } from "./bindings/useCanvasKitChromeControls";
+export type { ContextMenuSurface } from "./bindings/useContextMenuSurface";
+export type { SvgExportControls, } from "./bindings/useSvgExport";
+export type { ToolbarSurfaces, } from "./bindings/useToolbarSurfaces";
+export type CanvasKitLayerNode = BuiltInCanvasLayerNode;
+export interface CanvasKitToolbarActionState {
+    value: CanvasActionValue | undefined;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+export interface CanvasKitToolbarRuntime {
+    getActionState(input: {
+        actionId: string;
+        context: CanvasActionContext;
+    }): CanvasKitToolbarActionState | null;
+    runAction(input: {
+        actionId: string;
+        context: CanvasActionContext;
+        value?: CanvasActionValue;
+    }): void;
+}
+export interface CanvasKitGridControls {
+    isVisible: boolean;
+    setIsVisible(isVisible: boolean): void;
+}
+export interface CanvasKitPersistenceControls {
+    discardUnsupportedRecords: (() => Promise<void>) | null;
+    isDiscardingUnsupportedRecords: boolean;
+    status: ProductPersistenceStatus | null;
+}
+export interface CanvasKitChromeContext<TController extends CanvasKitBaseController = CanvasKitController> {
+    controller: TController;
+    contextMenu: CanvasKitContextMenuState;
+    currentPageId: string;
+    currentPageShapeIds: readonly ShapeId[];
+    history: HistoryControls;
+    layers: readonly BuiltInCanvasLayerNode[];
+    pages: PageControls;
+    selection: EditorSelectionState;
+    selectedShapeIds: readonly ShapeId[];
+    persistence: CanvasKitPersistenceControls;
+    svgExport: SvgExportControls;
+    toolbarRuntime: CanvasKitToolbarRuntime;
+    toolbarSurfaces: ToolbarSurfaces;
+    grid: CanvasKitGridControls;
+    zoom: ZoomControlsState;
+}
+export interface CanvasKitContextMenuState {
+    activeContextMenu: ActiveContextMenu | null;
+    onActiveContextMenuChange: (activeContextMenu: ActiveContextMenu | null) => void;
+    runAction(input: {
+        actionId: string;
+        context: NonNullable<ContextMenuSurface["context"]>;
+        value?: CanvasActionValue;
+    }): void;
+    surface: ContextMenuSurface;
+}

package/chrome/useCanvasKitChromeContext.d.ts

@@ -0,0 +1,19 @@
+import { type RefObject } from "react";
+import type { ActiveContextMenu } from "../_vendor/canvas-core/index";
+import type { CanvasKitBaseController } from "../controller/canvasKitController";
+import type { CanvasKitRuntime } from "../runtime/canvasKitRuntime";
+import type { CanvasKitHostExtension } from "../runtime/canvasKitHostExtensions";
+import type { ProductServiceRegistry } from "../core";
+import type { CanvasKitChromeContext, CanvasKitGridControls, CanvasKitPersistenceControls } from "./types";
+export declare function useCanvasKitChromeContext<TController extends CanvasKitBaseController>({ controller, activeContextMenu, editor, grid, hostExtensions, onActiveContextMenuChange, persistence, pluginHostRuntime, services, themeRootRef, }: {
+    controller: TController;
+    activeContextMenu: ActiveContextMenu | null;
+    editor: CanvasKitRuntime["editor"];
+    grid: CanvasKitGridControls;
+    hostExtensions: readonly CanvasKitHostExtension[];
+    onActiveContextMenuChange: (activeContextMenu: ActiveContextMenu | null) => void;
+    persistence: CanvasKitPersistenceControls;
+    pluginHostRuntime: CanvasKitRuntime["pluginHostRuntime"];
+    services: ProductServiceRegistry;
+    themeRootRef: RefObject<HTMLElement | null>;
+}): CanvasKitChromeContext<TController>;

package/controller/canvasKitController.d.ts

@@ -0,0 +1,36 @@
+import { type CanvasProductController, type CanvasProductControllerContext, type CanvasProductSessionSnapshot } from "../core/controller";
+import type { CanvasPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+import { type BuiltInCanvasController, type BuiltInCanvasControllerSnapshot, type BuiltInCanvasFrameInput, type BuiltInCanvasShapeInput, type BuiltInCanvasTextInput } from "../builtins";
+import { type ImageProductController } from "../features/image";
+export type CanvasKitShapeInput = BuiltInCanvasShapeInput;
+export type CanvasKitTextInput = BuiltInCanvasTextInput;
+export type CanvasKitFrameInput = BuiltInCanvasFrameInput;
+export interface CanvasKitBaseController<TToolId extends string = string> extends CanvasProductController<TToolId> {
+}
+export declare const CANVAS_KIT_TOOL_IDS: readonly ["select", "hand", "rectangle", "ellipse", "diamond", "triangle", "hexagon", "star", "arrow", "draw", "text", "frame", "eraser", "laser"];
+export type CanvasKitToolId = (typeof CANVAS_KIT_TOOL_IDS)[number];
+export interface CanvasKitControllerSnapshot<TToolId extends string = CanvasKitToolId> extends BuiltInCanvasControllerSnapshot<TToolId> {
+    productId: string;
+    session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface CanvasKitController<TToolId extends string = CanvasKitToolId> extends BuiltInCanvasController<TToolId> {
+    image: ImageProductController | null;
+    snapshot(): CanvasKitControllerSnapshot<TToolId>;
+}
+export interface CanvasKitControllerRuntimeContext extends Omit<CanvasProductControllerContext, "pluginHostRuntime"> {
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}
+export interface CanvasKitControllerOptions<TToolId extends string = CanvasKitToolId> extends CanvasKitControllerRuntimeContext {
+    assertToolId?: (toolId: string) => asserts toolId is TToolId;
+}
+export interface CanvasKitControllerWithToolsOptions<TToolId extends string> extends CanvasKitControllerRuntimeContext {
+    assertToolId: (toolId: string) => asserts toolId is TToolId;
+}
+export type CanvasKitControllerWithTools<TToolId extends string> = CanvasKitController<TToolId>;
+declare global {
+    interface Window {
+        landCanvasKit?: CanvasKitController;
+    }
+}
+export declare function createCanvasKitController(context: CanvasKitControllerOptions<CanvasKitToolId>): CanvasKitController;
+export declare function createCanvasKitControllerWithTools<TToolId extends string>(context: CanvasKitControllerWithToolsOptions<TToolId>): CanvasKitControllerWithTools<TToolId>;