@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-core/tools/select/states/index.ts

@@ -0,0 +1,11 @@
+export { BrushingState } from "./BrushingState";
+export { DraggingSelectionHandleInteractionState } from "./DraggingSelectionHandleInteractionState";
+export { IdleState } from "./IdleState";
+export { PointingCanvasState } from "./PointingCanvasState";
+export { PointingResizeHandleState } from "./PointingResizeHandleState";
+export { PointingRotateHandleState } from "./PointingRotateHandleState";
+export { PointingSelectionHandleInteractionState } from "./PointingSelectionHandleInteractionState";
+export { PointingShapeState } from "./PointingShapeState";
+export { ResizingState } from "./ResizingState";
+export { RotatingState } from "./RotatingState";
+export { TranslatingState } from "./TranslatingState";

package/_vendor/canvas-plugin-api/feature.ts

@@ -0,0 +1,204 @@
+import type {
+  LandCorePlugin,
+  ShapeRecordBase,
+} from "@land/canvas-core";
+import type { LandCanvasPlugin } from "./index";
+
+type LandExtensionOptions = Record<string, unknown>;
+
+export interface LandFeatureBundle {
+  id: string;
+  corePlugins: readonly LandCorePlugin[];
+  canvasPlugins: readonly LandCanvasPlugin[];
+  shapeTypes: readonly ShapeRecordBase["type"][];
+}
+
+export interface LandExtension {
+  readonly name: string;
+  readonly options: Readonly<LandExtensionOptions>;
+  readonly priority: number;
+  createFeature(): LandFeatureBundle | null;
+  getExtensions(): readonly LandExtension[];
+}
+
+export type LandExtensionOptionsInput<T> =
+  T extends readonly unknown[]
+    ? T
+    : T extends LandExtensionOptions
+      ? { [K in keyof T]?: LandExtensionOptionsInput<T[K]> }
+      : T;
+
+export interface ConfigurableLandExtension<
+  Options extends LandExtensionOptions,
+> extends LandExtension {
+  readonly options: Readonly<Options>;
+  configure(
+    options?: LandExtensionOptionsInput<Options>,
+  ): ConfigurableLandExtension<Options>;
+}
+
+export interface LandExtensionConfig<
+  Options extends LandExtensionOptions,
+> {
+  name: string;
+  priority?: number;
+  addOptions?(): Options;
+  addExtensions?(
+    options: Readonly<Options>,
+  ): readonly LandExtension[];
+  createFeature?(options: Readonly<Options>): LandFeatureBundle;
+}
+
+export interface ResolvedLandExtension {
+  extension: LandExtension;
+  feature: LandFeatureBundle | null;
+}
+
+const DEFAULT_EXTENSION_PRIORITY = 100;
+
+class LandExtensionInstance<
+  Options extends LandExtensionOptions,
+> implements ConfigurableLandExtension<Options> {
+  readonly name: string;
+  readonly options: Readonly<Options>;
+  readonly priority: number;
+
+  constructor(
+    private readonly config: LandExtensionConfig<Options>,
+    options: Options,
+  ) {
+    this.name = config.name;
+    this.options = Object.freeze(options);
+    this.priority = config.priority ?? DEFAULT_EXTENSION_PRIORITY;
+  }
+
+  configure(
+    options?: LandExtensionOptionsInput<Options>,
+  ): ConfigurableLandExtension<Options> {
+    return new LandExtensionInstance(
+      this.config,
+      mergeExtensionOptions(
+        this.options,
+        options ?? ({} as LandExtensionOptionsInput<Options>),
+      ),
+    );
+  }
+
+  createFeature(): LandFeatureBundle | null {
+    return this.config.createFeature?.(this.options) ?? null;
+  }
+
+  getExtensions(): readonly LandExtension[] {
+    return this.config.addExtensions?.(this.options) ?? [];
+  }
+}
+
+export function defineLandExtension<
+  Options extends LandExtensionOptions = Record<string, never>,
+>(
+  config: LandExtensionConfig<Options>,
+): ConfigurableLandExtension<Options> {
+  if (!config.createFeature && !config.addExtensions) {
+    throw new Error(
+      `Land extension "${config.name}" must define createFeature() or addExtensions().`,
+    );
+  }
+
+  const options = config.addOptions?.() ?? ({} as Options);
+  return new LandExtensionInstance(config, options);
+}
+
+export function resolveLandExtensions(
+  extensions: readonly LandExtension[],
+): ResolvedLandExtension[] {
+  const flattened: Array<{ extension: LandExtension; index: number }> = [];
+  const activeExtensions = new Set<LandExtension>();
+  let index = 0;
+
+  const visit = (extension: LandExtension) => {
+    if (activeExtensions.has(extension)) {
+      throw new Error(
+        `Circular Land extension bundle detected at "${extension.name}".`,
+      );
+    }
+
+    activeExtensions.add(extension);
+    flattened.push({ extension, index });
+    index += 1;
+    for (const child of extension.getExtensions()) {
+      visit(child);
+    }
+    activeExtensions.delete(extension);
+  };
+
+  for (const extension of extensions) {
+    visit(extension);
+  }
+
+  const duplicateNames = getDuplicateNames(
+    flattened.map(({ extension }) => extension.name),
+  );
+  if (duplicateNames.length > 0) {
+    throw new Error(
+      `Duplicate Land extension names: ${duplicateNames.join(", ")}.`,
+    );
+  }
+
+  return flattened
+    .sort(
+      (a, b) =>
+        b.extension.priority - a.extension.priority ||
+        a.index - b.index,
+    )
+    .map(({ extension }) => ({
+      extension,
+      feature: extension.createFeature(),
+    }));
+}
+
+function mergeExtensionOptions<Options extends LandExtensionOptions>(
+  base: Readonly<Options>,
+  overrides: LandExtensionOptionsInput<Options>,
+): Options {
+  return mergeRecords(base, overrides as LandExtensionOptions) as Options;
+}
+
+function mergeRecords(
+  base: Readonly<LandExtensionOptions>,
+  overrides: Readonly<LandExtensionOptions>,
+): LandExtensionOptions {
+  const result: LandExtensionOptions = { ...base };
+
+  for (const [key, overrideValue] of Object.entries(overrides)) {
+    const baseValue = base[key];
+    result[key] =
+      isPlainRecord(baseValue) && isPlainRecord(overrideValue)
+        ? mergeRecords(baseValue, overrideValue)
+        : overrideValue;
+  }
+
+  return result;
+}
+
+function isPlainRecord(value: unknown): value is LandExtensionOptions {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value)
+  );
+}
+
+function getDuplicateNames(names: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+
+  for (const name of names) {
+    if (seen.has(name)) {
+      duplicates.add(name);
+    } else {
+      seen.add(name);
+    }
+  }
+
+  return [...duplicates];
+}

package/_vendor/canvas-plugin-api/index.ts

@@ -0,0 +1,142 @@
+import type { ComponentType, ReactNode } from "react";
+import type {
+  Editor,
+  LandCorePlugin,
+  ShapeEditingSession,
+  ShapeRecordBase,
+  ToolbarAction,
+  ToolbarActionRunInput,
+  ToolbarActionValue,
+  ToolbarBadgeItem,
+  ToolbarButtonItem,
+  ToolbarContext,
+  ToolbarContribution,
+  ToolbarGroup,
+  ToolbarItem,
+  ToolbarSegmentedItem,
+  ToolbarSegmentedOption,
+  ToolbarSelectionSnapshot,
+  ToolbarSeparatorItem,
+  ToolbarStepperItem,
+  ToolbarStepperOption,
+  ToolbarTextInputItem,
+  ToolbarSurface,
+  ToolbarSwatchesItem,
+  ToolbarSwatchOption,
+  ToolbarToolSnapshot,
+} from "@land/canvas-core";
+export {
+  defineLandExtension,
+  resolveLandExtensions,
+} from "./feature";
+export type {
+  ConfigurableLandExtension,
+  LandExtension,
+  LandExtensionConfig,
+  LandExtensionOptionsInput,
+  LandFeatureBundle,
+  ResolvedLandExtension,
+} from "./feature";
+
+export interface ShapeRendererProps<
+  S extends ShapeRecordBase = ShapeRecordBase,
+> {
+  shape: S;
+  editor: Editor;
+  isSelected: boolean;
+  shapeEditingSession: ShapeEditingSession | null;
+}
+
+export interface RegisteredShapeRenderer<
+  S extends ShapeRecordBase = ShapeRecordBase,
+> {
+  type: S["type"];
+  component: ComponentType<ShapeRendererProps<S>>;
+}
+
+export type AnyRegisteredShapeRenderer = RegisteredShapeRenderer<ShapeRecordBase>;
+
+export interface CanvasPluginComponent {
+  id: string;
+  component: ComponentType;
+}
+
+export interface CanvasPluginProvider {
+  id: string;
+  component: ComponentType<{ children: ReactNode }>;
+}
+
+export type ShapeRendererRegistrar = <S extends ShapeRecordBase>(
+  renderer: RegisteredShapeRenderer<S>,
+) => void;
+
+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 LandCanvasPlugin {
+  id: string;
+  domEventGuards?: readonly CanvasDomEventGuard[];
+  canvasProviders?: readonly CanvasPluginProvider[];
+  canvasComponents?: readonly CanvasPluginComponent[];
+  setup(registerShapeRenderer: ShapeRendererRegistrar): void;
+}
+
+export type {
+  ToolbarAction,
+  ToolbarActionRunInput,
+  ToolbarActionValue,
+  ToolbarBadgeItem,
+  ToolbarButtonItem,
+  ToolbarContext,
+  ToolbarContribution,
+  ToolbarGroup,
+  ToolbarItem,
+  ToolbarSegmentedItem,
+  ToolbarSegmentedOption,
+  ToolbarSelectionSnapshot,
+  ToolbarSeparatorItem,
+  ToolbarStepperItem,
+  ToolbarStepperOption,
+  ToolbarTextInputItem,
+  ToolbarSurface,
+  ToolbarSwatchesItem,
+  ToolbarSwatchOption,
+  ToolbarToolSnapshot,
+};
+
+export function setupCanvasPlugins(
+  plugins: readonly LandCanvasPlugin[],
+  registerShapeRenderer: ShapeRendererRegistrar,
+): void {
+  for (const plugin of plugins) {
+    plugin.setup(registerShapeRenderer);
+  }
+}

package/_vendor/canvas-product-react/api/apiRegistry.ts

@@ -0,0 +1,35 @@
+export interface ProductApiToken<TApi> {
+  readonly id: string;
+  readonly __api?: TApi;
+}
+
+export interface ProductApiRegistry {
+  get<TApi>(token: ProductApiToken<TApi>): TApi | null;
+}
+
+export interface ProductApiRegistryRuntime extends ProductApiRegistry {
+  register<TApi>(token: ProductApiToken<TApi>, api: TApi): void;
+}
+
+export function createProductApiToken<TApi>(
+  id: string,
+): ProductApiToken<TApi> {
+  return { id };
+}
+
+export function createProductApiRegistry(): ProductApiRegistryRuntime {
+  const apis = new Map<string, unknown>();
+
+  return {
+    register<TApi>(token: ProductApiToken<TApi>, api: TApi): void {
+      if (apis.has(token.id)) {
+        throw new Error(`Product API already registered: ${token.id}`);
+      }
+      apis.set(token.id, api);
+    },
+    get<TApi>(token: ProductApiToken<TApi>): TApi | null {
+      return (apis.get(token.id) as TApi | undefined) ?? null;
+    },
+  };
+}
+