@atlaspack/core 2.14.0 → 2.14.1-canary.6

package/lib/public/BundleGraph.js

@@ -0,0 +1,279 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bundleGraphToInternalBundleGraph = bundleGraphToInternalBundleGraph;
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+var _Asset = require("./Asset");
+var _Bundle = require("./Bundle");
+var _Dependency = _interopRequireWildcard(require("./Dependency"));
+var _Target = require("./Target");
+var _utils = require("../utils");
+var _BundleGroup = _interopRequireWildcard(require("./BundleGroup"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Friendly access for other modules within this package that need access
+// to the internal bundle.
+const _bundleGraphToInternalBundleGraph = new WeakMap();
+function bundleGraphToInternalBundleGraph(bundleGraph) {
+  return (0, _nullthrows().default)(_bundleGraphToInternalBundleGraph.get(bundleGraph));
+}
+class BundleGraph {
+  #graph;
+  #options;
+  #createBundle;
+  constructor(graph, createBundle, options) {
+    this.#graph = graph;
+    this.#options = options;
+    this.#createBundle = createBundle;
+    // $FlowFixMe
+    _bundleGraphToInternalBundleGraph.set(this, graph);
+  }
+  getAssetById(id) {
+    return (0, _Asset.assetFromValue)(this.#graph.getAssetById(id), this.#options);
+  }
+  getAssetPublicId(asset) {
+    return this.#graph.getAssetPublicId((0, _Asset.assetToAssetValue)(asset));
+  }
+  isDependencySkipped(dep) {
+    return this.#graph.isDependencySkipped((0, _Dependency.dependencyToInternalDependency)(dep));
+  }
+  getResolvedAsset(dep, bundle) {
+    let resolution = this.#graph.getResolvedAsset((0, _Dependency.dependencyToInternalDependency)(dep), bundle && (0, _Bundle.bundleToInternalBundle)(bundle));
+    if (resolution) {
+      return (0, _Asset.assetFromValue)(resolution, this.#options);
+    }
+  }
+  getIncomingDependencies(asset) {
+    return this.#graph.getIncomingDependencies((0, _Asset.assetToAssetValue)(asset)).map(dep => (0, _Dependency.getPublicDependency)(dep, this.#options));
+  }
+  getAssetWithDependency(dep) {
+    let asset = this.#graph.getAssetWithDependency((0, _Dependency.dependencyToInternalDependency)(dep));
+    if (asset) {
+      return (0, _Asset.assetFromValue)(asset, this.#options);
+    }
+  }
+  getBundleGroupsContainingBundle(bundle) {
+    return this.#graph.getBundleGroupsContainingBundle((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundleGroup => new _BundleGroup.default(bundleGroup, this.#options));
+  }
+  getReferencedBundles(bundle, opts) {
+    return this.#graph.getReferencedBundles((0, _Bundle.bundleToInternalBundle)(bundle), opts).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  getReferencingBundles(bundle) {
+    return this.#graph.getReferencingBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  resolveAsyncDependency(dependency, bundle) {
+    let resolved = this.#graph.resolveAsyncDependency((0, _Dependency.dependencyToInternalDependency)(dependency), bundle && (0, _Bundle.bundleToInternalBundle)(bundle));
+    if (resolved == null) {
+      return;
+    } else if (resolved.type === 'bundle_group') {
+      return {
+        type: 'bundle_group',
+        value: new _BundleGroup.default(resolved.value, this.#options)
+      };
+    }
+    return {
+      type: 'asset',
+      value: (0, _Asset.assetFromValue)(resolved.value, this.#options)
+    };
+  }
+  getReferencedBundle(dependency, bundle) {
+    let result = this.#graph.getReferencedBundle((0, _Dependency.dependencyToInternalDependency)(dependency), (0, _Bundle.bundleToInternalBundle)(bundle));
+    if (result != null) {
+      return this.#createBundle(result, this.#graph, this.#options);
+    }
+  }
+  getDependencies(asset) {
+    return this.#graph.getDependencies((0, _Asset.assetToAssetValue)(asset)).map(dep => (0, _Dependency.getPublicDependency)(dep, this.#options));
+  }
+  isAssetReachableFromBundle(asset, bundle) {
+    return this.#graph.isAssetReachableFromBundle((0, _Asset.assetToAssetValue)(asset), (0, _Bundle.bundleToInternalBundle)(bundle));
+  }
+  isAssetReferenced(bundle, asset) {
+    return this.#graph.isAssetReferenced((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
+  }
+  hasParentBundleOfType(bundle, type) {
+    return this.#graph.hasParentBundleOfType((0, _Bundle.bundleToInternalBundle)(bundle), type);
+  }
+  getBundlesInBundleGroup(bundleGroup, opts) {
+    return this.#graph.getBundlesInBundleGroup((0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup), opts).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  getBundles(opts) {
+    return this.#graph.getBundles(opts).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  isEntryBundleGroup(bundleGroup) {
+    return this.#graph.isEntryBundleGroup((0, _BundleGroup.bundleGroupToInternalBundleGroup)(bundleGroup));
+  }
+  getChildBundles(bundle) {
+    return this.#graph.getChildBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  getParentBundles(bundle) {
+    return this.#graph.getParentBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  getSymbolResolution(asset, symbol, boundary) {
+    let res = this.#graph.getSymbolResolution((0, _Asset.assetToAssetValue)(asset), symbol, boundary ? (0, _Bundle.bundleToInternalBundle)(boundary) : null);
+    return {
+      asset: (0, _Asset.assetFromValue)(res.asset, this.#options),
+      exportSymbol: res.exportSymbol,
+      symbol: res.symbol,
+      loc: (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, res.loc)
+    };
+  }
+  getExportedSymbols(asset, boundary) {
+    let res = this.#graph.getExportedSymbols((0, _Asset.assetToAssetValue)(asset), boundary ? (0, _Bundle.bundleToInternalBundle)(boundary) : null);
+    return res.map(e => ({
+      asset: (0, _Asset.assetFromValue)(e.asset, this.#options),
+      exportSymbol: e.exportSymbol,
+      symbol: e.symbol,
+      loc: (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, e.loc),
+      exportAs: e.exportAs
+    }));
+  }
+  traverse(visit, start, opts) {
+    return this.#graph.traverse((0, _graph().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 !== null && opts !== void 0 && opts.skipUnusedDependencies && node.type === 'dependency' && (node.hasDeferred || node.excluded)) {
+        actions.skipChildren();
+        return null;
+      }
+      return node.type === 'asset' ? {
+        type: 'asset',
+        value: (0, _Asset.assetFromValue)(node.value, this.#options)
+      } : {
+        type: 'dependency',
+        value: (0, _Dependency.getPublicDependency)(node.value, this.#options)
+      };
+    }, visit), start ? (0, _Asset.assetToAssetValue)(start) : undefined);
+  }
+  traverseBundles(visit, startBundle) {
+    return this.#graph.traverseBundles((0, _graph().mapVisitor)(bundle => this.#createBundle(bundle, this.#graph, this.#options), visit), startBundle == null ? undefined : (0, _Bundle.bundleToInternalBundle)(startBundle));
+  }
+  getBundlesWithAsset(asset) {
+    return this.#graph.getBundlesWithAsset((0, _Asset.assetToAssetValue)(asset)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  getBundlesWithDependency(dependency) {
+    return this.#graph.getBundlesWithDependency((0, _Dependency.dependencyToInternalDependency)(dependency)).map(bundle => this.#createBundle(bundle, this.#graph, this.#options));
+  }
+  getUsedSymbols(v) {
+    if (v instanceof _Asset.Asset) {
+      return this.#graph.getUsedSymbolsAsset((0, _Asset.assetToAssetValue)(v));
+    } else {
+      (0, _assert().default)(v instanceof _Dependency.default);
+      return this.#graph.getUsedSymbolsDependency((0, _Dependency.dependencyToInternalDependency)(v));
+    }
+  }
+  getEntryRoot(target) {
+    return this.#graph.getEntryRoot(this.#options.projectRoot, (0, _Target.targetToInternalTarget)(target));
+  }
+
+  // Given a set of dependencies, return any conditions where those dependencies are either
+  // the true or false dependency for those conditions. This is currently used to work out which
+  // conditions belong to a bundle in packaging.
+  getConditionsForDependencies(deps, bundle) {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (depIds.includes(condition.ifTrueDependency.id) || depIds.includes(condition.ifFalseDependency.id)) {
+        const [[trueAsset, ifTrueBundles], [falseAsset, ifFalseBundles]] = [condition.ifTrueDependency, condition.ifFalseDependency].map(dep => {
+          const asset = this.#graph.getResolvedAsset(dep, (0, _Bundle.bundleToInternalBundle)(bundle));
+          if (asset && this.#graph.bundleHasAsset((0, _Bundle.bundleToInternalBundle)(bundle), asset)) {
+            // Asset is in the same bundle, we know it doesn't need to be loaded externally
+            return [asset, []];
+          }
+          const resolvedAsync = this.#graph.resolveAsyncDependency(dep, (0, _Bundle.bundleToInternalBundle)(bundle));
+          if ((resolvedAsync === null || resolvedAsync === void 0 ? void 0 : resolvedAsync.type) === 'asset') {
+            // Single bundle to load dynamically
+            return [resolvedAsync.value, [this.#createBundle((0, _nullthrows().default)(this.#graph.getReferencedBundle(dep, (0, _Bundle.bundleToInternalBundle)(bundle)), `Failed to load referenced bundle for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`), this.#graph, this.#options)]];
+          } else if (resolvedAsync) {
+            // Bundle group means we have multiple bundles to load first
+            return [this.#graph.getAssetById(resolvedAsync.value.entryAssetId), this.#graph.getBundlesInBundleGroup(resolvedAsync.value).map(b => this.#createBundle(b, this.#graph, this.#options))];
+          } else {
+            return [(0, _nullthrows().default)(asset, `Failed to load depenendency for '${dep.specifier}' specifier from '${String(dep.sourcePath)}'`), []];
+          }
+        });
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
+          ifFalseDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
+          ifTrueBundles,
+          ifFalseBundles,
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset)
+        });
+      }
+    }
+    return conditions;
+  }
+
+  // This is used to generate information for building a manifest that can
+  // be used by a webserver to understand which conditions are used by which bundles,
+  // and which bundles those conditions require depending on what they evaluate to.
+  getConditionalBundleMapping() {
+    let bundleConditions = new Map();
+
+    // Convert the internal references in conditions to public API references
+    for (const cond of this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset => (0, _nullthrows().default)(this.getAssetById(asset.id)));
+      let bundles = new Set();
+      let ifTrueBundles = [];
+      let ifFalseBundles = [];
+      for (const asset of assets) {
+        const bundlesWithAsset = this.getBundlesWithAsset(asset);
+        for (const bundle of bundlesWithAsset) {
+          bundles.add(bundle);
+        }
+        const assetDeps = this.getDependencies(asset);
+        const depToBundles = dep => {
+          const publicDep = (0, _nullthrows().default)(assetDeps.find(assetDep => dep.id === assetDep.id));
+          const resolved = this.resolveAsyncDependency(publicDep);
+          if (!resolved) {
+            // If there's no async dependency, don't list it as required
+            return [];
+          }
+          (0, _assert().default)(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles
+        });
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+    return bundleConditions;
+  }
+  getReferencedConditionalBundles(bundle) {
+    return this.#graph.getReferencedConditionalBundles((0, _Bundle.bundleToInternalBundle)(bundle)).map(result => this.#createBundle(result, this.#graph, this.#options));
+  }
+}
+exports.default = BundleGraph;

package/lib/public/BundleGroup.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bundleGroupToInternalBundleGroup = bundleGroupToInternalBundleGroup;
+exports.default = void 0;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _Target = _interopRequireDefault(require("./Target"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const internalBundleGroupToBundleGroup = new WeakMap();
+const _bundleGroupToInternalBundleGroup = new WeakMap();
+function bundleGroupToInternalBundleGroup(target) {
+  return (0, _nullthrows().default)(_bundleGroupToInternalBundleGroup.get(target));
+}
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+class BundleGroup {
+  #bundleGroup /*: InternalBundleGroup */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(bundleGroup, options) {
+    let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
+    if (existing != null) {
+      return existing;
+    }
+    this.#bundleGroup = bundleGroup;
+    this.#options = options;
+    _bundleGroupToInternalBundleGroup.set(this, bundleGroup);
+    internalBundleGroupToBundleGroup.set(bundleGroup, this);
+    return this;
+  }
+  get target() {
+    return new _Target.default(this.#bundleGroup.target, this.#options);
+  }
+  get entryAssetId() {
+    return this.#bundleGroup.entryAssetId;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `BundleGroup(${this.entryAssetId})`;
+  }
+}
+exports.default = BundleGroup;

package/lib/public/Config.js

@@ -0,0 +1,202 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _Environment = _interopRequireDefault(require("./Environment"));
+var _projectPath = require("../projectPath");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const internalConfigToConfig = new (_utils().DefaultWeakMap)(() => new WeakMap());
+class PublicConfig {
+  #config /*: Config */;
+  #pkg /*: ?PackageJSON */;
+  #pkgFilePath /*: ?FilePath */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(config, options) {
+    let existing = internalConfigToConfig.get(options).get(config);
+    if (existing != null) {
+      return existing;
+    }
+    this.#config = config;
+    this.#options = options;
+    internalConfigToConfig.get(options).set(config, this);
+    return this;
+  }
+  get env() {
+    return new _Environment.default(this.#config.env, this.#options);
+  }
+  get searchPath() {
+    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#config.searchPath);
+  }
+  get result() {
+    return this.#config.result;
+  }
+  get isSource() {
+    return this.#config.isSource;
+  }
+
+  // $FlowFixMe
+  setResult(result) {
+    this.#config.result = result;
+  }
+  setCacheKey(cacheKey) {
+    this.#config.cacheKey = cacheKey;
+  }
+  invalidateOnFileChange(filePath) {
+    this.#config.invalidateOnFileChange.add((0, _projectPath.toProjectPath)(this.#options.projectRoot, filePath));
+  }
+  invalidateOnConfigKeyChange(filePath, configKey) {
+    this.#config.invalidateOnConfigKeyChange.push({
+      filePath: (0, _projectPath.toProjectPath)(this.#options.projectRoot, filePath),
+      configKey
+    });
+  }
+  addDevDependency(devDep) {
+    var _devDep$additionalInv;
+    this.#config.devDeps.push({
+      ...devDep,
+      resolveFrom: (0, _projectPath.toProjectPath)(this.#options.projectRoot, devDep.resolveFrom),
+      additionalInvalidations: (_devDep$additionalInv = devDep.additionalInvalidations) === null || _devDep$additionalInv === void 0 ? void 0 : _devDep$additionalInv.map(i => ({
+        ...i,
+        resolveFrom: (0, _projectPath.toProjectPath)(this.#options.projectRoot, i.resolveFrom)
+      }))
+    });
+  }
+  invalidateOnFileCreate(invalidation) {
+    if (invalidation.glob != null) {
+      // $FlowFixMe
+      this.#config.invalidateOnFileCreate.push(invalidation);
+    } else if (invalidation.filePath != null) {
+      this.#config.invalidateOnFileCreate.push({
+        filePath: (0, _projectPath.toProjectPath)(this.#options.projectRoot, invalidation.filePath)
+      });
+    } else {
+      (0, _assert().default)(invalidation.aboveFilePath != null);
+      this.#config.invalidateOnFileCreate.push({
+        // $FlowFixMe
+        fileName: invalidation.fileName,
+        aboveFilePath: (0, _projectPath.toProjectPath)(this.#options.projectRoot, invalidation.aboveFilePath)
+      });
+    }
+  }
+  invalidateOnEnvChange(env) {
+    this.#config.invalidateOnEnvChange.add(env);
+  }
+  invalidateOnStartup() {
+    this.#config.invalidateOnStartup = true;
+  }
+  invalidateOnBuild() {
+    this.#config.invalidateOnBuild = true;
+  }
+  async getConfigFrom(searchPath, fileNames, options) {
+    let packageKey = options === null || options === void 0 ? void 0 : options.packageKey;
+    if (packageKey != null) {
+      let pkg = await this.getConfigFrom(searchPath, ['package.json'], {
+        exclude: true
+      });
+      if (pkg && pkg.contents[packageKey]) {
+        // Invalidate only when the package key changes
+        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+        return {
+          contents: pkg.contents[packageKey],
+          filePath: pkg.filePath
+        };
+      }
+    }
+    if (fileNames.length === 0) {
+      return null;
+    }
+
+    // Invalidate when any of the file names are created above the search path.
+    for (let fileName of fileNames) {
+      this.invalidateOnFileCreate({
+        fileName,
+        aboveFilePath: searchPath
+      });
+    }
+    let parse = options && options.parse;
+    let configFilePath = await (0, _utils().resolveConfig)(this.#options.inputFS, searchPath, fileNames, this.#options.projectRoot);
+    if (configFilePath == null) {
+      return null;
+    }
+    if (!options || !options.exclude) {
+      this.invalidateOnFileChange(configFilePath);
+    }
+
+    // If this is a JavaScript file, load it with the package manager.
+    let extname = _path().default.extname(configFilePath);
+    if (extname === '.js' || extname === '.cjs' || extname === '.mjs') {
+      let specifier = (0, _utils().relativePath)(_path().default.dirname(searchPath), configFilePath);
+
+      // Add dev dependency so we reload the config and any dependencies in watch mode.
+      this.addDevDependency({
+        specifier,
+        resolveFrom: searchPath
+      });
+
+      // Invalidate on startup in case the config is non-deterministic,
+      // e.g. uses unknown environment variables, reads from the filesystem, etc.
+      this.invalidateOnStartup();
+      let config = await this.#options.packageManager.require(specifier, searchPath);
+      if (
+      // $FlowFixMe
+      Object.prototype.toString.call(config) === '[object Module]' && config.default != null) {
+        // Native ESM config. Try to use a default export, otherwise fall back to the whole namespace.
+        config = config.default;
+      }
+      return {
+        contents: config,
+        filePath: configFilePath
+      };
+    }
+    let conf = await (0, _utils().readConfig)(this.#options.inputFS, configFilePath, parse == null ? null : {
+      parse
+    });
+    if (conf == null) {
+      return null;
+    }
+    return {
+      contents: conf.config,
+      filePath: configFilePath
+    };
+  }
+  getConfig(filePaths, options) {
+    return this.getConfigFrom(this.searchPath, filePaths, options);
+  }
+  async getPackage() {
+    if (this.#pkg) {
+      return this.#pkg;
+    }
+    let pkgConfig = await this.getConfig(['package.json']);
+    if (!pkgConfig) {
+      return null;
+    }
+    this.#pkg = pkgConfig.contents;
+    this.#pkgFilePath = pkgConfig.filePath;
+    return this.#pkg;
+  }
+}
+exports.default = PublicConfig;

package/lib/public/Dependency.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.dependencyToInternalDependency = dependencyToInternalDependency;
+exports.getPublicDependency = getPublicDependency;
+var _types = require("../types");
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _Environment = _interopRequireDefault(require("./Environment"));
+var _Target = _interopRequireDefault(require("./Target"));
+var _Symbols = require("./Symbols");
+var _projectPath = require("../projectPath");
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const SpecifierTypeNames = Object.keys(_types.SpecifierType);
+const PriorityNames = Object.keys(_types.Priority);
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const internalDependencyToDependency = new WeakMap();
+const _dependencyToInternalDependency = new WeakMap();
+function dependencyToInternalDependency(dependency) {
+  return (0, _nullthrows().default)(_dependencyToInternalDependency.get(dependency));
+}
+function getPublicDependency(dep, options) {
+  let existing = internalDependencyToDependency.get(dep);
+  if (existing != null) {
+    return existing;
+  }
+  return new Dependency(dep, options);
+}
+class Dependency {
+  #dep /*: InternalDependency */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(dep, options) {
+    this.#dep = dep;
+    this.#options = options;
+    _dependencyToInternalDependency.set(this, dep);
+    internalDependencyToDependency.set(dep, this);
+    return this;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `Dependency(${String(this.sourcePath)} -> ${this.specifier})`;
+  }
+  get id() {
+    return this.#dep.id;
+  }
+  get specifier() {
+    return this.#dep.specifier;
+  }
+  get specifierType() {
+    return SpecifierTypeNames[this.#dep.specifierType];
+  }
+  get priority() {
+    return PriorityNames[this.#dep.priority];
+  }
+  get needsStableName() {
+    return this.#dep.needsStableName;
+  }
+  get bundleBehavior() {
+    let bundleBehavior = this.#dep.bundleBehavior;
+    return bundleBehavior == null ? null : _types.BundleBehaviorNames[bundleBehavior];
+  }
+  get isEntry() {
+    return this.#dep.isEntry;
+  }
+  get isOptional() {
+    return this.#dep.isOptional;
+  }
+  get loc() {
+    return (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, this.#dep.loc);
+  }
+  get env() {
+    return new _Environment.default(this.#dep.env, this.#options);
+  }
+  get packageConditions() {
+    // Merge custom conditions with conditions stored as bitflags.
+    // Order is not important because exports conditions are resolved
+    // in the order they are declared in the package.json.
+    let conditions = this.#dep.customPackageConditions;
+    if (this.#dep.packageConditions) {
+      conditions = conditions ? [...conditions] : [];
+      for (let key in _types.ExportsCondition) {
+        if (this.#dep.packageConditions & _types.ExportsCondition[key]) {
+          conditions.push(key);
+        }
+      }
+    }
+    return conditions;
+  }
+  get meta() {
+    return this.#dep.meta;
+  }
+  get symbols() {
+    return new _Symbols.MutableDependencySymbols(this.#options, this.#dep);
+  }
+  get target() {
+    let target = this.#dep.target;
+    return target ? new _Target.default(target, this.#options) : null;
+  }
+  get sourceAssetId() {
+    // TODO: does this need to be public?
+    return this.#dep.sourceAssetId;
+  }
+  get sourcePath() {
+    // TODO: does this need to be public?
+    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#dep.sourcePath);
+  }
+  get sourceAssetType() {
+    return this.#dep.sourceAssetType;
+  }
+  get resolveFrom() {
+    return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#dep.resolveFrom ?? this.#dep.sourcePath);
+  }
+  get range() {
+    return this.#dep.range;
+  }
+  get pipeline() {
+    return this.#dep.pipeline;
+  }
+}
+exports.default = Dependency;