@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-react/host/pluginHost.ts

@@ -0,0 +1,635 @@
+import {
+  SET_ACTIVE_TOOL_TOOLBAR_ACTION_ID,
+  TOGGLE_TOOL_LOCKED_TOOLBAR_ACTION_ID,
+  ShapeCapabilitySupport,
+} from "@land/canvas-core";
+import {
+  resolveLandExtensions,
+  type CanvasPluginComponent,
+  type CanvasPluginProvider,
+  type LandExtension,
+  type LandFeatureBundle,
+  type LandCanvasPlugin,
+} from "@land/canvas-plugin-api";
+import type { LandCorePlugin } from "@land/canvas-core";
+import {
+  createCanvasRendererRegistry,
+  type CanvasRendererRegistry,
+} from "./rendererRegistry";
+import {
+  createCanvasDomEventGuardRegistry,
+  type CanvasDomEventGuardRegistry,
+} from "./domEventGuards";
+import {
+  createCanvasToolbarRegistry,
+  type CanvasToolbarRegistry,
+} from "./toolbarRegistry";
+import {
+  createCanvasContextMenuRegistry,
+  type CanvasContextMenuRegistry,
+} from "./contextMenuRegistry";
+
+const HOST_TOOLBAR_ACTION_IDS = [
+  SET_ACTIVE_TOOL_TOOLBAR_ACTION_ID,
+  TOGGLE_TOOL_LOCKED_TOOLBAR_ACTION_ID,
+  "system.clipboard.copy",
+  "system.clipboard.cut",
+  "system.clipboard.paste",
+  "system.clipboard.paste-at-point",
+  "system.selection.duplicate",
+  "system.selection.select-all",
+];
+
+export type CanvasPluginHostSource = "built-in" | "dev-sample";
+export type CanvasPluginHostVerdict = "pass" | "fail";
+
+export interface CreateCanvasPluginHostRuntimeOptions {
+  source?: CanvasPluginHostSource;
+}
+
+export interface CanvasPluginHostManifestEntry {
+  id: string;
+  extensionName: string;
+  source: CanvasPluginHostSource;
+  corePluginIds: string[];
+  canvasPluginIds: string[];
+  interactionHandlerIds: string[];
+  toolbarActionIds: string[];
+  toolbarContributionIds: string[];
+  toolbarContributions: CanvasPluginHostManifestToolbarContributionEntry[];
+  contextMenuContributionIds: string[];
+  contextMenuContributions: CanvasPluginHostManifestContextMenuContributionEntry[];
+  domEventGuardIds: string[];
+  canvasProviderIds: string[];
+  canvasComponentIds: string[];
+  shapeTypes: string[];
+}
+
+export interface CanvasPluginHostManifestToolbarContributionEntry {
+  id: string;
+  surface: string;
+  placement: string;
+  actionIds: string[];
+}
+
+export interface CanvasPluginHostManifestContextMenuContributionEntry {
+  id: string;
+  target: string;
+  actionIds: string[];
+}
+
+export interface CanvasPluginHostRuntime {
+  corePlugins: LandCorePlugin[];
+  canvasPlugins: LandCanvasPlugin[];
+  canvasProviders: CanvasPluginProvider[];
+  canvasComponents: CanvasPluginComponent[];
+  rendererRegistry: CanvasRendererRegistry;
+  domEventGuardRegistry: CanvasDomEventGuardRegistry;
+  toolbarRegistry: CanvasToolbarRegistry;
+  contextMenuRegistry: CanvasContextMenuRegistry;
+  manifest: CanvasPluginHostManifestEntry[];
+  validation: CanvasPluginHostValidationSummary;
+  externalPluginIds: string[];
+  ignoreStoredSnapshots: boolean;
+  disablePersistence: boolean;
+}
+
+export type CanvasPluginHostValidationIssueSeverity = "error" | "warning";
+
+export interface CanvasPluginHostValidationIssue {
+  severity: CanvasPluginHostValidationIssueSeverity;
+  code:
+    | "duplicate-feature-id"
+    | "duplicate-core-plugin-id"
+    | "duplicate-canvas-plugin-id"
+    | "duplicate-interaction-handler-id"
+    | "duplicate-toolbar-action-id"
+    | "duplicate-toolbar-contribution-id"
+    | "duplicate-context-menu-contribution-id"
+    | "duplicate-dom-event-guard-id"
+    | "duplicate-canvas-provider-id"
+    | "duplicate-canvas-component-id"
+    | "missing-toolbar-action"
+    | "missing-context-menu-action"
+    | "missing-core-plugin"
+    | "missing-canvas-plugin"
+    | "missing-shape-type"
+    | "missing-shape-capability"
+    | "missing-shape-util"
+    | "missing-svg-exporter"
+    | "missing-canvas-renderer";
+  featureId: string | null;
+  pluginId: string | null;
+  shapeType: string | null;
+  message: string;
+}
+
+export interface CanvasPluginHostShapeValidationSummary {
+  featureId: string;
+  shapeType: string;
+  hasCapability: boolean;
+  hasShapeUtil: boolean;
+  hasSvgExporter: boolean;
+  hasCanvasRenderer: boolean;
+  exportSupport: ShapeCapabilitySupport | null;
+}
+
+export interface CanvasPluginHostValidationSummary {
+  verdict: CanvasPluginHostVerdict;
+  issueCount: number;
+  errorCount: number;
+  warningCount: number;
+  issues: CanvasPluginHostValidationIssue[];
+  featureIds: string[];
+  corePluginIds: string[];
+  canvasPluginIds: string[];
+  interactionHandlerIds: string[];
+  toolbarActionIds: string[];
+  toolbarContributionIds: string[];
+  contextMenuContributionIds: string[];
+  domEventGuardIds: string[];
+  canvasProviderIds: string[];
+  canvasComponentIds: string[];
+  registeredRendererTypes: string[];
+  shapeSummaries: CanvasPluginHostShapeValidationSummary[];
+}
+
+interface ResolvedCanvasFeature {
+  extensionName: string;
+  feature: LandFeatureBundle;
+  source: CanvasPluginHostSource;
+}
+
+export function createCanvasPluginHostRuntime(
+  extensions: readonly LandExtension[],
+  options: CreateCanvasPluginHostRuntimeOptions = {},
+): CanvasPluginHostRuntime {
+  const source = options.source ?? "built-in";
+  const resolvedFeatures = resolveLandExtensions(extensions).flatMap(
+    ({ extension, feature }): ResolvedCanvasFeature[] =>
+      feature
+        ? [
+            {
+              extensionName: extension.name,
+              feature,
+              source,
+            },
+          ]
+        : [],
+  );
+  const corePlugins = resolvedFeatures.flatMap(
+    ({ feature }) => feature.corePlugins,
+  );
+  const canvasPlugins = resolvedFeatures.flatMap(
+    ({ feature }) => feature.canvasPlugins,
+  );
+  const canvasProviders = canvasPlugins.flatMap((plugin) => [
+    ...(plugin.canvasProviders ?? []),
+  ]);
+  const canvasComponents = canvasPlugins.flatMap((plugin) => [
+    ...(plugin.canvasComponents ?? []),
+  ]);
+  const manifest = resolvedFeatures.map(getManifestEntryFromFeature);
+  const externalPluginIds = resolvedFeatures
+    .filter(({ source: featureSource }) => featureSource !== "built-in")
+    .flatMap(({ feature }) => [
+      ...feature.corePlugins.map((plugin) => plugin.id),
+      ...feature.canvasPlugins.map((plugin) => plugin.id),
+    ]);
+  const hasExternalPlugins = externalPluginIds.length > 0;
+  const rendererRegistry = createCanvasRendererRegistry(canvasPlugins);
+
+  return {
+    corePlugins,
+    canvasPlugins,
+    canvasProviders,
+    canvasComponents,
+    rendererRegistry,
+    domEventGuardRegistry: createCanvasDomEventGuardRegistry(canvasPlugins),
+    toolbarRegistry: createCanvasToolbarRegistry(corePlugins),
+    contextMenuRegistry: createCanvasContextMenuRegistry(corePlugins),
+    manifest,
+    validation: validateCanvasPluginHost({
+      corePlugins,
+      canvasPlugins,
+      rendererRegistry,
+      resolvedFeatures,
+    }),
+    externalPluginIds,
+    ignoreStoredSnapshots: hasExternalPlugins,
+    disablePersistence: hasExternalPlugins,
+  };
+}
+
+function validateCanvasPluginHost(
+  {
+    corePlugins,
+    canvasPlugins,
+    rendererRegistry,
+    resolvedFeatures,
+  }: {
+    corePlugins: readonly LandCorePlugin[];
+    canvasPlugins: readonly LandCanvasPlugin[];
+    rendererRegistry: CanvasRendererRegistry;
+    resolvedFeatures: readonly ResolvedCanvasFeature[];
+  },
+): CanvasPluginHostValidationSummary {
+  const issues: CanvasPluginHostValidationIssue[] = [];
+  const featureIds = resolvedFeatures.map(({ feature }) => feature.id);
+  const corePluginIds = corePlugins.map((plugin) => plugin.id);
+  const canvasPluginIds = canvasPlugins.map((plugin) => plugin.id);
+  const interactionHandlerIds = corePlugins.flatMap((plugin) =>
+    (plugin.interactionHandlers ?? []).map((handler) => handler.id),
+  );
+  const toolbarActionIds = corePlugins.flatMap((plugin) =>
+    (plugin.toolbarActions ?? []).map((action) => action.id),
+  );
+  const toolbarContributionIds = corePlugins.flatMap((plugin) =>
+    (plugin.toolbarContributions ?? []).map((contribution) => contribution.id),
+  );
+  const contextMenuContributionIds = corePlugins.flatMap((plugin) =>
+    (plugin.contextMenuContributions ?? []).map(
+      (contribution) => contribution.id,
+    ),
+  );
+  const knownToolbarActionIds = new Set([
+    ...HOST_TOOLBAR_ACTION_IDS,
+    ...toolbarActionIds,
+  ]);
+  const domEventGuardIds = canvasPlugins.flatMap((plugin) =>
+    (plugin.domEventGuards ?? []).map((guard) => guard.id),
+  );
+  const canvasProviderIds = canvasPlugins.flatMap((plugin) =>
+    (plugin.canvasProviders ?? []).map((provider) => provider.id),
+  );
+  const canvasComponentIds = canvasPlugins.flatMap((plugin) =>
+    (plugin.canvasComponents ?? []).map((component) => component.id),
+  );
+  const shapeUtilsByType = new Set(
+    corePlugins.flatMap((plugin) =>
+      (plugin.shapeUtils ?? []).map((shapeUtil) => shapeUtil.type),
+    ),
+  );
+  const svgExportersByType = new Set(
+    corePlugins.flatMap((plugin) =>
+      (plugin.shapeSvgExporters ?? []).map((exporter) => exporter.type),
+    ),
+  );
+  const capabilitiesByType = new Map(
+    corePlugins.flatMap((plugin) =>
+      (plugin.shapeCapabilities ?? []).map((capability) => [
+        capability.type,
+        capability,
+      ]),
+    ),
+  );
+  const rendererTypes = new Set(rendererRegistry.getRegisteredShapeTypes());
+
+  pushDuplicateIssues({
+    code: "duplicate-feature-id",
+    ids: featureIds,
+    issues,
+    messagePrefix: "Duplicate feature id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-core-plugin-id",
+    ids: corePluginIds,
+    issues,
+    messagePrefix: "Duplicate core plugin id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-canvas-plugin-id",
+    ids: canvasPluginIds,
+    issues,
+    messagePrefix: "Duplicate canvas plugin id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-interaction-handler-id",
+    ids: interactionHandlerIds,
+    issues,
+    messagePrefix: "Duplicate interaction handler id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-toolbar-action-id",
+    ids: toolbarActionIds,
+    issues,
+    messagePrefix: "Duplicate toolbar action id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-toolbar-contribution-id",
+    ids: toolbarContributionIds,
+    issues,
+    messagePrefix: "Duplicate toolbar contribution id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-context-menu-contribution-id",
+    ids: contextMenuContributionIds,
+    issues,
+    messagePrefix: "Duplicate context menu contribution id",
+  });
+  pushMissingToolbarActionIssues({
+    resolvedFeatures,
+    issues,
+    knownToolbarActionIds,
+  });
+  pushMissingContextMenuActionIssues({
+    resolvedFeatures,
+    issues,
+    knownToolbarActionIds,
+  });
+  pushDuplicateIssues({
+    code: "duplicate-dom-event-guard-id",
+    ids: domEventGuardIds,
+    issues,
+    messagePrefix: "Duplicate DOM event guard id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-canvas-provider-id",
+    ids: canvasProviderIds,
+    issues,
+    messagePrefix: "Duplicate canvas plugin provider id",
+  });
+  pushDuplicateIssues({
+    code: "duplicate-canvas-component-id",
+    ids: canvasComponentIds,
+    issues,
+    messagePrefix: "Duplicate canvas plugin component id",
+  });
+
+  const shapeSummaries = resolvedFeatures.flatMap(({ feature }) => {
+    const isToolOnlyFeature =
+      feature.shapeTypes.length === 0 &&
+      feature.corePlugins.some(
+        (plugin) =>
+          (plugin.toolbarContributions ?? []).some(
+            (contribution) => contribution.surface === "tool",
+          ) || plugin.setup !== undefined,
+      );
+
+    if (feature.corePlugins.length === 0) {
+      issues.push({
+        severity: "error",
+        code: "missing-core-plugin",
+        featureId: feature.id,
+        pluginId: null,
+        shapeType: null,
+        message: `Feature ${feature.id} does not include a core plugin.`,
+      });
+    }
+    if (feature.canvasPlugins.length === 0 && !isToolOnlyFeature) {
+      issues.push({
+        severity: "error",
+        code: "missing-canvas-plugin",
+        featureId: feature.id,
+        pluginId: null,
+        shapeType: null,
+        message: `Feature ${feature.id} does not include a canvas plugin.`,
+      });
+    }
+    if (feature.shapeTypes.length === 0 && !isToolOnlyFeature) {
+      issues.push({
+        severity: "error",
+        code: "missing-shape-type",
+        featureId: feature.id,
+        pluginId: null,
+        shapeType: null,
+        message: `Feature ${feature.id} does not declare shape types.`,
+      });
+    }
+
+    return feature.shapeTypes.map((shapeType) => {
+      const capability = capabilitiesByType.get(shapeType) ?? null;
+      const hasShapeUtil = shapeUtilsByType.has(shapeType);
+      const hasSvgExporter = svgExportersByType.has(shapeType);
+      const hasCanvasRenderer = rendererTypes.has(shapeType);
+      const exportSupport: ShapeCapabilitySupport =
+        hasShapeUtil && hasSvgExporter ? "supported" : "missing";
+
+      if (!capability) {
+        issues.push({
+          severity: "error",
+          code: "missing-shape-capability",
+          featureId: feature.id,
+          pluginId: null,
+          shapeType,
+          message: `Shape type ${shapeType} does not have a core capability entry.`,
+        });
+      }
+      if (!hasShapeUtil) {
+        issues.push({
+          severity: "error",
+          code: "missing-shape-util",
+          featureId: feature.id,
+          pluginId: null,
+          shapeType,
+          message: `Shape type ${shapeType} does not have a core shape util.`,
+        });
+      }
+      if (capability?.reactRenderer === "supported" && !hasCanvasRenderer) {
+        issues.push({
+          severity: "error",
+          code: "missing-canvas-renderer",
+          featureId: feature.id,
+          pluginId: null,
+          shapeType,
+          message: `Shape type ${shapeType} declares React renderer support but no canvas renderer registered.`,
+        });
+      }
+      if (!hasSvgExporter) {
+        issues.push({
+          severity: "warning",
+          code: "missing-svg-exporter",
+          featureId: feature.id,
+          pluginId: null,
+          shapeType,
+          message: `Shape type ${shapeType} does not have an SVG exporter.`,
+        });
+      }
+
+      return {
+        featureId: feature.id,
+        shapeType,
+        hasCapability: capability !== null,
+        hasShapeUtil,
+        hasSvgExporter,
+        hasCanvasRenderer,
+        exportSupport,
+      };
+    });
+  });
+  const errorCount = issues.filter((issue) => issue.severity === "error").length;
+  const warningCount = issues.length - errorCount;
+
+  return {
+    verdict: errorCount === 0 ? "pass" : "fail",
+    issueCount: issues.length,
+    errorCount,
+    warningCount,
+    issues,
+    featureIds,
+    corePluginIds,
+    canvasPluginIds,
+    interactionHandlerIds,
+    toolbarActionIds,
+    toolbarContributionIds,
+    contextMenuContributionIds,
+    domEventGuardIds,
+    canvasProviderIds,
+    canvasComponentIds,
+    registeredRendererTypes: Array.from(rendererTypes),
+    shapeSummaries,
+  };
+}
+
+function pushDuplicateIssues({
+  code,
+  ids,
+  issues,
+  messagePrefix,
+}: {
+  code:
+    | "duplicate-feature-id"
+    | "duplicate-core-plugin-id"
+    | "duplicate-canvas-plugin-id"
+    | "duplicate-interaction-handler-id"
+    | "duplicate-toolbar-action-id"
+    | "duplicate-toolbar-contribution-id"
+    | "duplicate-context-menu-contribution-id"
+    | "duplicate-dom-event-guard-id"
+    | "duplicate-canvas-provider-id"
+    | "duplicate-canvas-component-id";
+  ids: readonly string[];
+  issues: CanvasPluginHostValidationIssue[];
+  messagePrefix: string;
+}): void {
+  const counts = new Map<string, number>();
+  for (const id of ids) {
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  for (const [id, count] of counts) {
+    if (count > 1) {
+      issues.push({
+        severity: "error",
+        code,
+        featureId: null,
+        pluginId: id,
+        shapeType: null,
+        message: `${messagePrefix}: ${id}.`,
+      });
+    }
+  }
+}
+
+function pushMissingContextMenuActionIssues({
+  resolvedFeatures,
+  issues,
+  knownToolbarActionIds,
+}: {
+  resolvedFeatures: readonly ResolvedCanvasFeature[];
+  issues: CanvasPluginHostValidationIssue[];
+  knownToolbarActionIds: ReadonlySet<string>;
+}): void {
+  for (const { feature } of resolvedFeatures) {
+    for (const plugin of feature.corePlugins) {
+      for (const contribution of plugin.contextMenuContributions ?? []) {
+        for (const actionId of contribution.actionIds) {
+          if (knownToolbarActionIds.has(actionId)) {
+            continue;
+          }
+          issues.push({
+            severity: "error",
+            code: "missing-context-menu-action",
+            featureId: feature.id,
+            pluginId: plugin.id,
+            shapeType: null,
+            message: `Context menu contribution ${contribution.id} references missing action ${actionId}.`,
+          });
+        }
+      }
+    }
+  }
+}
+
+function pushMissingToolbarActionIssues({
+  resolvedFeatures,
+  issues,
+  knownToolbarActionIds,
+}: {
+  resolvedFeatures: readonly ResolvedCanvasFeature[];
+  issues: CanvasPluginHostValidationIssue[];
+  knownToolbarActionIds: ReadonlySet<string>;
+}): void {
+  for (const { feature } of resolvedFeatures) {
+    for (const plugin of feature.corePlugins) {
+      for (const contribution of plugin.toolbarContributions ?? []) {
+        for (const actionId of contribution.actionIds) {
+          if (knownToolbarActionIds.has(actionId)) {
+            continue;
+          }
+          issues.push({
+            severity: "error",
+            code: "missing-toolbar-action",
+            featureId: feature.id,
+            pluginId: plugin.id,
+            shapeType: null,
+            message: `Toolbar contribution ${contribution.id} references missing action ${actionId}.`,
+          });
+        }
+      }
+    }
+  }
+}
+
+function getManifestEntryFromFeature(
+  resolvedFeature: ResolvedCanvasFeature,
+): CanvasPluginHostManifestEntry {
+  const { extensionName, feature, source } = resolvedFeature;
+  return {
+    id: feature.id,
+    extensionName,
+    source,
+    corePluginIds: feature.corePlugins.map((plugin) => plugin.id),
+    canvasPluginIds: feature.canvasPlugins.map((plugin) => plugin.id),
+    interactionHandlerIds: feature.corePlugins.flatMap((plugin) =>
+      (plugin.interactionHandlers ?? []).map((handler) => handler.id),
+    ),
+    toolbarActionIds: feature.corePlugins.flatMap((plugin) =>
+      (plugin.toolbarActions ?? []).map((action) => action.id),
+    ),
+    toolbarContributionIds: feature.corePlugins.flatMap((plugin) =>
+      (plugin.toolbarContributions ?? []).map(
+        (contribution) => contribution.id,
+      ),
+    ),
+    toolbarContributions: feature.corePlugins.flatMap((plugin) =>
+      (plugin.toolbarContributions ?? []).map((contribution) => ({
+        id: contribution.id,
+        surface: contribution.surface,
+        placement: contribution.placement ?? "context",
+        actionIds: [...contribution.actionIds],
+      })),
+    ),
+    contextMenuContributionIds: feature.corePlugins.flatMap((plugin) =>
+      (plugin.contextMenuContributions ?? []).map(
+        (contribution) => contribution.id,
+      ),
+    ),
+    contextMenuContributions: feature.corePlugins.flatMap((plugin) =>
+      (plugin.contextMenuContributions ?? []).map((contribution) => ({
+        id: contribution.id,
+        target: contribution.target,
+        actionIds: [...contribution.actionIds],
+      })),
+    ),
+    domEventGuardIds: feature.canvasPlugins.flatMap((plugin) =>
+      (plugin.domEventGuards ?? []).map((guard) => guard.id),
+    ),
+    canvasProviderIds: feature.canvasPlugins.flatMap((plugin) =>
+      (plugin.canvasProviders ?? []).map((provider) => provider.id),
+    ),
+    canvasComponentIds: feature.canvasPlugins.flatMap((plugin) =>
+      (plugin.canvasComponents ?? []).map((component) => component.id),
+    ),
+    shapeTypes: [...feature.shapeTypes],
+  };
+}

package/_vendor/canvas-react/host/rendererRegistry.tsx

@@ -0,0 +1,58 @@
+import type { ShapeRecordBase } from "@land/canvas-core";
+import {
+  setupCanvasPlugins,
+  type AnyRegisteredShapeRenderer,
+  type LandCanvasPlugin,
+  type RegisteredShapeRenderer,
+} from "@land/canvas-plugin-api";
+
+export class CanvasRendererRegistry {
+  private readonly registry = new Map<string, AnyRegisteredShapeRenderer>();
+  private readonly registeredPluginIds = new Set<string>();
+
+  registerShapeRenderer<S extends ShapeRecordBase>(
+    renderer: RegisteredShapeRenderer<S>,
+  ): void {
+    this.registry.set(renderer.type, eraseRegisteredShapeRenderer(renderer));
+  }
+
+  getShapeRenderer(
+    type: ShapeRecordBase["type"],
+  ): AnyRegisteredShapeRenderer | null {
+    return this.registry.get(type) ?? null;
+  }
+
+  hasShapeRenderer(type: ShapeRecordBase["type"]): boolean {
+    return this.registry.has(type);
+  }
+
+  getRegisteredShapeTypes(): ShapeRecordBase["type"][] {
+    return [...this.registry.keys()];
+  }
+
+  registerCanvasPlugins(plugins: readonly LandCanvasPlugin[]): void {
+    const pendingPlugins = plugins.filter(
+      (plugin) => !this.registeredPluginIds.has(plugin.id),
+    );
+    setupCanvasPlugins(pendingPlugins, (renderer) =>
+      this.registerShapeRenderer(renderer),
+    );
+    for (const plugin of pendingPlugins) {
+      this.registeredPluginIds.add(plugin.id);
+    }
+  }
+}
+
+function eraseRegisteredShapeRenderer<S extends ShapeRecordBase>(
+  renderer: RegisteredShapeRenderer<S>,
+): AnyRegisteredShapeRenderer {
+  return renderer as unknown as AnyRegisteredShapeRenderer;
+}
+
+export function createCanvasRendererRegistry(
+  plugins: readonly LandCanvasPlugin[] = [],
+): CanvasRendererRegistry {
+  const nextRegistry = new CanvasRendererRegistry();
+  nextRegistry.registerCanvasPlugins(plugins);
+  return nextRegistry;
+}