@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

@@ -1,11 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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;
-    },
-  };
-}
-