@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuzhouu/canvas-kit",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Land canvas packaged as an all-in-one React canvas kit and typed API surface.",
   "type": "module",
   "main": "./index.mjs",
@@ -15,16 +15,6 @@
       "import": "./index.mjs",
       "default": "./index.mjs"
     },
-    "./product": {
-      "types": "./product/index.d.ts",
-      "import": "./product.mjs",
-      "default": "./product.mjs"
-    },
-    "./standard": {
-      "types": "./standard/index.d.ts",
-      "import": "./standard.mjs",
-      "default": "./standard.mjs"
-    },
     "./style.css": "./index.css",
     "./package.json": "./package.json"
   },

package/product/canvasKitProduct.d.ts

@@ -0,0 +1,59 @@
+import type { CanvasPluginHostRuntime, LandExtension } from "../_vendor/canvas-react/host/index";
+import type { ReactNode } from "react";
+import type { CanvasProductRuntimeInitializer, ProductAssetResolverService, ProductPersistenceAdapter, ProductServiceFactory, ProductServiceToken } from "../core";
+import type { CanvasKitBaseController, CanvasKitController } from "../controller/canvasKitController";
+import type { CanvasKitChromeContext } from "../chrome/types";
+import { type CanvasKitHostExtension } from "../runtime/canvasKitHostExtensions";
+export declare const CANVAS_KIT_STORAGE_NAMESPACE = "land.canvasKit";
+declare const CANVAS_KIT_PRODUCT_BRAND: unique symbol;
+export type CanvasKitChromeRenderer<TController extends CanvasKitBaseController = CanvasKitController> = (context: CanvasKitChromeContext<TController>) => ReactNode;
+export type CanvasKitDocumentSeed<TController extends CanvasKitBaseController = CanvasKitController> = (controller: TController) => void;
+export interface CanvasKitExtensionOptions {
+    arrow?: boolean;
+    draw?: boolean;
+    eraser?: boolean;
+    frame?: boolean;
+    geo?: boolean;
+    group?: boolean;
+    image?: boolean;
+    laser?: boolean;
+    text?: boolean;
+}
+export interface CanvasKitProductOptions<TController extends CanvasKitBaseController = CanvasKitController> {
+    id?: string;
+    chrome?: CanvasKitChromeRenderer<TController>;
+    exposeControllerOnWindow?: boolean;
+    onControllerDispose?: () => void;
+    onControllerReady?: (controller: TController) => void;
+    persistence?: ProductPersistenceAdapter | null;
+    seedDocument?: CanvasKitDocumentSeed<TController>;
+    shouldSkipStoredSnapshots?: () => boolean;
+    builtInExtensions?: CanvasKitExtensionOptions;
+    storageNamespace?: string;
+    warnOnPluginRegistrationConflicts?: boolean;
+    windowKey?: string;
+}
+export interface ResolvedCanvasKitConfig<TController extends CanvasKitBaseController = CanvasKitController> {
+    renderChrome?: CanvasKitChromeRenderer<TController>;
+    exposeControllerOnWindow: boolean;
+    onControllerDispose?: () => void;
+    onControllerReady?: (controller: TController) => void;
+    windowKey: string;
+}
+export interface CanvasKitProduct<TController extends CanvasKitBaseController = CanvasKitController> {
+    readonly [CANVAS_KIT_PRODUCT_BRAND]: TController;
+}
+export interface ResolvedCanvasKitProduct<TController extends CanvasKitBaseController = CanvasKitController> extends CanvasKitProduct<TController> {
+    readonly assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    readonly canvasExtensions: readonly LandExtension[];
+    readonly id: string;
+    readonly config: ResolvedCanvasKitConfig<TController>;
+    readonly hostExtensions: readonly CanvasKitHostExtension[];
+    readonly initializeRuntime: CanvasProductRuntimeInitializer<CanvasPluginHostRuntime>;
+    readonly persistence: ProductPersistenceAdapter | null;
+    readonly serviceFactories: readonly ProductServiceFactory<unknown>[];
+    readonly shouldSkipStoredSnapshots?: () => boolean;
+}
+export declare function defineCanvasKit<TController extends CanvasKitBaseController = CanvasKitController>(options?: CanvasKitProductOptions<TController>): CanvasKitProduct<TController>;
+export declare function asResolvedCanvasKitProduct<TController extends CanvasKitBaseController = CanvasKitController>(product: CanvasKitProduct<TController>): ResolvedCanvasKitProduct<TController>;
+export {};

package/react/CanvasKitPersistenceNotice.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasKitPersistenceControls } from "../chrome/types";
+export declare function CanvasKitPersistenceNotice({ persistence, }: {
+    persistence: CanvasKitPersistenceControls;
+}): import("react/jsx-runtime").JSX.Element | null;

package/react/CanvasKitRoot.d.ts

@@ -0,0 +1,5 @@
+import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+import type { CanvasKitProduct } from "../product/canvasKitProduct";
+export declare function CanvasKitRoot<TController extends CanvasKitBaseController = CanvasKitController>({ product, }: {
+    product: CanvasKitProduct<TController>;
+}): import("react/jsx-runtime").JSX.Element | null;

package/react/useCanvasKitController.d.ts

@@ -0,0 +1,5 @@
+import { type CanvasKitController, type CanvasKitControllerRuntimeContext, type CanvasKitBaseController } from "../controller/canvasKitController";
+import type { ResolvedCanvasKitConfig } from "../product/canvasKitProduct";
+export declare function useCanvasKitController<TController extends CanvasKitBaseController = CanvasKitController>({ featureControllers, config, editor, pluginHostRuntime, productId, services, }: CanvasKitControllerRuntimeContext & {
+    config: ResolvedCanvasKitConfig<TController>;
+}): TController;

package/react/useCanvasKitKeyboardShortcuts.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+export declare function useCanvasKitKeyboardShortcuts({ editor, pluginHostRuntime, }: {
+    editor: Editor;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): void;

package/react/useCanvasKitRuntime.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+import { type CanvasKitProduct } from "../product/canvasKitProduct";
+import { type CanvasKitRuntime } from "../runtime/canvasKitRuntime";
+export declare function useCanvasKitRuntime<TController extends CanvasKitBaseController = CanvasKitController>(product: CanvasKitProduct<TController>): CanvasKitRuntime<TController> | null;

package/react/useCanvasKitStartup.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+import type { CanvasKitPersistenceControls } from "../chrome/types";
+import type { CanvasKitRuntime } from "../runtime/canvasKitRuntime";
+interface CanvasKitStartup {
+    isReady: boolean;
+    persistence: CanvasKitPersistenceControls;
+}
+export declare function useCanvasKitStartup<TController extends CanvasKitBaseController = CanvasKitController>(runtime: CanvasKitRuntime<TController> | null): CanvasKitStartup;
+export {};

package/runtime/canvasKitHostExtensions.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from "react";
+import type { CanvasActionContext, Editor } from "../_vendor/canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+import { type CanvasProductRuntimeContribution, type ProductAssetResolverService, type ProductServiceFactory, type ProductServiceRegistry, type ProductServiceToken, type SvgAssetInliner } from "../core";
+export interface CanvasKitHostExtension extends CanvasProductRuntimeContribution<CanvasPluginHostRuntime> {
+    canShowToolbarDuringEditing?: (context: CanvasActionContext) => boolean;
+    createSvgAssetInliners?: (services: ProductServiceRegistry) => readonly SvgAssetInliner[];
+    renderController?: (input: {
+        editor: Editor;
+        services: ProductServiceRegistry;
+    }) => ReactNode;
+}
+export declare function createCanvasKitHostExtensions({ flushSnapshot, image, }: {
+    flushSnapshot?: (editor: Editor) => Promise<void>;
+    image: boolean;
+}): readonly CanvasKitHostExtension[];
+export declare function getCanvasKitHostExtensionSvgAssetInliners(hostExtensions: readonly CanvasKitHostExtension[], services: ProductServiceRegistry): readonly SvgAssetInliner[];
+export declare function getCanvasKitHostExtensionServiceFactories(hostExtensions: readonly CanvasKitHostExtension[]): readonly ProductServiceFactory<unknown>[];
+export declare function getCanvasKitHostExtensionAssetResolverTokens(hostExtensions: readonly CanvasKitHostExtension[]): readonly ProductServiceToken<ProductAssetResolverService>[];

package/runtime/canvasKitRuntime.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import { type CanvasPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+import { type ProductAssetResolverService, type ProductFeatureControllerRegistryRuntime, type ProductPersistenceAdapter, type ProductServiceRegistryRuntime, type ProductServiceToken } from "../core";
+import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+import type { ResolvedCanvasKitConfig, ResolvedCanvasKitProduct } from "../product/canvasKitProduct";
+import type { CanvasKitHostExtension } from "./canvasKitHostExtensions";
+export interface CanvasKitRuntime<TController extends CanvasKitBaseController = CanvasKitController> {
+    assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    config: ResolvedCanvasKitConfig<TController>;
+    editor: Editor;
+    featureControllers: ProductFeatureControllerRegistryRuntime;
+    hostExtensions: readonly CanvasKitHostExtension[];
+    persistence: ProductPersistenceAdapter | null;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    productId: string;
+    services: ProductServiceRegistryRuntime;
+    shouldSkipStoredSnapshots?: () => boolean;
+}
+export declare function createCanvasKitRuntime<TController extends CanvasKitBaseController = CanvasKitController>(product: ResolvedCanvasKitProduct<TController>): CanvasKitRuntime<TController>;

package/runtime/canvasKitRuntimeInitializer.d.ts

@@ -0,0 +1,11 @@
+import { type CanvasActionContext } from "../_vendor/canvas-core/index";
+import { type CanvasKitBaseController } from "../controller/canvasKitController";
+import type { CanvasProductRuntimeInitializer } from "../core";
+import type { CanvasKitHostExtension } from "./canvasKitHostExtensions";
+import type { CanvasKitRuntime } from "./canvasKitRuntime";
+export declare function createCanvasKitRuntimeInitializer<TController extends CanvasKitBaseController>({ hostExtensions, seedDocument, warnOnPluginRegistrationConflicts, }: {
+    hostExtensions: readonly CanvasKitHostExtension[];
+    seedDocument?: (controller: TController) => void;
+    warnOnPluginRegistrationConflicts: boolean;
+}): CanvasProductRuntimeInitializer<CanvasKitRuntime["pluginHostRuntime"]>;
+export declare function canShowCanvasKitToolbarDuringEditing(hostExtensions: readonly CanvasKitHostExtension[], context: CanvasActionContext): boolean;

package/_vendor/canvas-core/bindings/BindingUtil.ts

@@ -1,92 +0,0 @@
-import type { Editor } from "../editor/Editor";
-import type { SelectionOverlayFrameGeometryState } from "../editor/selection";
-import type {
-  BindingId,
-  BindingRecord,
-  BindingRecordBase,
-  ShapeRecord,
-} from "../schema/records";
-
-export interface BindingUtilEffect {
-  shapes?: ShapeRecord[];
-  bindings?: BindingRecord[];
-  deleteShapeIds?: ShapeRecord["id"][];
-  deleteBindingIds?: BindingId[];
-}
-
-export interface BindingShapeChangeContext {
-  before: ShapeRecord;
-  after: ShapeRecord;
-  role: "from" | "to";
-}
-
-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 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;
-
-  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"][];
-
-  getGeometryDependentShapeIds?(
-    editor: Editor,
-    binding: B,
-    context: BindingShapeGeometryDependencyContext,
-  ): ShapeRecord["id"][];
-
-  getSelectionCompanionFrameGeometries?(
-    editor: Editor,
-    binding: B,
-    context: BindingSelectionCompanionFrameContext,
-  ): SelectionOverlayFrameGeometryState[];
-}

package/_vendor/canvas-core/bindings/BindingUtilRegistry.ts

@@ -1,22 +0,0 @@
-import type { BindingRecordBase } from "../schema/records";
-import { BindingUtil } from "./BindingUtil";
-
-export class BindingUtilRegistry {
-  private readonly registry = new Map<string, BindingUtil>();
-
-  register<B extends BindingRecordBase>(util: BindingUtil<B>): void {
-    this.registry.set(util.type, util as BindingUtil);
-  }
-
-  values(): IterableIterator<BindingUtil> {
-    return this.registry.values();
-  }
-
-  get<B extends BindingRecordBase>(type: B["type"]): BindingUtil<B> {
-    const util = this.registry.get(type);
-    if (!util) {
-      throw new Error(`Missing binding util for type \"${type}\"`);
-    }
-    return util as BindingUtil<B>;
-  }
-}

package/_vendor/canvas-core/bindings/arrow/arrowBindingHelpers.ts

@@ -1,52 +0,0 @@
-import { Vec } from "../../geometry/Vec";
-import type { Editor } from "../../editor/Editor";
-import type { ArrowBindingPreviewState } from "../../editor/selection";
-import type { ShapeId } from "../../schema/records";
-
-export interface ConnectionPoint {
-  x: number;
-  y: number;
-}
-
-export type ConnectionTerminal = "start" | "end";
-
-export interface ArrowBindingTargetInput {
-  targetShapeId: ShapeId;
-  normalizedAnchor: ConnectionPoint;
-}
-
-export interface ResolvedArrowTerminalBinding {
-  pagePoint: Vec;
-  binding: ArrowBindingTargetInput | null;
-  preview: ArrowBindingPreviewState | null;
-}
-
-export interface ArrowTerminalBindingResolverInput {
-  terminal: ConnectionTerminal;
-  rawPagePoint: Vec;
-  oppositePagePoint: Vec;
-  excludeShapeId?: ShapeId;
-  ignoreTargets?: boolean;
-}
-
-export type ArrowTerminalBindingResolver = (
-  editor: Editor,
-  input: ArrowTerminalBindingResolverInput,
-) => ResolvedArrowTerminalBinding;
-
-export function getFreeArrowTerminalBinding({
-  rawPagePoint,
-}: ArrowTerminalBindingResolverInput): ResolvedArrowTerminalBinding {
-  return {
-    pagePoint: rawPagePoint.clone(),
-    binding: null,
-    preview: null,
-  };
-}
-
-export function resolveArrowTerminalBindingAtPoint(
-  editor: Editor,
-  input: ArrowTerminalBindingResolverInput,
-): ResolvedArrowTerminalBinding {
-  return editor.resolveArrowTerminalBinding(input);
-}

package/_vendor/canvas-core/contextMenu.ts

@@ -1,85 +0,0 @@
-import type { ShapeId, ShapeRecordBase } from "./schema/records";
-import type { ToolbarActionValue, ToolbarContext } from "./toolbar";
-import type { Vec } from "./geometry";
-
-export interface ContextMenuCanvasTarget {
-  type: "canvas";
-}
-
-export interface ContextMenuShapeTarget {
-  type: "shape";
-  shapeId: ShapeId;
-  shapeType: ShapeRecordBase["type"];
-  selected: boolean;
-}
-
-export interface ContextMenuSelectionTarget {
-  type: "selection";
-  selectedShapeIds: readonly ShapeId[];
-}
-
-export type ContextMenuTarget =
-  | ContextMenuCanvasTarget
-  | ContextMenuShapeTarget
-  | ContextMenuSelectionTarget;
-
-export interface ContextMenuOpenSnapshot {
-  screenPoint: Vec;
-  pagePoint: Vec;
-  target: ContextMenuTarget;
-}
-
-export interface ContextMenuContext extends ToolbarContext {
-  menu: ContextMenuOpenSnapshot;
-}
-
-export type ContextMenuContributionTarget =
-  | "canvas"
-  | "selection"
-  | "shape"
-  | "any";
-
-export interface ContextMenuCommandItem {
-  kind: "command";
-  id: string;
-  actionId: string;
-  label: string;
-  icon?: string;
-  value?: ToolbarActionValue;
-  shortcut?: string;
-  tone?: "default" | "destructive";
-  dataUi?: string;
-}
-
-export interface ContextMenuSeparatorItem {
-  kind: "separator";
-  id: string;
-}
-
-export interface ContextMenuBadgeItem {
-  kind: "badge";
-  id: string;
-  label: string;
-  dataUi?: string;
-}
-
-export type ContextMenuItem =
-  | ContextMenuCommandItem
-  | ContextMenuSeparatorItem
-  | ContextMenuBadgeItem;
-
-export interface ContextMenuSection {
-  id: string;
-  order?: number;
-  title?: string;
-  items: readonly ContextMenuItem[];
-}
-
-export interface ContextMenuContribution {
-  id: string;
-  target: ContextMenuContributionTarget;
-  order?: number;
-  actionIds: readonly string[];
-  when?(context: ContextMenuContext): boolean;
-  getSections(context: ContextMenuContext): readonly ContextMenuSection[];
-}