@wyw-in-js/transform 1.0.6 → 1.0.7

package/esm/transform/generators/rewriteBarrelImports.js

@@ -0,0 +1,733 @@
+/* eslint-disable no-continue, @typescript-eslint/no-use-before-define, @typescript-eslint/no-explicit-any, no-param-reassign, prefer-destructuring */
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+import { EventEmitter } from '../../utils/EventEmitter';
+import { shaker } from '../../shaker';
+import { TransformCacheCollection } from '../../cache';
+import { Entrypoint } from '../Entrypoint';
+import { analyzeBarrelFile } from '../barrelManifest';
+const createAnalysisServices = services => ({
+  ...services,
+  cache: new TransformCacheCollection({
+    barrelManifests: services.cache.barrelManifests,
+    exports: services.cache.exports
+  }),
+  eventEmitter: EventEmitter.dummy
+});
+const addBinding = (manifest, exported, binding, explicitExports) => {
+  const existing = manifest[exported];
+  if (explicitExports.has(exported)) {
+    return;
+  }
+  if (!existing) {
+    manifest[exported] = binding;
+    return;
+  }
+  if (existing.kind === 'blocked') {
+    return;
+  }
+  if (!isSameBinding(existing, binding)) {
+    manifest[exported] = {
+      kind: 'blocked',
+      reason: 'ambiguous'
+    };
+  }
+};
+const addBlockedExport = (manifest, exported, reason) => {
+  manifest[exported] = {
+    kind: 'blocked',
+    reason
+  };
+};
+const buildResolvedDependencyMap = resolvedImports => new Map(resolvedImports.map(dependency => [dependency.source, dependency]));
+const cloneExportedName = name => t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
+const cloneImportedName = name => name === 'default' || t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
+const isSameBinding = (left, right) => {
+  if (left.kind !== right.kind) {
+    return false;
+  }
+  if (left.source !== right.source) {
+    return false;
+  }
+  if (left.kind === 'named' && right.kind === 'named') {
+    return left.imported === right.imported;
+  }
+  return true;
+};
+function createAnalysisEntrypoint(services, filename, loadedCode) {
+  return Entrypoint.createRoot(services, filename, ['*'], loadedCode);
+}
+function getUniqueSources(raw) {
+  return Array.from(new Set([...raw.reexports.map(reexport => reexport.source), ...raw.exportAll]));
+}
+function buildImportsForResolve(raw) {
+  return new Map(getUniqueSources(raw).map(source => [source, []]));
+}
+function getReexportResolutionMap(resolvedImports) {
+  return new Map(resolvedImports.map(dependency => [dependency.source, dependency.resolved]));
+}
+function isBarrelEntry(entry) {
+  return entry.kind === 'barrel';
+}
+function isRawBarrelManifest(entry) {
+  return 'reexports' in entry;
+}
+function shouldUseDirectExports(reason) {
+  return reason === 'impure';
+}
+const getModuleName = node => t.isIdentifier(node) ? node.name : node.value;
+const canEmitNamedReexport = imported => imported === 'default' || t.isValidIdentifier(imported);
+function collectOptimizedImports(ast) {
+  const imports = new Map();
+  const addImport = (source, imported) => {
+    if (!imports.has(source)) {
+      imports.set(source, []);
+    }
+    if (!imports.get(source).includes(imported)) {
+      imports.get(source).push(imported);
+    }
+  };
+  const program = ast.program;
+  for (const statement of program.body) {
+    if (t.isImportDeclaration(statement) && t.isStringLiteral(statement.source)) {
+      if (statement.specifiers.length === 0) {
+        addImport(statement.source.value, 'side-effect');
+        continue;
+      }
+      for (const specifier of statement.specifiers) {
+        if (t.isImportDefaultSpecifier(specifier)) {
+          addImport(statement.source.value, 'default');
+          continue;
+        }
+        if (t.isImportNamespaceSpecifier(specifier)) {
+          addImport(statement.source.value, '*');
+          continue;
+        }
+        if (t.isImportSpecifier(specifier)) {
+          addImport(statement.source.value, t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value);
+        }
+      }
+      continue;
+    }
+    if (t.isExportNamedDeclaration(statement) && statement.source && t.isStringLiteral(statement.source)) {
+      for (const specifier of statement.specifiers) {
+        if (t.isExportNamespaceSpecifier(specifier)) {
+          addImport(statement.source.value, '*');
+          continue;
+        }
+        if (t.isExportDefaultSpecifier(specifier)) {
+          addImport(statement.source.value, 'default');
+          continue;
+        }
+        if (t.isExportSpecifier(specifier)) {
+          addImport(statement.source.value, getModuleName(specifier.local));
+        }
+      }
+      continue;
+    }
+    if (t.isExportAllDeclaration(statement) && statement.source && t.isStringLiteral(statement.source)) {
+      addImport(statement.source.value, '*');
+    }
+  }
+  return imports;
+}
+function groupImportSpecifiers(optimized) {
+  const grouped = new Map();
+  for (const specifier of optimized) {
+    if (!grouped.has(specifier.source)) {
+      grouped.set(specifier.source, {
+        defaults: [],
+        named: []
+      });
+    }
+    const bucket = grouped.get(specifier.source);
+    if (specifier.kind === 'default') {
+      bucket.defaults.push(t.importDefaultSpecifier(specifier.local));
+      continue;
+    }
+    bucket.named.push(t.importSpecifier(specifier.local, cloneImportedName(specifier.imported)));
+  }
+  const declarations = [];
+  for (const [source, bucket] of grouped) {
+    if (bucket.defaults.length === 0) {
+      declarations.push(t.importDeclaration(bucket.named, t.stringLiteral(source)));
+      continue;
+    }
+    declarations.push(t.importDeclaration([bucket.defaults[0], ...bucket.named], t.stringLiteral(source)));
+    for (const defaultSpecifier of bucket.defaults.slice(1)) {
+      declarations.push(t.importDeclaration([defaultSpecifier], t.stringLiteral(source)));
+    }
+  }
+  return declarations;
+}
+function groupExportSpecifiers(optimized) {
+  const grouped = new Map();
+  for (const specifier of optimized) {
+    if (!grouped.has(specifier.source)) {
+      grouped.set(specifier.source, []);
+    }
+    if (specifier.kind === 'namespace') {
+      grouped.get(specifier.source).push(t.exportNamespaceSpecifier(t.identifier(specifier.exported)));
+      continue;
+    }
+    grouped.get(specifier.source).push(t.exportSpecifier(t.identifier(specifier.imported), cloneExportedName(specifier.exported)));
+  }
+  return Array.from(grouped.entries()).map(([source, specifiers]) => t.exportNamedDeclaration(null, specifiers, t.stringLiteral(source)));
+}
+function createImportFallback(statement, fallbackSpecifiers) {
+  if (fallbackSpecifiers.length === 0) {
+    return null;
+  }
+  return t.importDeclaration(fallbackSpecifiers, t.stringLiteral(statement.source.value));
+}
+function createExportFallback(statement, fallbackSpecifiers) {
+  if (!statement.source || fallbackSpecifiers.length === 0) {
+    return null;
+  }
+  return t.exportNamedDeclaration(null, fallbackSpecifiers, t.stringLiteral(statement.source.value));
+}
+function emitRewriteSkipped(action, source, reason) {
+  action.services.eventEmitter.single({
+    file: action.entrypoint.name,
+    kind: 'barrelRewriteSkipped',
+    reason,
+    source
+  });
+}
+function getManifestExport(manifest, exported) {
+  return manifest.exports[exported] ?? null;
+}
+function* getNamedBinding(analysisServices, targetResolved, imported, stack) {
+  if (stack.has(targetResolved)) {
+    return {
+      kind: 'blocked',
+      reason: 'cycle'
+    };
+  }
+  const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+  if (isBarrelEntry(targetManifest)) {
+    const resolved = getManifestExport(targetManifest, imported);
+    if (resolved) {
+      return resolved;
+    }
+    return {
+      kind: 'blocked',
+      reason: targetManifest.complete ? 'unresolved' : 'unknown-star'
+    };
+  }
+  return {
+    kind: 'named',
+    imported,
+    source: targetResolved
+  };
+}
+function* getStarCandidates(analysisServices, targetResolved, stack) {
+  if (stack.has(targetResolved)) {
+    return {
+      candidates: [],
+      complete: false
+    };
+  }
+  const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+  if (isBarrelEntry(targetManifest)) {
+    if (!targetManifest.complete) {
+      return {
+        candidates: [],
+        complete: false
+      };
+    }
+    return {
+      candidates: Object.entries(targetManifest.exports).filter(([exported, binding]) => exported !== 'default' && binding.kind !== 'blocked').map(([exported, binding]) => ({
+        binding: binding,
+        exported
+      })),
+      complete: true
+    };
+  }
+  if (!shouldUseDirectExports(targetManifest.reason)) {
+    return {
+      candidates: [],
+      complete: false
+    };
+  }
+  const exports = yield* getExportsForFile.call(this, analysisServices, targetResolved);
+  return {
+    candidates: exports.filter(exported => exported !== 'default').map(exported => ({
+      binding: {
+        kind: 'named',
+        imported: exported,
+        source: targetResolved
+      },
+      exported
+    })),
+    complete: true
+  };
+}
+function* getExportsForFile(services, filename) {
+  const entrypoint = createAnalysisEntrypoint(services, filename);
+  return yield* this.getNext('getExports', entrypoint, undefined, null);
+}
+function* getOrBuildBarrelManifest(analysisServices, filename, stack = new Set()) {
+  const cached = this.services.cache.get('barrelManifests', filename);
+  if (cached) {
+    this.services.eventEmitter.single({
+      file: filename,
+      kind: 'barrelManifest',
+      status: 'hit'
+    });
+    return cached;
+  }
+  const loadedAndParsed = analysisServices.loadAndParseFn(analysisServices, filename, undefined, analysisServices.log);
+  if (loadedAndParsed.evaluator === 'ignored') {
+    const ignoredEntry = {
+      kind: 'ineligible',
+      reason: 'ignored'
+    };
+    this.services.cache.add('barrelManifests', filename, ignoredEntry);
+    return ignoredEntry;
+  }
+  if (loadedAndParsed.evaluator !== shaker) {
+    const customEntry = {
+      kind: 'ineligible',
+      reason: 'custom-evaluator'
+    };
+    this.services.cache.add('barrelManifests', filename, customEntry);
+    return customEntry;
+  }
+  const analyzed = analyzeBarrelFile(loadedAndParsed.ast);
+  if (!isRawBarrelManifest(analyzed)) {
+    this.services.cache.add('barrelManifests', filename, analyzed);
+    return analyzed;
+  }
+  const resolveEntrypoint = createAnalysisEntrypoint(analysisServices, filename, loadedAndParsed.code);
+  const resolvedImports = yield* this.getNext('resolveImports', resolveEntrypoint, {
+    imports: buildImportsForResolve(analyzed)
+  }, null);
+  const manifestDependencies = resolvedImports.flatMap(dependency => dependency.resolved ? [dependency.resolved] : []);
+  const resolutionMap = getReexportResolutionMap(resolvedImports);
+  const manifest = {
+    complete: analyzed.complete,
+    exports: {},
+    kind: 'barrel'
+  };
+  const explicitExports = new Set(analyzed.explicitExports);
+  const nextStack = new Set(stack);
+  nextStack.add(filename);
+  for (const reexport of analyzed.reexports) {
+    explicitExports.add(reexport.exported);
+    const targetResolved = resolutionMap.get(reexport.source);
+    if (!targetResolved) {
+      manifest.complete = false;
+      addBlockedExport(manifest.exports, reexport.exported, 'unresolved');
+      continue;
+    }
+    if (reexport.kind === 'namespace') {
+      const namespaceBinding = yield* getNamespaceBinding.call(this, analysisServices, targetResolved, nextStack);
+      manifest.exports[reexport.exported] = namespaceBinding;
+      if (namespaceBinding.kind === 'blocked') {
+        manifest.complete = false;
+      }
+      continue;
+    }
+    const binding = yield* getNamedBinding.call(this, analysisServices, targetResolved, reexport.imported, nextStack);
+    manifest.exports[reexport.exported] = binding;
+    if (binding.kind === 'blocked') {
+      manifest.complete = false;
+    }
+  }
+  for (const exportAllSource of analyzed.exportAll) {
+    const targetResolved = resolutionMap.get(exportAllSource);
+    if (!targetResolved) {
+      manifest.complete = false;
+      continue;
+    }
+    const {
+      candidates,
+      complete
+    } = yield* getStarCandidates.call(this, analysisServices, targetResolved, nextStack);
+    if (!complete) {
+      manifest.complete = false;
+      continue;
+    }
+    for (const candidate of candidates) {
+      addBinding(manifest.exports, candidate.exported, candidate.binding, explicitExports);
+    }
+  }
+  this.services.cache.add('barrelManifests', filename, manifest);
+  this.services.cache.setCacheDependencies('barrelManifests', filename, manifestDependencies);
+  this.services.eventEmitter.single({
+    complete: manifest.complete,
+    file: filename,
+    kind: 'barrelManifest',
+    status: 'built'
+  });
+  return manifest;
+}
+function* getNamespaceBinding(analysisServices, targetResolved, stack) {
+  if (stack.has(targetResolved)) {
+    return {
+      kind: 'blocked',
+      reason: 'cycle'
+    };
+  }
+  const targetManifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, targetResolved, stack);
+  if (isBarrelEntry(targetManifest)) {
+    return {
+      kind: 'blocked',
+      reason: 'namespace-barrel'
+    };
+  }
+  return {
+    kind: 'namespace',
+    source: targetResolved
+  };
+}
+function getResolvedDependency(dependencies, source) {
+  return dependencies.get(source);
+}
+function* rewriteImportDeclaration(analysisServices, statement, dependencies) {
+  const dependency = getResolvedDependency(dependencies, statement.source.value);
+  if (!dependency?.resolved) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+  if (!isBarrelEntry(manifest)) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const optimized = [];
+  const fallback = [];
+  for (const specifier of statement.specifiers) {
+    if (t.isImportNamespaceSpecifier(specifier)) {
+      fallback.push(specifier);
+      continue;
+    }
+    if (t.isImportDefaultSpecifier(specifier)) {
+      const binding = getManifestExport(manifest, 'default');
+      if (binding?.kind === 'named' && binding.imported === 'default') {
+        optimized.push({
+          kind: 'default',
+          local: specifier.local,
+          source: binding.source
+        });
+        continue;
+      }
+      if (binding?.kind === 'blocked') {
+        emitRewriteSkipped(this, statement.source.value, binding.reason);
+      }
+      fallback.push(specifier);
+      continue;
+    }
+    const imported = t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+    const binding = getManifestExport(manifest, imported);
+    if (binding?.kind === 'named') {
+      optimized.push({
+        imported: binding.imported,
+        kind: 'named',
+        local: specifier.local,
+        source: binding.source
+      });
+      continue;
+    }
+    if (binding?.kind === 'blocked') {
+      emitRewriteSkipped(this, statement.source.value, binding.reason);
+    }
+    fallback.push(specifier);
+  }
+  if (optimized.length === 0) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const rewritten = groupImportSpecifiers(optimized);
+  const fallbackDeclaration = createImportFallback(statement, fallback);
+  const mode = fallbackDeclaration ? 'partial' : 'full';
+  this.services.eventEmitter.single({
+    file: this.entrypoint.name,
+    kind: 'barrelRewrite',
+    mode,
+    optimized: optimized.length,
+    source: statement.source.value
+  });
+  return {
+    generatedSources: Array.from(new Set(optimized.map(specifier => specifier.source))),
+    mode,
+    statements: fallbackDeclaration ? [fallbackDeclaration, ...rewritten] : rewritten
+  };
+}
+function* rewriteExportNamedDeclaration(analysisServices, statement, dependencies) {
+  if (!statement.source || !t.isStringLiteral(statement.source)) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const dependency = getResolvedDependency(dependencies, statement.source.value);
+  if (!dependency?.resolved) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+  if (!isBarrelEntry(manifest)) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const optimized = [];
+  const fallback = [];
+  for (const specifier of statement.specifiers) {
+    if (t.isExportNamespaceSpecifier(specifier)) {
+      fallback.push(specifier);
+      continue;
+    }
+    if (t.isExportDefaultSpecifier(specifier)) {
+      const binding = getManifestExport(manifest, 'default');
+      if (binding?.kind === 'named' && binding.imported === 'default') {
+        optimized.push({
+          exported: getModuleName(specifier.exported),
+          imported: 'default',
+          kind: 'named',
+          source: binding.source
+        });
+        continue;
+      }
+      if (binding?.kind === 'blocked') {
+        emitRewriteSkipped(this, statement.source.value, binding.reason);
+      }
+      fallback.push(specifier);
+      continue;
+    }
+    const imported = getModuleName(specifier.local);
+    const exported = getModuleName(specifier.exported);
+    const binding = getManifestExport(manifest, imported);
+    if (binding?.kind === 'named' && canEmitNamedReexport(binding.imported)) {
+      optimized.push({
+        exported,
+        imported: binding.imported,
+        kind: 'named',
+        source: binding.source
+      });
+      continue;
+    }
+    if (binding?.kind === 'namespace' && t.isValidIdentifier(exported)) {
+      optimized.push({
+        exported,
+        kind: 'namespace',
+        source: binding.source
+      });
+      continue;
+    }
+    if (binding?.kind === 'blocked') {
+      emitRewriteSkipped(this, statement.source.value, binding.reason);
+    }
+    fallback.push(specifier);
+  }
+  if (optimized.length === 0) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const rewritten = groupExportSpecifiers(optimized);
+  const fallbackDeclaration = createExportFallback(statement, fallback);
+  const mode = fallbackDeclaration ? 'partial' : 'full';
+  this.services.eventEmitter.single({
+    file: this.entrypoint.name,
+    kind: 'barrelRewrite',
+    mode,
+    optimized: optimized.length,
+    source: statement.source.value
+  });
+  return {
+    generatedSources: Array.from(new Set(optimized.map(specifier => specifier.source))),
+    mode,
+    statements: fallbackDeclaration ? [fallbackDeclaration, ...rewritten] : rewritten
+  };
+}
+function* rewriteExportAllDeclaration(analysisServices, statement, dependencies) {
+  const dependency = getResolvedDependency(dependencies, statement.source.value);
+  if (!dependency?.resolved) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const manifest = yield* getOrBuildBarrelManifest.call(this, analysisServices, dependency.resolved);
+  if (!isBarrelEntry(manifest) || !manifest.complete) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  const optimized = [];
+  let hasUnrewritableExport = false;
+  for (const [exported, binding] of Object.entries(manifest.exports)) {
+    if (exported === 'default' || binding.kind === 'blocked') {
+      continue;
+    }
+    if (binding.kind === 'namespace') {
+      if (!t.isValidIdentifier(exported)) {
+        emitRewriteSkipped(this, statement.source.value, 'namespace-barrel');
+        hasUnrewritableExport = true;
+        continue;
+      }
+      optimized.push({
+        exported,
+        kind: 'namespace',
+        source: binding.source
+      });
+      continue;
+    }
+    if (!canEmitNamedReexport(binding.imported)) {
+      emitRewriteSkipped(this, statement.source.value, 'unknown-star');
+      hasUnrewritableExport = true;
+      continue;
+    }
+    optimized.push({
+      exported,
+      imported: binding.imported,
+      kind: 'named',
+      source: binding.source
+    });
+  }
+  if (hasUnrewritableExport) {
+    return {
+      generatedSources: [],
+      mode: 'unchanged',
+      statements: [statement]
+    };
+  }
+  if (optimized.length === 0) {
+    this.services.eventEmitter.single({
+      file: this.entrypoint.name,
+      kind: 'barrelRewrite',
+      mode: 'full',
+      optimized: 0,
+      source: statement.source.value
+    });
+    return {
+      generatedSources: [],
+      mode: 'full',
+      statements: []
+    };
+  }
+  this.services.eventEmitter.single({
+    complete: true,
+    file: this.entrypoint.name,
+    kind: 'barrelRewrite',
+    mode: 'full',
+    optimized: optimized.length,
+    source: statement.source.value
+  });
+  return {
+    generatedSources: Array.from(new Set(optimized.map(specifier => specifier.source))),
+    mode: 'full',
+    statements: groupExportSpecifiers(optimized)
+  };
+}
+export function* rewriteOptimizedBarrelImports(ast, code, resolvedImports) {
+  const dependencies = buildResolvedDependencyMap(resolvedImports);
+  const analysisServices = createAnalysisServices(this.services);
+  const nextBody = [];
+  const generatedSources = new Set();
+  let optimizedCount = 0;
+  const sourceModes = new Map();
+  let skippedCount = 0;
+  const recordSourceMode = (source, mode, statementChanged) => {
+    if (mode === 'unchanged') {
+      return;
+    }
+    if (statementChanged) {
+      optimizedCount += 1;
+    }
+    if (mode === 'partial') {
+      sourceModes.set(source, 'partial');
+      return;
+    }
+    if (!sourceModes.has(source)) {
+      sourceModes.set(source, 'full');
+    }
+  };
+  for (const statement of ast.program.body) {
+    if (t.isImportDeclaration(statement) && t.isStringLiteral(statement.source)) {
+      const rewritten = yield* rewriteImportDeclaration.call(this, analysisServices, statement, dependencies);
+      recordSourceMode(statement.source.value, rewritten.mode, !(rewritten.statements.length === 1 && rewritten.statements[0] === statement));
+      for (const source of rewritten.generatedSources) {
+        generatedSources.add(source);
+      }
+      nextBody.push(...rewritten.statements);
+      continue;
+    }
+    if (t.isExportNamedDeclaration(statement) && statement.source && t.isStringLiteral(statement.source)) {
+      const rewritten = yield* rewriteExportNamedDeclaration.call(this, analysisServices, statement, dependencies);
+      recordSourceMode(statement.source.value, rewritten.mode, !(rewritten.statements.length === 1 && rewritten.statements[0] === statement));
+      for (const source of rewritten.generatedSources) {
+        generatedSources.add(source);
+      }
+      nextBody.push(...rewritten.statements);
+      continue;
+    }
+    if (t.isExportAllDeclaration(statement) && statement.source && t.isStringLiteral(statement.source)) {
+      const rewritten = yield* rewriteExportAllDeclaration.call(this, analysisServices, statement, dependencies);
+      if (rewritten.mode === 'unchanged' && rewritten.statements.length === 1 && rewritten.statements[0] === statement) {
+        skippedCount += 1;
+      }
+      recordSourceMode(statement.source.value, rewritten.mode, !(rewritten.statements.length === 1 && rewritten.statements[0] === statement));
+      for (const source of rewritten.generatedSources) {
+        generatedSources.add(source);
+      }
+      nextBody.push(...rewritten.statements);
+      continue;
+    }
+    nextBody.push(statement);
+  }
+  ast.program.body = nextBody;
+  const rewrittenCode = generate(ast).code;
+  const imports = collectOptimizedImports(ast);
+  const preResolvedImports = Array.from(imports.entries()).flatMap(([source, only]) => {
+    const dependency = dependencies.get(source);
+    if (dependency) {
+      return [{
+        ...dependency,
+        only
+      }];
+    }
+    if (generatedSources.has(source)) {
+      return [{
+        only,
+        resolved: source,
+        source
+      }];
+    }
+    return [];
+  });
+  return {
+    ast,
+    code: rewrittenCode,
+    fullyRewrittenSources: Array.from(sourceModes.entries()).filter(([, mode]) => mode === 'full').map(([source]) => source),
+    imports,
+    optimizedCount,
+    partialFallbackSources: Array.from(sourceModes.entries()).filter(([, mode]) => mode === 'partial').map(([source]) => source),
+    preResolvedImports,
+    skippedCount
+  };
+}
+//# sourceMappingURL=rewriteBarrelImports.js.map