@atlaspack/core 2.12.1-canary.3354

package/src/public/Bundle.js

@@ -0,0 +1,337 @@
+// @flow strict-local
+
+import type {
+  Bundle as InternalBundle,
+  AtlaspackOptions,
+  PackagedBundleInfo,
+} from '../types';
+import type {
+  Asset as IAsset,
+  Bundle as IBundle,
+  BundleTraversable,
+  Dependency as IDependency,
+  Environment as IEnvironment,
+  GraphVisitor,
+  NamedBundle as INamedBundle,
+  PackagedBundle as IPackagedBundle,
+  Stats,
+  Target as ITarget,
+  BundleBehavior,
+} from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+import {DefaultWeakMap} from '@atlaspack/utils';
+
+import {assetToAssetValue, assetFromValue} from './Asset';
+import {mapVisitor} from '@atlaspack/graph';
+import Environment from './Environment';
+import {
+  dependencyToInternalDependency,
+  getPublicDependency,
+} from './Dependency';
+import Target from './Target';
+import {BundleBehaviorNames} from '../types';
+import {fromProjectPath} from '../projectPath';
+
+const internalBundleToBundle: DefaultWeakMap<
+  AtlaspackOptions,
+  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, Bundle>>,
+> = new DefaultWeakMap(() => new DefaultWeakMap(() => new WeakMap()));
+const internalBundleToNamedBundle: DefaultWeakMap<
+  AtlaspackOptions,
+  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, NamedBundle>>,
+> = new DefaultWeakMap(() => new DefaultWeakMap(() => new WeakMap()));
+const internalBundleToPackagedBundle: DefaultWeakMap<
+  AtlaspackOptions,
+  DefaultWeakMap<BundleGraph, WeakMap<InternalBundle, PackagedBundle>>,
+> = new DefaultWeakMap(() => new DefaultWeakMap(() => new WeakMap()));
+
+// Friendly access for other modules within this package that need access
+// to the internal bundle.
+const _bundleToInternalBundle: WeakMap<IBundle, InternalBundle> = new WeakMap();
+export function bundleToInternalBundle(bundle: IBundle): InternalBundle {
+  return nullthrows(_bundleToInternalBundle.get(bundle));
+}
+const _bundleToInternalBundleGraph: WeakMap<IBundle, BundleGraph> =
+  new WeakMap();
+export function bundleToInternalBundleGraph(bundle: IBundle): BundleGraph {
+  return nullthrows(_bundleToInternalBundleGraph.get(bundle));
+}
+
+// Require this private object to be present when invoking these constructors,
+// preventing others from using them. They should use the static `get` method.
+let _private = {};
+
+export class Bundle implements IBundle {
+  #bundle /*: InternalBundle */;
+  #bundleGraph /*: BundleGraph */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(
+    sentinel: mixed,
+    bundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+  ) {
+    if (sentinel !== _private) {
+      throw new Error('Unexpected public usage');
+    }
+
+    this.#bundle = bundle;
+    this.#bundleGraph = bundleGraph;
+    this.#options = options;
+  }
+
+  static get(
+    internalBundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+  ): Bundle {
+    let existingMap = internalBundleToBundle.get(options).get(bundleGraph);
+    let existing = existingMap.get(internalBundle);
+    if (existing != null) {
+      return existing;
+    }
+
+    let bundle = new Bundle(_private, internalBundle, bundleGraph, options);
+    _bundleToInternalBundle.set(bundle, internalBundle);
+    _bundleToInternalBundleGraph.set(bundle, bundleGraph);
+    existingMap.set(internalBundle, bundle);
+
+    return bundle;
+  }
+
+  get id(): string {
+    return this.#bundle.id;
+  }
+
+  get hashReference(): string {
+    return this.#bundle.hashReference;
+  }
+
+  get type(): string {
+    return this.#bundle.type;
+  }
+
+  get env(): IEnvironment {
+    return new Environment(this.#bundle.env, this.#options);
+  }
+
+  get needsStableName(): ?boolean {
+    return this.#bundle.needsStableName;
+  }
+
+  get bundleBehavior(): ?BundleBehavior {
+    let bundleBehavior = this.#bundle.bundleBehavior;
+    return bundleBehavior != null ? BundleBehaviorNames[bundleBehavior] : null;
+  }
+
+  get isSplittable(): ?boolean {
+    return this.#bundle.isSplittable;
+  }
+
+  get manualSharedBundle(): ?string {
+    return this.#bundle.manualSharedBundle;
+  }
+
+  get target(): ITarget {
+    return new Target(this.#bundle.target, this.#options);
+  }
+
+  hasAsset(asset: IAsset): boolean {
+    return this.#bundleGraph.bundleHasAsset(
+      this.#bundle,
+      assetToAssetValue(asset),
+    );
+  }
+
+  hasDependency(dep: IDependency): boolean {
+    return this.#bundleGraph.bundleHasDependency(
+      this.#bundle,
+      dependencyToInternalDependency(dep),
+    );
+  }
+
+  getEntryAssets(): Array<IAsset> {
+    return this.#bundle.entryAssetIds.map(id => {
+      let assetNode = this.#bundleGraph._graph.getNodeByContentKey(id);
+      invariant(assetNode != null && assetNode.type === 'asset');
+      return assetFromValue(assetNode.value, this.#options);
+    });
+  }
+
+  getMainEntry(): ?IAsset {
+    if (this.#bundle.mainEntryId != null) {
+      let assetNode = this.#bundleGraph._graph.getNodeByContentKey(
+        this.#bundle.mainEntryId,
+      );
+      invariant(assetNode != null && assetNode.type === 'asset');
+      return assetFromValue(assetNode.value, this.#options);
+    }
+  }
+
+  traverse<TContext>(
+    visit: GraphVisitor<BundleTraversable, TContext>,
+  ): ?TContext {
+    return this.#bundleGraph.traverseBundle(
+      this.#bundle,
+      mapVisitor(node => {
+        if (node.type === 'asset') {
+          return {
+            type: 'asset',
+            value: assetFromValue(node.value, this.#options),
+          };
+        } else if (node.type === 'dependency') {
+          return {
+            type: 'dependency',
+            value: getPublicDependency(node.value, this.#options),
+          };
+        }
+      }, visit),
+    );
+  }
+
+  traverseAssets<TContext>(
+    visit: GraphVisitor<IAsset, TContext>,
+    startAsset?: IAsset,
+  ): ?TContext {
+    return this.#bundleGraph.traverseAssets(
+      this.#bundle,
+      mapVisitor(asset => assetFromValue(asset, this.#options), visit),
+      startAsset ? assetToAssetValue(startAsset) : undefined,
+    );
+  }
+}
+
+export class NamedBundle extends Bundle implements INamedBundle {
+  #bundle /*: InternalBundle */;
+  #bundleGraph /*: BundleGraph */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(
+    sentinel: mixed,
+    bundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+  ) {
+    super(sentinel, bundle, bundleGraph, options);
+    this.#bundle = bundle; // Repeating for flow
+    this.#bundleGraph = bundleGraph; // Repeating for flow
+    this.#options = options;
+  }
+
+  static get(
+    internalBundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+  ): NamedBundle {
+    let existingMap = internalBundleToNamedBundle.get(options).get(bundleGraph);
+    let existing = existingMap.get(internalBundle);
+    if (existing != null) {
+      return existing;
+    }
+
+    let namedBundle = new NamedBundle(
+      _private,
+      internalBundle,
+      bundleGraph,
+      options,
+    );
+    _bundleToInternalBundle.set(namedBundle, internalBundle);
+    _bundleToInternalBundleGraph.set(namedBundle, bundleGraph);
+    existingMap.set(internalBundle, namedBundle);
+
+    return namedBundle;
+  }
+
+  get name(): string {
+    return nullthrows(this.#bundle.name);
+  }
+
+  get displayName(): string {
+    return nullthrows(this.#bundle.displayName);
+  }
+
+  get publicId(): string {
+    return nullthrows(this.#bundle.publicId);
+  }
+}
+
+export class PackagedBundle extends NamedBundle implements IPackagedBundle {
+  #bundle /*: InternalBundle */;
+  #bundleGraph /*: BundleGraph */;
+  #options /*: AtlaspackOptions */;
+  #bundleInfo /*: ?PackagedBundleInfo */;
+
+  constructor(
+    sentinel: mixed,
+    bundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+  ) {
+    super(sentinel, bundle, bundleGraph, options);
+    this.#bundle = bundle; // Repeating for flow
+    this.#bundleGraph = bundleGraph; // Repeating for flow
+    this.#options = options; // Repeating for flow
+  }
+
+  static get(
+    internalBundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+  ): PackagedBundle {
+    let existingMap = internalBundleToPackagedBundle
+      .get(options)
+      .get(bundleGraph);
+    let existing = existingMap.get(internalBundle);
+    if (existing != null) {
+      return existing;
+    }
+
+    let packagedBundle = new PackagedBundle(
+      _private,
+      internalBundle,
+      bundleGraph,
+      options,
+    );
+    _bundleToInternalBundle.set(packagedBundle, internalBundle);
+    _bundleToInternalBundleGraph.set(packagedBundle, bundleGraph);
+    existingMap.set(internalBundle, packagedBundle);
+
+    return packagedBundle;
+  }
+
+  static getWithInfo(
+    internalBundle: InternalBundle,
+    bundleGraph: BundleGraph,
+    options: AtlaspackOptions,
+    bundleInfo: ?PackagedBundleInfo,
+  ): PackagedBundle {
+    let packagedBundle = PackagedBundle.get(
+      internalBundle,
+      bundleGraph,
+      options,
+    );
+    packagedBundle.#bundleInfo = bundleInfo;
+    return packagedBundle;
+  }
+
+  get filePath(): string {
+    return fromProjectPath(
+      this.#options.projectRoot,
+      nullthrows(this.#bundleInfo).filePath,
+    );
+  }
+
+  get type(): string {
+    // The bundle type may be overridden in the packager.
+    // However, inline bundles will not have a bundleInfo here since they are not written to the filesystem.
+    return this.#bundleInfo ? this.#bundleInfo.type : this.#bundle.type;
+  }
+
+  get stats(): Stats {
+    return nullthrows(this.#bundleInfo).stats;
+  }
+}

package/src/public/BundleGraph.js

@@ -0,0 +1,335 @@
+// @flow strict-local
+
+import type {
+  Asset as IAsset,
+  Bundle as IBundle,
+  BundleGraph as IBundleGraph,
+  BundleGraphTraversable,
+  BundleGroup as IBundleGroup,
+  Dependency as IDependency,
+  ExportSymbolResolution,
+  FilePath,
+  GraphVisitor,
+  Symbol,
+  SymbolResolution,
+  Target,
+} from '@atlaspack/types';
+import type {Bundle as InternalBundle, AtlaspackOptions} from '../types';
+import type InternalBundleGraph from '../BundleGraph';
+
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+
+import {mapVisitor} from '@atlaspack/graph';
+import {assetFromValue, assetToAssetValue, Asset} from './Asset';
+import {bundleToInternalBundle} from './Bundle';
+import Dependency, {
+  dependencyToInternalDependency,
+  getPublicDependency,
+} from './Dependency';
+import {targetToInternalTarget} from './Target';
+import {fromInternalSourceLocation} from '../utils';
+import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
+
+// Friendly access for other modules within this package that need access
+// to the internal bundle.
+const _bundleGraphToInternalBundleGraph: WeakMap<
+  IBundleGraph<IBundle>,
+  InternalBundleGraph,
+> = new WeakMap();
+export function bundleGraphToInternalBundleGraph(
+  bundleGraph: IBundleGraph<IBundle>,
+): InternalBundleGraph {
+  return nullthrows(_bundleGraphToInternalBundleGraph.get(bundleGraph));
+}
+
+type BundleFactory<TBundle: IBundle> = (
+  InternalBundle,
+  InternalBundleGraph,
+  AtlaspackOptions,
+) => TBundle;
+
+export default class BundleGraph<TBundle: IBundle>
+  implements IBundleGraph<TBundle>
+{
+  #graph: InternalBundleGraph;
+  #options: AtlaspackOptions;
+  #createBundle: BundleFactory<TBundle>;
+
+  constructor(
+    graph: InternalBundleGraph,
+    createBundle: BundleFactory<TBundle>,
+    options: AtlaspackOptions,
+  ) {
+    this.#graph = graph;
+    this.#options = options;
+    this.#createBundle = createBundle;
+    // $FlowFixMe
+    _bundleGraphToInternalBundleGraph.set(this, graph);
+  }
+
+  getAssetById(id: string): Asset {
+    return assetFromValue(this.#graph.getAssetById(id), this.#options);
+  }
+
+  getAssetPublicId(asset: IAsset): string {
+    return this.#graph.getAssetPublicId(assetToAssetValue(asset));
+  }
+
+  isDependencySkipped(dep: IDependency): boolean {
+    return this.#graph.isDependencySkipped(dependencyToInternalDependency(dep));
+  }
+
+  getResolvedAsset(dep: IDependency, bundle: ?IBundle): ?IAsset {
+    let resolution = this.#graph.getResolvedAsset(
+      dependencyToInternalDependency(dep),
+      bundle && bundleToInternalBundle(bundle),
+    );
+    if (resolution) {
+      return assetFromValue(resolution, this.#options);
+    }
+  }
+
+  getIncomingDependencies(asset: IAsset): Array<IDependency> {
+    return this.#graph
+      .getIncomingDependencies(assetToAssetValue(asset))
+      .map(dep => getPublicDependency(dep, this.#options));
+  }
+
+  getAssetWithDependency(dep: IDependency): ?IAsset {
+    let asset = this.#graph.getAssetWithDependency(
+      dependencyToInternalDependency(dep),
+    );
+    if (asset) {
+      return assetFromValue(asset, this.#options);
+    }
+  }
+
+  getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup> {
+    return this.#graph
+      .getBundleGroupsContainingBundle(bundleToInternalBundle(bundle))
+      .map(bundleGroup => new BundleGroup(bundleGroup, this.#options));
+  }
+
+  getReferencedBundles(
+    bundle: IBundle,
+    opts?: {|recursive?: boolean, includeInline?: boolean|},
+  ): Array<TBundle> {
+    return this.#graph
+      .getReferencedBundles(bundleToInternalBundle(bundle), opts)
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  getReferencingBundles(bundle: IBundle): Array<TBundle> {
+    return this.#graph
+      .getReferencingBundles(bundleToInternalBundle(bundle))
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  resolveAsyncDependency(
+    dependency: IDependency,
+    bundle: ?IBundle,
+  ): ?(
+    | {|type: 'bundle_group', value: IBundleGroup|}
+    | {|type: 'asset', value: IAsset|}
+  ) {
+    let resolved = this.#graph.resolveAsyncDependency(
+      dependencyToInternalDependency(dependency),
+      bundle && bundleToInternalBundle(bundle),
+    );
+
+    if (resolved == null) {
+      return;
+    } else if (resolved.type === 'bundle_group') {
+      return {
+        type: 'bundle_group',
+        value: new BundleGroup(resolved.value, this.#options),
+      };
+    }
+
+    return {
+      type: 'asset',
+      value: assetFromValue(resolved.value, this.#options),
+    };
+  }
+
+  getReferencedBundle(dependency: IDependency, bundle: IBundle): ?TBundle {
+    let result = this.#graph.getReferencedBundle(
+      dependencyToInternalDependency(dependency),
+      bundleToInternalBundle(bundle),
+    );
+
+    if (result != null) {
+      return this.#createBundle(result, this.#graph, this.#options);
+    }
+  }
+
+  getDependencies(asset: IAsset): Array<IDependency> {
+    return this.#graph
+      .getDependencies(assetToAssetValue(asset))
+      .map(dep => getPublicDependency(dep, this.#options));
+  }
+
+  isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean {
+    return this.#graph.isAssetReachableFromBundle(
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+    );
+  }
+
+  isAssetReferenced(bundle: IBundle, asset: IAsset): boolean {
+    return this.#graph.isAssetReferenced(
+      bundleToInternalBundle(bundle),
+      assetToAssetValue(asset),
+    );
+  }
+
+  hasParentBundleOfType(bundle: IBundle, type: string): boolean {
+    return this.#graph.hasParentBundleOfType(
+      bundleToInternalBundle(bundle),
+      type,
+    );
+  }
+
+  getBundlesInBundleGroup(
+    bundleGroup: IBundleGroup,
+    opts?: {|includeInline: boolean|},
+  ): Array<TBundle> {
+    return this.#graph
+      .getBundlesInBundleGroup(
+        bundleGroupToInternalBundleGroup(bundleGroup),
+        opts,
+      )
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  getBundles(opts?: {|includeInline: boolean|}): Array<TBundle> {
+    return this.#graph
+      .getBundles(opts)
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  isEntryBundleGroup(bundleGroup: IBundleGroup): boolean {
+    return this.#graph.isEntryBundleGroup(
+      bundleGroupToInternalBundleGroup(bundleGroup),
+    );
+  }
+
+  getChildBundles(bundle: IBundle): Array<TBundle> {
+    return this.#graph
+      .getChildBundles(bundleToInternalBundle(bundle))
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  getParentBundles(bundle: IBundle): Array<TBundle> {
+    return this.#graph
+      .getParentBundles(bundleToInternalBundle(bundle))
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  getSymbolResolution(
+    asset: IAsset,
+    symbol: Symbol,
+    boundary: ?IBundle,
+  ): SymbolResolution {
+    let res = this.#graph.getSymbolResolution(
+      assetToAssetValue(asset),
+      symbol,
+      boundary ? bundleToInternalBundle(boundary) : null,
+    );
+    return {
+      asset: assetFromValue(res.asset, this.#options),
+      exportSymbol: res.exportSymbol,
+      symbol: res.symbol,
+      loc: fromInternalSourceLocation(this.#options.projectRoot, res.loc),
+    };
+  }
+
+  getExportedSymbols(
+    asset: IAsset,
+    boundary: ?IBundle,
+  ): Array<ExportSymbolResolution> {
+    let res = this.#graph.getExportedSymbols(
+      assetToAssetValue(asset),
+      boundary ? bundleToInternalBundle(boundary) : null,
+    );
+    return res.map(e => ({
+      asset: assetFromValue(e.asset, this.#options),
+      exportSymbol: e.exportSymbol,
+      symbol: e.symbol,
+      loc: fromInternalSourceLocation(this.#options.projectRoot, e.loc),
+      exportAs: e.exportAs,
+    }));
+  }
+
+  traverse<TContext>(
+    visit: GraphVisitor<BundleGraphTraversable, TContext>,
+    start?: ?IAsset,
+    opts?: ?{|skipUnusedDependencies?: boolean|},
+  ): ?TContext {
+    return this.#graph.traverse(
+      mapVisitor((node, actions) => {
+        // Skipping unused dependencies here is faster than doing an isDependencySkipped check inside the visitor
+        // because the node needs to be re-looked up by id from the hashmap.
+        if (
+          opts?.skipUnusedDependencies &&
+          node.type === 'dependency' &&
+          (node.hasDeferred || node.excluded)
+        ) {
+          actions.skipChildren();
+          return null;
+        }
+        return node.type === 'asset'
+          ? {type: 'asset', value: assetFromValue(node.value, this.#options)}
+          : {
+              type: 'dependency',
+              value: getPublicDependency(node.value, this.#options),
+            };
+      }, visit),
+      start ? assetToAssetValue(start) : undefined,
+    );
+  }
+
+  traverseBundles<TContext>(
+    visit: GraphVisitor<TBundle, TContext>,
+    startBundle: ?IBundle,
+  ): ?TContext {
+    return this.#graph.traverseBundles(
+      mapVisitor(
+        bundle => this.#createBundle(bundle, this.#graph, this.#options),
+        visit,
+      ),
+      startBundle == null ? undefined : bundleToInternalBundle(startBundle),
+    );
+  }
+
+  getBundlesWithAsset(asset: IAsset): Array<TBundle> {
+    return this.#graph
+      .getBundlesWithAsset(assetToAssetValue(asset))
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  getBundlesWithDependency(dependency: IDependency): Array<TBundle> {
+    return this.#graph
+      .getBundlesWithDependency(dependencyToInternalDependency(dependency))
+      .map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+
+  getUsedSymbols(v: IAsset | IDependency): ?$ReadOnlySet<Symbol> {
+    if (v instanceof Asset) {
+      return this.#graph.getUsedSymbolsAsset(assetToAssetValue(v));
+    } else {
+      invariant(v instanceof Dependency);
+      return this.#graph.getUsedSymbolsDependency(
+        dependencyToInternalDependency(v),
+      );
+    }
+  }
+
+  getEntryRoot(target: Target): FilePath {
+    return this.#graph.getEntryRoot(
+      this.#options.projectRoot,
+      targetToInternalTarget(target),
+    );
+  }
+}