@atlaspack/core 2.12.1-canary.3354

package/src/public/Environment.js

@@ -0,0 +1,316 @@
+// @flow strict-local
+import type {
+  Environment as IEnvironment,
+  EnvironmentContext,
+  EnvironmentFeature,
+  Engines,
+  OutputFormat,
+  PackageName,
+  VersionMap,
+  SourceLocation,
+  SourceType,
+  TargetSourceMapOptions,
+} from '@atlaspack/types';
+import type {
+  Environment as InternalEnvironment,
+  AtlaspackOptions,
+} from '../types';
+import nullthrows from 'nullthrows';
+import browserslist from 'browserslist';
+import semver from 'semver';
+import {fromInternalSourceLocation} from '../utils';
+
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+
+export const BROWSER_ENVS: Set<string> = new Set<string>([
+  'browser',
+  'web-worker',
+  'service-worker',
+  'worklet',
+  'electron-renderer',
+]);
+const ELECTRON_ENVS = new Set(['electron-main', 'electron-renderer']);
+const NODE_ENVS = new Set(['node', ...ELECTRON_ENVS]);
+const WORKER_ENVS = new Set(['web-worker', 'service-worker']);
+export const ISOLATED_ENVS: Set<string> = new Set([...WORKER_ENVS, 'worklet']);
+
+const ALL_BROWSERS = [
+  'chrome',
+  'and_chr',
+  'edge',
+  'firefox',
+  'and_ff',
+  'safari',
+  'ios',
+  'samsung',
+  'opera',
+  'ie',
+  'op_mini',
+  'blackberry',
+  'op_mob',
+  'ie_mob',
+  'and_uc',
+  'and_qq',
+  'baidu',
+  'kaios',
+];
+
+// See require("caniuse-api").getSupport(<feature name>)
+const supportData = {
+  esmodules: {
+    edge: '16',
+    firefox: '60',
+    chrome: '61',
+    safari: '10.1',
+    opera: '48',
+    ios: '10.3',
+    android: '76',
+    and_chr: '76',
+    and_ff: '68',
+    samsung: '8.2',
+    and_qq: '10.4',
+    op_mob: '64',
+  },
+  'dynamic-import': {
+    edge: '76',
+    firefox: '67',
+    chrome: '63',
+    safari: '11.1',
+    opera: '50',
+    ios: '11.3',
+    android: '63',
+    and_chr: '63',
+    and_ff: '67',
+    samsung: '8',
+    and_qq: '10.4',
+    op_mob: '64',
+  },
+  'worker-module': {
+    edge: '80',
+    chrome: '80',
+    opera: '67',
+    android: '81',
+    and_chr: '86',
+  },
+  'service-worker-module': {
+    // TODO: Safari 14.1??
+  },
+  'import-meta-url': {
+    edge: '79',
+    firefox: '62',
+    chrome: '64',
+    safari: '11.1',
+    opera: '51',
+    ios: '12',
+    android: '64',
+    and_chr: '64',
+    and_ff: '62',
+    samsung: '9.2',
+    and_qq: '10.4',
+    op_mob: '64',
+  },
+  'arrow-functions': {
+    chrome: '47',
+    opera: '34',
+    edge: '13',
+    firefox: '45',
+    safari: '10',
+    node: '6',
+    ios: '10',
+    samsung: '5',
+    electron: '0.36',
+    android: '50',
+    qq: '10.4',
+    baidu: '7.12',
+    kaios: '2.5',
+    and_chr: '50',
+    and_qq: '12.12',
+    op_mob: '64',
+  },
+  'global-this': {
+    chrome: '75',
+    edge: '79',
+    safari: '12.1',
+    firefox: '65',
+    opera: '58',
+    node: '12',
+    and_chr: '71',
+    ios: '12.2',
+    android: '71',
+    samsung: '10.1',
+  },
+};
+
+const internalEnvironmentToEnvironment: WeakMap<
+  InternalEnvironment,
+  Environment,
+> = new WeakMap();
+const _environmentToInternalEnvironment: WeakMap<
+  IEnvironment,
+  InternalEnvironment,
+> = new WeakMap();
+export function environmentToInternalEnvironment(
+  environment: IEnvironment,
+): InternalEnvironment {
+  return nullthrows(_environmentToInternalEnvironment.get(environment));
+}
+
+export default class Environment implements IEnvironment {
+  #environment /*: InternalEnvironment */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(
+    env: InternalEnvironment,
+    options: AtlaspackOptions,
+  ): Environment {
+    let existing = internalEnvironmentToEnvironment.get(env);
+    if (existing != null) {
+      return existing;
+    }
+
+    this.#environment = env;
+    this.#options = options;
+    _environmentToInternalEnvironment.set(this, env);
+    internalEnvironmentToEnvironment.set(env, this);
+    return this;
+  }
+
+  get id(): string {
+    return this.#environment.id;
+  }
+
+  get context(): EnvironmentContext {
+    return this.#environment.context;
+  }
+
+  get engines(): Engines {
+    return this.#environment.engines;
+  }
+
+  get includeNodeModules():
+    | boolean
+    | Array<PackageName>
+    | {[PackageName]: boolean, ...} {
+    return this.#environment.includeNodeModules;
+  }
+
+  get outputFormat(): OutputFormat {
+    return this.#environment.outputFormat;
+  }
+
+  get sourceType(): SourceType {
+    return this.#environment.sourceType;
+  }
+
+  get isLibrary(): boolean {
+    return this.#environment.isLibrary;
+  }
+
+  get shouldOptimize(): boolean {
+    return this.#environment.shouldOptimize;
+  }
+
+  get shouldScopeHoist(): boolean {
+    return this.#environment.shouldScopeHoist;
+  }
+
+  get sourceMap(): ?TargetSourceMapOptions {
+    return this.#environment.sourceMap;
+  }
+
+  get loc(): ?SourceLocation {
+    return fromInternalSourceLocation(
+      this.#options.projectRoot,
+      this.#environment.loc,
+    );
+  }
+
+  // $FlowFixMe[unsupported-syntax]
+  [inspect](): string {
+    return `Env(${this.#environment.context})`;
+  }
+
+  isBrowser(): boolean {
+    return BROWSER_ENVS.has(this.#environment.context);
+  }
+
+  isNode(): boolean {
+    return NODE_ENVS.has(this.#environment.context);
+  }
+
+  isElectron(): boolean {
+    return ELECTRON_ENVS.has(this.#environment.context);
+  }
+
+  isIsolated(): boolean {
+    return ISOLATED_ENVS.has(this.#environment.context);
+  }
+
+  isWorker(): boolean {
+    return WORKER_ENVS.has(this.#environment.context);
+  }
+
+  isWorklet(): boolean {
+    return this.#environment.context === 'worklet';
+  }
+
+  matchesEngines(
+    minVersions: VersionMap,
+    defaultValue?: boolean = false,
+  ): boolean {
+    // Determine if the environment matches some minimum version requirements.
+    // For browsers, we run a browserslist query with and without the minimum
+    // required browsers and compare the lists. For node, we just check semver.
+    if (this.isBrowser() && this.engines.browsers != null) {
+      let targetBrowsers = this.engines.browsers;
+      let browsers =
+        targetBrowsers != null && !Array.isArray(targetBrowsers)
+          ? [targetBrowsers]
+          : targetBrowsers;
+
+      // If outputting esmodules, exclude browsers without support.
+      if (this.outputFormat === 'esmodule') {
+        browsers = [...browsers, ...getExcludedBrowsers(supportData.esmodules)];
+      }
+
+      let matchedBrowsers = browserslist(browsers);
+      if (matchedBrowsers.length === 0) {
+        return false;
+      }
+
+      let minBrowsers = getExcludedBrowsers(minVersions);
+      let withoutMinBrowsers = browserslist([...browsers, ...minBrowsers]);
+      return matchedBrowsers.length === withoutMinBrowsers.length;
+    } else if (this.isNode() && this.engines.node != null) {
+      return (
+        minVersions.node != null &&
+        !semver.intersects(`< ${minVersions.node}`, this.engines.node)
+      );
+    }
+
+    return defaultValue;
+  }
+
+  supports(feature: EnvironmentFeature, defaultValue?: boolean): boolean {
+    let engines = supportData[feature];
+    if (!engines) {
+      throw new Error('Unknown environment feature: ' + feature);
+    }
+
+    return this.matchesEngines(engines, defaultValue);
+  }
+}
+
+function getExcludedBrowsers(minVersions: VersionMap) {
+  let browsers = [];
+  for (let browser of ALL_BROWSERS) {
+    let version = minVersions[browser];
+    if (version) {
+      browsers.push(`not ${browser} < ${version}`);
+    } else {
+      browsers.push(`not ${browser} > 0`);
+    }
+  }
+
+  return browsers;
+}

package/src/public/MutableBundleGraph.js

@@ -0,0 +1,320 @@
+// @flow strict-local
+
+import type {
+  Asset as IAsset,
+  Bundle as IBundle,
+  BundleGroup as IBundleGroup,
+  CreateBundleOpts,
+  Dependency as IDependency,
+  MutableBundleGraph as IMutableBundleGraph,
+  Target,
+} from '@atlaspack/types';
+import type {
+  AtlaspackOptions,
+  BundleGroup as InternalBundleGroup,
+  BundleNode,
+} from '../types';
+
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+import {hashString} from '@atlaspack/rust';
+import BundleGraph from './BundleGraph';
+import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
+import {Bundle, bundleToInternalBundle} from './Bundle';
+import {assetFromValue, assetToAssetValue} from './Asset';
+import {getBundleGroupId, getPublicId} from '../utils';
+import Dependency, {dependencyToInternalDependency} from './Dependency';
+import {environmentToInternalEnvironment} from './Environment';
+import {targetToInternalTarget} from './Target';
+import {HASH_REF_PREFIX} from '../constants';
+import {fromProjectPathRelative} from '../projectPath';
+import {BundleBehavior} from '../types';
+import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
+
+export default class MutableBundleGraph
+  extends BundleGraph<IBundle>
+  implements IMutableBundleGraph
+{
+  #graph /*: InternalBundleGraph */;
+  #options /*: AtlaspackOptions */;
+  #bundlePublicIds /*: Set<string> */ = new Set<string>();
+
+  constructor(graph: InternalBundleGraph, options: AtlaspackOptions) {
+    super(graph, Bundle.get.bind(Bundle), options);
+    this.#graph = graph;
+    this.#options = options;
+  }
+
+  addAssetToBundle(asset: IAsset, bundle: IBundle) {
+    this.#graph.addAssetToBundle(
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+    );
+  }
+
+  addAssetGraphToBundle(
+    asset: IAsset,
+    bundle: IBundle,
+    shouldSkipDependency?: IDependency => boolean,
+  ) {
+    this.#graph.addAssetGraphToBundle(
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+      shouldSkipDependency
+        ? d => shouldSkipDependency(new Dependency(d, this.#options))
+        : undefined,
+    );
+  }
+
+  addEntryToBundle(
+    asset: IAsset,
+    bundle: IBundle,
+    shouldSkipDependency?: IDependency => boolean,
+  ) {
+    this.#graph.addEntryToBundle(
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+      shouldSkipDependency
+        ? d => shouldSkipDependency(new Dependency(d, this.#options))
+        : undefined,
+    );
+  }
+
+  createBundleGroup(dependency: IDependency, target: Target): IBundleGroup {
+    let dependencyNode = this.#graph._graph.getNodeByContentKey(dependency.id);
+    if (!dependencyNode) {
+      throw new Error('Dependency not found');
+    }
+
+    invariant(dependencyNode.type === 'dependency');
+
+    let resolved = this.#graph.getResolvedAsset(
+      dependencyToInternalDependency(dependency),
+    );
+    if (!resolved) {
+      throw new Error(
+        'Dependency did not resolve to an asset ' + dependency.id,
+      );
+    }
+
+    let bundleGroup: InternalBundleGroup = {
+      target: targetToInternalTarget(target),
+      entryAssetId: resolved.id,
+    };
+
+    let bundleGroupKey = getBundleGroupId(bundleGroup);
+    let bundleGroupNodeId = this.#graph._graph.hasContentKey(bundleGroupKey)
+      ? this.#graph._graph.getNodeIdByContentKey(bundleGroupKey)
+      : this.#graph._graph.addNodeByContentKey(bundleGroupKey, {
+          id: bundleGroupKey,
+          type: 'bundle_group',
+          value: bundleGroup,
+        });
+
+    let dependencyNodeId = this.#graph._graph.getNodeIdByContentKey(
+      dependencyNode.id,
+    );
+    let resolvedNodeId = this.#graph._graph.getNodeIdByContentKey(resolved.id);
+    let assetNodes =
+      this.#graph._graph.getNodeIdsConnectedFrom(dependencyNodeId);
+    this.#graph._graph.addEdge(dependencyNodeId, bundleGroupNodeId);
+    this.#graph._graph.replaceNodeIdsConnectedTo(bundleGroupNodeId, assetNodes);
+    this.#graph._graph.addEdge(
+      dependencyNodeId,
+      resolvedNodeId,
+      bundleGraphEdgeTypes.references,
+    );
+    if (
+      // This check is needed for multiple targets, when we go over the same nodes twice
+      this.#graph._graph.hasEdge(
+        dependencyNodeId,
+        resolvedNodeId,
+        bundleGraphEdgeTypes.null,
+      )
+    ) {
+      //nullEdgeType
+      this.#graph._graph.removeEdge(dependencyNodeId, resolvedNodeId);
+    }
+
+    if (dependency.isEntry) {
+      this.#graph._graph.addEdge(
+        nullthrows(this.#graph._graph.rootNodeId),
+        bundleGroupNodeId,
+        bundleGraphEdgeTypes.bundle,
+      );
+    } else {
+      let inboundBundleNodeIds = this.#graph._graph.getNodeIdsConnectedTo(
+        dependencyNodeId,
+        bundleGraphEdgeTypes.contains,
+      );
+      for (let inboundBundleNodeId of inboundBundleNodeIds) {
+        invariant(
+          this.#graph._graph.getNode(inboundBundleNodeId)?.type === 'bundle',
+        );
+        this.#graph._graph.addEdge(
+          inboundBundleNodeId,
+          bundleGroupNodeId,
+          bundleGraphEdgeTypes.bundle,
+        );
+      }
+    }
+
+    return new BundleGroup(bundleGroup, this.#options);
+  }
+
+  removeBundleGroup(bundleGroup: IBundleGroup): void {
+    this.#graph.removeBundleGroup(
+      bundleGroupToInternalBundleGroup(bundleGroup),
+    );
+  }
+
+  internalizeAsyncDependency(bundle: IBundle, dependency: IDependency): void {
+    this.#graph.internalizeAsyncDependency(
+      bundleToInternalBundle(bundle),
+      dependencyToInternalDependency(dependency),
+    );
+  }
+
+  createBundle(opts: CreateBundleOpts): Bundle {
+    let entryAsset = opts.entryAsset
+      ? assetToAssetValue(opts.entryAsset)
+      : null;
+
+    let target = targetToInternalTarget(opts.target);
+    let bundleId = hashString(
+      'bundle:' +
+        (opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) +
+        fromProjectPathRelative(target.distDir) +
+        (opts.bundleBehavior ?? ''),
+    );
+
+    let existing = this.#graph._graph.getNodeByContentKey(bundleId);
+    if (existing != null) {
+      invariant(existing.type === 'bundle');
+      return Bundle.get(existing.value, this.#graph, this.#options);
+    }
+
+    let publicId = getPublicId(bundleId, existing =>
+      this.#bundlePublicIds.has(existing),
+    );
+    this.#bundlePublicIds.add(publicId);
+
+    let isPlaceholder = false;
+    if (entryAsset) {
+      let entryAssetNode = this.#graph._graph.getNodeByContentKey(
+        entryAsset.id,
+      );
+      invariant(entryAssetNode?.type === 'asset', 'Entry asset does not exist');
+      isPlaceholder = entryAssetNode.requested === false;
+    }
+
+    let bundleNode: BundleNode = {
+      type: 'bundle',
+      id: bundleId,
+      value: {
+        id: bundleId,
+        hashReference: this.#options.shouldContentHash
+          ? HASH_REF_PREFIX + bundleId
+          : bundleId.slice(-8),
+        type: opts.entryAsset ? opts.entryAsset.type : opts.type,
+        env: opts.env
+          ? environmentToInternalEnvironment(opts.env)
+          : nullthrows(entryAsset).env,
+        entryAssetIds: entryAsset ? [entryAsset.id] : [],
+        mainEntryId: entryAsset?.id,
+        pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
+        needsStableName: opts.needsStableName,
+        bundleBehavior:
+          opts.bundleBehavior != null
+            ? BundleBehavior[opts.bundleBehavior]
+            : null,
+        isSplittable: opts.entryAsset
+          ? opts.entryAsset.isBundleSplittable
+          : opts.isSplittable,
+        isPlaceholder,
+        target,
+        name: null,
+        displayName: null,
+        publicId,
+        manualSharedBundle: opts.manualSharedBundle,
+      },
+    };
+
+    let bundleNodeId = this.#graph._graph.addNodeByContentKey(
+      bundleId,
+      bundleNode,
+    );
+
+    if (opts.entryAsset) {
+      this.#graph._graph.addEdge(
+        bundleNodeId,
+        this.#graph._graph.getNodeIdByContentKey(opts.entryAsset.id),
+      );
+    }
+    return Bundle.get(bundleNode.value, this.#graph, this.#options);
+  }
+
+  addBundleToBundleGroup(bundle: IBundle, bundleGroup: IBundleGroup) {
+    this.#graph.addBundleToBundleGroup(
+      bundleToInternalBundle(bundle),
+      bundleGroupToInternalBundleGroup(bundleGroup),
+    );
+  }
+
+  createAssetReference(
+    dependency: IDependency,
+    asset: IAsset,
+    bundle: IBundle,
+  ): void {
+    return this.#graph.createAssetReference(
+      dependencyToInternalDependency(dependency),
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+    );
+  }
+
+  createBundleReference(from: IBundle, to: IBundle): void {
+    return this.#graph.createBundleReference(
+      bundleToInternalBundle(from),
+      bundleToInternalBundle(to),
+    );
+  }
+
+  getDependencyAssets(dependency: IDependency): Array<IAsset> {
+    return this.#graph
+      .getDependencyAssets(dependencyToInternalDependency(dependency))
+      .map(asset => assetFromValue(asset, this.#options));
+  }
+
+  getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup> {
+    return this.#graph
+      .getBundleGroupsContainingBundle(bundleToInternalBundle(bundle))
+      .map(bundleGroup => new BundleGroup(bundleGroup, this.#options));
+  }
+
+  getParentBundlesOfBundleGroup(bundleGroup: IBundleGroup): Array<IBundle> {
+    return this.#graph
+      .getParentBundlesOfBundleGroup(
+        bundleGroupToInternalBundleGroup(bundleGroup),
+      )
+      .map(bundle => Bundle.get(bundle, this.#graph, this.#options));
+  }
+
+  getTotalSize(asset: IAsset): number {
+    return this.#graph.getTotalSize(assetToAssetValue(asset));
+  }
+
+  isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean {
+    return this.#graph.isAssetReachableFromBundle(
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+    );
+  }
+
+  removeAssetGraphFromBundle(asset: IAsset, bundle: IBundle) {
+    this.#graph.removeAssetGraphFromBundle(
+      assetToAssetValue(asset),
+      bundleToInternalBundle(bundle),
+    );
+  }
+}