@teambit/importer 1.0.108 → 1.0.110

package/import.cmd.ts

@@ -1,286 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import chalk from 'chalk';
-import { compact } from 'lodash';
-import R from 'ramda';
-import { installationErrorOutput, compilationErrorOutput } from '@teambit/merging';
-import {
-  FileStatus,
-  MergeOptions,
-  MergeStrategy,
-} from '@teambit/legacy/dist/consumer/versions-ops/merge-version/merge-version';
-import { ComponentIdList, ComponentID } from '@teambit/component-id';
-import GeneralError from '@teambit/legacy/dist/error/general-error';
-import { immutableUnshift } from '@teambit/legacy/dist/utils';
-import { formatPlainComponentItem } from '@teambit/legacy/dist/cli/chalk-box';
-import { ImporterMain } from './importer.main.runtime';
-import { ImportOptions, ImportDetails, ImportStatus, ImportResult } from './import-components';
-
-type ImportFlags = {
-  path?: string;
-  objects?: boolean;
-  displayDependencies?: boolean;
-  override?: boolean;
-  verbose?: boolean;
-  json?: boolean;
-  conf?: string;
-  skipDependencyInstallation?: boolean;
-  skipWriteConfigFiles?: boolean;
-  merge?: MergeStrategy;
-  filterEnvs?: string;
-  saveInLane?: boolean;
-  dependencies?: boolean;
-  dependents?: boolean;
-  allHistory?: boolean;
-  fetchDeps?: boolean;
-  trackOnly?: boolean;
-  includeDeprecated?: boolean;
-};
-
-export class ImportCmd implements Command {
-  name = 'import [component-patterns...]';
-  description = 'import components from their remote scopes to the local workspace';
-  helpUrl = 'reference/components/importing-components';
-  arguments = [
-    {
-      name: 'component-patterns...',
-      description:
-        'component IDs or component patterns (separated by space). Use patterns to import groups of components using a common scope or namespace. E.g., "utils/*" (wrap with double quotes)',
-    },
-  ];
-  extendedDescription: string;
-  group = 'collaborate';
-  alias = '';
-  options = [
-    ['p', 'path <path>', 'import components into a specific directory (a relative path in the workspace)'],
-    [
-      'o',
-      'objects',
-      'import components objects to the local scope without checkout (without writing them to the file system). This is the default behavior for import with no id argument',
-    ],
-    ['O', 'override', 'override local changes'],
-    ['v', 'verbose', 'show verbose output for inspection'],
-    ['j', 'json', 'return the output as JSON'],
-    // ['', 'conf', 'write the configuration file (component.json) of the component'], // not working. need to fix once ComponentWriter is moved to Harmony
-    ['x', 'skip-dependency-installation', 'do not auto-install dependencies of the imported components'],
-    ['', 'skip-write-config-files', 'do not write config files (such as eslint, tsconfig, prettier, etc...)'],
-    [
-      'm',
-      'merge [strategy]',
-      'merge local changes with the imported version. strategy should be "theirs", "ours" or "manual"',
-    ],
-    [
-      '',
-      'dependencies',
-      'import all dependencies (bit components only) of imported components and write them to the workspace',
-    ],
-    [
-      '',
-      'dependents',
-      'import components found while traversing from the imported components upwards to the workspace components',
-    ],
-    [
-      '',
-      'filter-envs <envs>',
-      'only import components that have the specified environment (e.g., "teambit.react/react-env")',
-    ],
-    [
-      '',
-      'save-in-lane',
-      'when checked out to a lane and the component is not on the remote-lane, save it in the lane (defaults to save on main)',
-    ],
-    [
-      '',
-      'all-history',
-      'relevant for fetching all components objects. avoid optimizations, fetch all history versions, always',
-    ],
-    [
-      '',
-      'fetch-deps',
-      'fetch dependencies (bit components) objects to the local scope, but dont add to the workspace. Useful to resolve errors about missing dependency data',
-    ],
-    [
-      '',
-      'track-only',
-      'do not write any component files, just create .bitmap entries of the imported components. Useful when the files already exist and just want to re-add the component to the bitmap',
-    ],
-    ['', 'include-deprecated', 'when importing with patterns, include deprecated components (default to exclude them)'],
-  ] as CommandOptions;
-  loader = true;
-  migration = true;
-  remoteOp = true;
-  _packageManagerArgs: string[]; // gets populated by yargs-adapter.handler().
-
-  constructor(private importer: ImporterMain) {}
-
-  async report([ids = []]: [string[]], importFlags: ImportFlags): Promise<any> {
-    const {
-      importDetails,
-      importedIds,
-      importedDeps,
-      installationError,
-      compilationError,
-      missingIds,
-      cancellationMessage,
-    } = await this.getImportResults(ids, importFlags);
-    if (!importedIds.length && !missingIds?.length) {
-      return chalk.yellow(cancellationMessage || 'nothing to import');
-    }
-    const importedIdsUniqNoVersion = ComponentIdList.fromArray(importedIds).toVersionLatest();
-    const summaryPrefix =
-      importedIdsUniqNoVersion.length === 1
-        ? 'successfully imported one component'
-        : `successfully imported ${importedIdsUniqNoVersion.length} components`;
-
-    let upToDateCount = 0;
-    const importedComponents = importedIds.map((bitId) => {
-      const details = importDetails.find((c) => c.id === bitId.toStringWithoutVersion());
-      if (!details) throw new Error(`missing details for component ${bitId.toString()}`);
-      if (details.status === 'up to date') {
-        upToDateCount += 1;
-      }
-      return formatPlainComponentItemWithVersions(bitId, details);
-    });
-    const upToDateStr = upToDateCount === 0 ? '' : `, ${upToDateCount} components are up to date`;
-    const summary = `${summaryPrefix}${upToDateStr}`;
-    const importOutput = [...compact(importedComponents), chalk.green(summary)].join('\n');
-    const importedDepsOutput =
-      importFlags.displayDependencies && importedDeps.length
-        ? immutableUnshift(
-            R.uniq(importedDeps.map(formatPlainComponentItem)),
-            chalk.green(`\n\nsuccessfully imported ${importedDeps.length} component dependencies`)
-          ).join('\n')
-        : '';
-
-    const output =
-      importOutput +
-      importedDepsOutput +
-      formatMissingComponents(missingIds) +
-      installationErrorOutput(installationError) +
-      compilationErrorOutput(compilationError);
-
-    return output;
-  }
-
-  async json([ids]: [string[]], importFlags: ImportFlags) {
-    const { importDetails, installationError, missingIds } = await this.getImportResults(ids, importFlags);
-
-    return { importDetails, installationError, missingIds };
-  }
-
-  private async getImportResults(
-    ids: string[],
-    {
-      path,
-      objects = false,
-      override = false,
-      verbose = false,
-      conf,
-      skipDependencyInstallation = false,
-      skipWriteConfigFiles = false,
-      merge,
-      filterEnvs,
-      saveInLane = false,
-      dependencies = false,
-      dependents = false,
-      allHistory = false,
-      fetchDeps = false,
-      trackOnly = false,
-      includeDeprecated = false,
-    }: ImportFlags
-  ): Promise<ImportResult> {
-    if (objects && merge) {
-      throw new GeneralError(' --objects and --merge flags cannot be used together');
-    }
-    if (override && merge) {
-      throw new GeneralError('--override and --merge cannot be used together');
-    }
-    if (!ids.length && dependencies) {
-      throw new GeneralError('you have to specify ids to use "--dependencies" flag');
-    }
-    if (!ids.length && dependents) {
-      throw new GeneralError('you have to specify ids to use "--dependents" flag');
-    }
-    if (!ids.length && trackOnly) {
-      throw new GeneralError('you have to specify ids to use "--track-only" flag');
-    }
-    let mergeStrategy;
-    if (merge && R.is(String, merge)) {
-      const options = Object.keys(MergeOptions);
-      if (!options.includes(merge)) {
-        throw new GeneralError(`merge must be one of the following: ${options.join(', ')}`);
-      }
-      mergeStrategy = merge;
-    }
-
-    const envsToFilter = filterEnvs ? filterEnvs.split(',').map((p) => p.trim()) : undefined;
-
-    const importOptions: ImportOptions = {
-      ids,
-      verbose,
-      merge: Boolean(merge),
-      filterEnvs: envsToFilter,
-      mergeStrategy,
-      writeToPath: path,
-      objectsOnly: objects,
-      override,
-      writeConfig: Boolean(conf),
-      installNpmPackages: !skipDependencyInstallation,
-      writeConfigFiles: !skipWriteConfigFiles,
-      saveInLane,
-      importDependenciesDirectly: dependencies,
-      importDependents: dependents,
-      allHistory,
-      fetchDeps,
-      trackOnly,
-      includeDeprecated,
-    };
-    return this.importer.import(importOptions, this._packageManagerArgs);
-  }
-}
-
-function formatMissingComponents(missing?: string[]) {
-  if (!missing?.length) return '';
-  const title = chalk.underline('Missing Components');
-  const subTitle = `The following components are missing from the remote in the requested version, try running "bit status" to re-sync your .bitmap file
-Also, check that the requested version exists on main or the checked out lane`;
-  const body = chalk.red(missing.join('\n'));
-  return `\n\n${title}\n${subTitle}\n${body}`;
-}
-
-function formatPlainComponentItemWithVersions(bitId: ComponentID, importDetails: ImportDetails) {
-  const status: ImportStatus = importDetails.status;
-  const id = bitId.toStringWithoutVersion();
-  const getVersionsOutput = () => {
-    if (!importDetails.versions.length) return '';
-    if (importDetails.latestVersion) {
-      return `${importDetails.versions.length} new version(s) available, latest ${importDetails.latestVersion}`;
-    }
-    return `new versions: ${importDetails.versions.join(', ')}`;
-  };
-  const versions = getVersionsOutput();
-  const usedVersion = status === 'added' ? `, currently used version ${bitId.version}` : '';
-  const getConflictMessage = () => {
-    if (!importDetails.filesStatus) return '';
-    const conflictedFiles = Object.keys(importDetails.filesStatus)
-      // @ts-ignore file is set
-      .filter((file) => importDetails.filesStatus[file] === FileStatus.manual);
-    if (!conflictedFiles.length) return '';
-    return `(the following files were saved with conflicts ${conflictedFiles
-      .map((file) => chalk.bold(file))
-      .join(', ')}) `;
-  };
-  const conflictMessage = getConflictMessage();
-  const deprecated = importDetails.deprecated && !importDetails.removed ? chalk.yellow('deprecated') : '';
-  const removed = importDetails.removed ? chalk.red('removed') : '';
-  const missingDeps = importDetails.missingDeps.length
-    ? chalk.red(`missing dependencies: ${importDetails.missingDeps.map((d) => d.toString()).join(', ')}`)
-    : '';
-  if (status === 'up to date' && !missingDeps && !deprecated && !conflictMessage && !removed) {
-    return undefined;
-  }
-  return chalk.dim(
-    `- ${chalk.green(status)} ${chalk.cyan(
-      id
-    )} ${versions}${usedVersion} ${conflictMessage}${deprecated}${removed} ${missingDeps}`
-  );
-}

package/importer.aspect.ts

@@ -1,5 +0,0 @@
-import { Aspect } from '@teambit/harmony';
-
-export const ImporterAspect = Aspect.create({
-  id: 'teambit.scope/importer',
-});

package/importer.main.runtime.ts

@@ -1,332 +0,0 @@
-import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
-import { DependencyResolverAspect, DependencyResolverMain } from '@teambit/dependency-resolver';
-import WorkspaceAspect, { OutsideWorkspaceError, Workspace } from '@teambit/workspace';
-import { Analytics } from '@teambit/legacy/dist/analytics/analytics';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import componentIdToPackageName from '@teambit/legacy/dist/utils/bit/component-id-to-package-name';
-import { InvalidScopeName, InvalidScopeNameFromRemote } from '@teambit/legacy-bit-id';
-import pMapSeries from 'p-map-series';
-import EnvsAspect, { EnvsMain } from '@teambit/envs';
-import ComponentWriterAspect, { ComponentWriterMain } from '@teambit/component-writer';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import ScopeAspect, { ScopeMain } from '@teambit/scope';
-import { DEFAULT_LANE, LaneId } from '@teambit/lane-id';
-import ScopeComponentsImporter from '@teambit/legacy/dist/scope/component-ops/scope-components-importer';
-import { importAllArtifacts } from '@teambit/legacy/dist/consumer/component/sources/artifact-files';
-import InstallAspect, { InstallMain } from '@teambit/install';
-import loader from '@teambit/legacy/dist/cli/loader';
-import { ComponentIdList, ComponentID } from '@teambit/component-id';
-import { Lane } from '@teambit/legacy/dist/scope/models';
-import { ScopeNotFoundOrDenied } from '@teambit/legacy/dist/remotes/exceptions/scope-not-found-or-denied';
-import GraphAspect, { GraphMain } from '@teambit/graph';
-import { LaneNotFound } from '@teambit/legacy/dist/api/scope/lib/exceptions/lane-not-found';
-import { BitError } from '@teambit/bit-error';
-import { ImportCmd } from './import.cmd';
-import { ImporterAspect } from './importer.aspect';
-import { FetchCmd } from './fetch-cmd';
-import ImportComponents, { ImportOptions, ImportResult } from './import-components';
-
-export class ImporterMain {
-  constructor(
-    private workspace: Workspace,
-    private depResolver: DependencyResolverMain,
-    private graph: GraphMain,
-    private scope: ScopeMain,
-    private componentWriter: ComponentWriterMain,
-    private envs: EnvsMain,
-    private logger: Logger
-  ) {}
-
-  async import(importOptions: ImportOptions, packageManagerArgs: string[] = []): Promise<ImportResult> {
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    const consumer = this.workspace.consumer;
-    consumer.packageManagerArgs = packageManagerArgs;
-    if (!importOptions.ids.length) {
-      importOptions.objectsOnly = true;
-    }
-    if (this.workspace.consumer.isOnLane()) {
-      const currentRemoteLane = await this.workspace.getCurrentRemoteLane();
-      if (currentRemoteLane) {
-        importOptions.lanes = { laneIds: [currentRemoteLane.toLaneId()], lanes: [currentRemoteLane] };
-      } else if (!importOptions.ids.length) {
-        // this is probably a local lane that was never exported.
-        // although no need to fetch from the lane, still, the import is needed for main (which are available on this
-        // local lane)
-        const currentLaneId = this.workspace.getCurrentLaneId();
-        importOptions.lanes = { laneIds: [currentLaneId], lanes: [] };
-      }
-    }
-    const importComponents = new ImportComponents(
-      this.workspace,
-      this.graph,
-      this.componentWriter,
-      this.envs,
-      importOptions
-    );
-    const results = await importComponents.importComponents();
-    Analytics.setExtraData('num_components', results.importedIds.length);
-    if (results.writtenComponents && results.writtenComponents.length) {
-      await this.removeFromWorkspaceConfig(results.writtenComponents);
-    }
-    await consumer.onDestroy('import');
-    return results;
-  }
-
-  /**
-   * fetch objects according to the criteria set by `options` param.
-   * to fetch current objects according to the current lane or main, use `this.importCurrentObjects()`.
-   */
-  async importObjects(options: Partial<ImportOptions> = {}): Promise<ImportResult> {
-    const importOptions: ImportOptions = {
-      ...options,
-      objectsOnly: true,
-      ids: options.ids || [],
-      installNpmPackages: false,
-      writeConfigFiles: false,
-    };
-    const importComponents = new ImportComponents(
-      this.workspace,
-      this.graph,
-      this.componentWriter,
-      this.envs,
-      importOptions
-    );
-    return importComponents.importComponents();
-  }
-
-  /**
-   * given a lane object, load all components by their head on the lane, find the artifacts refs and import them from
-   * the lane scope
-   */
-  async importHeadArtifactsFromLane(lane: Lane, ids: ComponentID[] = lane.toBitIds(), throwIfMissing = false) {
-    const laneComps = await this.scope.legacyScope.getManyConsumerComponents(ids);
-    try {
-      await importAllArtifacts(this.scope.legacyScope, laneComps, lane);
-    } catch (err) {
-      this.logger.error(`failed fetching artifacts for lane ${lane.id.toString()}`, err);
-      if (throwIfMissing) throw err;
-    }
-  }
-
-  /**
-   * if on main, fetch main objects, if on lane, fetch lane objects.
-   */
-  async importCurrentObjects(): Promise<ImportResult> {
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    const importOptions: ImportOptions = {
-      ids: [],
-      objectsOnly: true,
-      installNpmPackages: false,
-      writeConfigFiles: false,
-    };
-    const currentRemoteLane = await this.workspace.getCurrentRemoteLane();
-    if (currentRemoteLane) {
-      importOptions.lanes = { laneIds: [currentRemoteLane.toLaneId()], lanes: [currentRemoteLane] };
-    }
-    const importComponents = new ImportComponents(
-      this.workspace,
-      this.graph,
-      this.componentWriter,
-      this.envs,
-      importOptions
-    );
-    return importComponents.importComponents();
-  }
-
-  async importObjectsFromMainIfExist(ids: ComponentID[]) {
-    await this.scope.legacyScope.scopeImporter.importWithoutDeps(ComponentIdList.fromArray(ids), {
-      cache: false,
-      includeVersionHistory: true,
-      ignoreMissingHead: true,
-    });
-  }
-
-  /**
-   * fetch lane's components and save them in the local scope.
-   * once done, merge the lane object and save it as well.
-   */
-  async fetchLaneComponents(lane: Lane) {
-    const ids = lane.toBitIds();
-    await this.scope.legacyScope.scopeImporter.importMany({
-      ids,
-      lane,
-      reason: `for fetching lane ${lane.id()}`,
-    });
-    const { mergeLane } = await this.scope.legacyScope.sources.mergeLane(lane, true);
-    await this.scope.legacyScope.lanes.saveLane(mergeLane);
-  }
-
-  async fetch(ids: string[], lanes: boolean, components: boolean, fromOriginalScope: boolean, allHistory = false) {
-    if (!lanes && !components) {
-      throw new BitError(
-        `please provide the type of objects you would like to pull, the options are --components and --lanes`
-      );
-    }
-    loader.start('fetching objects...');
-    if (!this.workspace) throw new OutsideWorkspaceError();
-    const consumer = this.workspace.consumer;
-
-    if (lanes) {
-      const lanesToFetch = await getLanes(this.logger);
-      const shouldFetchFromMain = !ids.length || ids.includes(DEFAULT_LANE);
-      return this.fetchLanes(lanesToFetch, shouldFetchFromMain, { allHistory });
-    }
-
-    const importOptions: ImportOptions = {
-      ids,
-      objectsOnly: true,
-      allHistory,
-      verbose: false,
-      writeConfig: false,
-      override: false,
-      installNpmPackages: false,
-      writeConfigFiles: false,
-      fromOriginalScope,
-    };
-
-    const importComponents = new ImportComponents(
-      this.workspace,
-      this.graph,
-      this.componentWriter,
-      this.envs,
-      importOptions
-    );
-    const { importedIds, importDetails } = await importComponents.importComponents();
-    Analytics.setExtraData('num_components', importedIds.length);
-    await consumer.onDestroy('import');
-    return { importedIds, importDetails };
-
-    async function getLanes(logger: Logger): Promise<Lane[]> {
-      let remoteLaneIds: LaneId[] = [];
-      if (ids.length) {
-        remoteLaneIds = ids
-          .filter((id) => id !== DEFAULT_LANE)
-          .map((id) => {
-            const trackLane = consumer.scope.lanes.getRemoteTrackedDataByLocalLane(id);
-            if (trackLane) return LaneId.from(trackLane.remoteLane, trackLane.remoteScope);
-            return LaneId.parse(id);
-          });
-      } else {
-        remoteLaneIds = await consumer.scope.objects.remoteLanes.getAllRemoteLaneIds();
-      }
-      const scopeComponentImporter = ScopeComponentsImporter.getInstance(consumer.scope);
-      try {
-        return await scopeComponentImporter.importLanes(remoteLaneIds);
-      } catch (err: any) {
-        if (
-          err instanceof InvalidScopeName ||
-          err instanceof ScopeNotFoundOrDenied ||
-          err instanceof LaneNotFound ||
-          err instanceof InvalidScopeNameFromRemote
-        ) {
-          // the lane could be a local lane so no need to throw an error in such case
-          loader.stop();
-          logger.console(`unable to get lane's data from a remote due to an error:\n${err.message}`, 'warn', 'yellow');
-        } else {
-          throw err;
-        }
-      }
-
-      return [];
-    }
-  }
-
-  async fetchLanes(
-    lanes: Lane[],
-    shouldFetchFromMain?: boolean,
-    options: Partial<ImportOptions> = {}
-  ): Promise<ImportResult> {
-    const resultFromMain = shouldFetchFromMain
-      ? await this.importObjects(options)
-      : { importedIds: [], importDetails: [], importedDeps: [] };
-    const resultsPerLane = await pMapSeries(lanes, async (lane) => {
-      this.logger.setStatusLine(`fetching lane ${lane.name}`);
-      options.lanes = { laneIds: [lane.toLaneId()], lanes: [lane] };
-      options.isLaneFromRemote = true;
-      const results = await this.importObjects(options);
-      this.logger.consoleSuccess();
-      return results;
-    });
-    resultsPerLane.push(resultFromMain);
-    const results = resultsPerLane.reduce((acc, curr) => {
-      acc.importedIds.push(...curr.importedIds);
-      acc.importDetails.push(...curr.importDetails);
-      return acc;
-    });
-    return results;
-  }
-
-  /**
-   * get a Lane object from the remote.
-   * `persistIfNotExists` saves the object in the local scope only if the lane is not there yet.
-   * otherwise, it needs some merging mechanism, which is done differently whether it's export or import.
-   * see `sources.mergeLane()` for export and `import-components._saveLaneDataIfNeeded()` for import.
-   * in this case, because we only bring the lane object and not the components, it's not easy to do the merge.
-   */
-  async importLaneObject(laneId: LaneId, persistIfNotExists = true): Promise<Lane> {
-    const legacyScope = this.scope.legacyScope;
-    const results = await legacyScope.scopeImporter.importLanes([laneId]);
-    const laneObject = results[0];
-    if (!laneObject) throw new LaneNotFound(laneId.scope, laneId.name);
-
-    if (persistIfNotExists) {
-      const exists = await legacyScope.loadLane(laneId);
-      if (!exists) {
-        await legacyScope.lanes.saveLane(laneObject);
-      }
-    }
-
-    return laneObject;
-  }
-
-  private async removeFromWorkspaceConfig(component: ConsumerComponent[]) {
-    const importedPackageNames = this.getImportedPackagesNames(component);
-    this.depResolver.removeFromRootPolicy(importedPackageNames);
-    await this.depResolver.persistConfig(this.workspace.path);
-  }
-
-  private getImportedPackagesNames(components: ConsumerComponent[]): string[] {
-    return components.map((component) => componentIdToPackageName(component));
-  }
-
-  static slots = [];
-  static dependencies = [
-    CLIAspect,
-    WorkspaceAspect,
-    DependencyResolverAspect,
-    GraphAspect,
-    ScopeAspect,
-    ComponentWriterAspect,
-    InstallAspect,
-    EnvsAspect,
-    LoggerAspect,
-  ];
-  static runtime = MainRuntime;
-  static async provider([cli, workspace, depResolver, graph, scope, componentWriter, install, envs, loggerMain]: [
-    CLIMain,
-    Workspace,
-    DependencyResolverMain,
-    GraphMain,
-    ScopeMain,
-    ComponentWriterMain,
-    InstallMain,
-    EnvsMain,
-    LoggerMain
-  ]) {
-    const logger = loggerMain.createLogger(ImporterAspect.id);
-    const importerMain = new ImporterMain(workspace, depResolver, graph, scope, componentWriter, envs, logger);
-    install.registerPreInstall(async (opts) => {
-      if (!opts?.import) return;
-      logger.setStatusLine('importing missing objects');
-      await importerMain.importCurrentObjects();
-      // logger.consoleSuccess();
-    });
-    install.registerPreLink(async (opts) => {
-      if (opts?.fetchObject) await importerMain.importCurrentObjects();
-    });
-    cli.register(new ImportCmd(importerMain), new FetchCmd(importerMain));
-    return importerMain;
-  }
-}
-
-ImporterAspect.addRuntime(ImporterMain);

package/index.ts

@@ -1,6 +0,0 @@
-import { ImporterAspect } from './importer.aspect';
-
-export type { ImportOptions } from './import-components';
-export type { ImporterMain } from './importer.main.runtime';
-export default ImporterAspect;
-export { ImporterAspect };