@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

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

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