@atlaspack/core 2.12.1-canary.3354

package/lib/public/BundleGroup.js

@@ -0,0 +1,44 @@
+"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));
+}
+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;
+  }
+}
+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;

package/lib/public/Environment.js

@@ -0,0 +1,244 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ISOLATED_ENVS = exports.BROWSER_ENVS = void 0;
+exports.environmentToInternalEnvironment = environmentToInternalEnvironment;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _browserslist() {
+  const data = _interopRequireDefault(require("browserslist"));
+  _browserslist = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const BROWSER_ENVS = exports.BROWSER_ENVS = new Set(['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']);
+const ISOLATED_ENVS = exports.ISOLATED_ENVS = 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 = new WeakMap();
+const _environmentToInternalEnvironment = new WeakMap();
+function environmentToInternalEnvironment(environment) {
+  return (0, _nullthrows().default)(_environmentToInternalEnvironment.get(environment));
+}
+class Environment {
+  #environment /*: InternalEnvironment */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(env, options) {
+    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() {
+    return this.#environment.id;
+  }
+  get context() {
+    return this.#environment.context;
+  }
+  get engines() {
+    return this.#environment.engines;
+  }
+  get includeNodeModules() {
+    return this.#environment.includeNodeModules;
+  }
+  get outputFormat() {
+    return this.#environment.outputFormat;
+  }
+  get sourceType() {
+    return this.#environment.sourceType;
+  }
+  get isLibrary() {
+    return this.#environment.isLibrary;
+  }
+  get shouldOptimize() {
+    return this.#environment.shouldOptimize;
+  }
+  get shouldScopeHoist() {
+    return this.#environment.shouldScopeHoist;
+  }
+  get sourceMap() {
+    return this.#environment.sourceMap;
+  }
+  get loc() {
+    return (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, this.#environment.loc);
+  }
+
+  // $FlowFixMe[unsupported-syntax]
+  [inspect]() {
+    return `Env(${this.#environment.context})`;
+  }
+  isBrowser() {
+    return BROWSER_ENVS.has(this.#environment.context);
+  }
+  isNode() {
+    return NODE_ENVS.has(this.#environment.context);
+  }
+  isElectron() {
+    return ELECTRON_ENVS.has(this.#environment.context);
+  }
+  isIsolated() {
+    return ISOLATED_ENVS.has(this.#environment.context);
+  }
+  isWorker() {
+    return WORKER_ENVS.has(this.#environment.context);
+  }
+  isWorklet() {
+    return this.#environment.context === 'worklet';
+  }
+  matchesEngines(minVersions, defaultValue = false) {
+    // 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 = (0, _browserslist().default)(browsers);
+      if (matchedBrowsers.length === 0) {
+        return false;
+      }
+      let minBrowsers = getExcludedBrowsers(minVersions);
+      let withoutMinBrowsers = (0, _browserslist().default)([...browsers, ...minBrowsers]);
+      return matchedBrowsers.length === withoutMinBrowsers.length;
+    } else if (this.isNode() && this.engines.node != null) {
+      return minVersions.node != null && !_semver().default.intersects(`< ${minVersions.node}`, this.engines.node);
+    }
+    return defaultValue;
+  }
+  supports(feature, defaultValue) {
+    let engines = supportData[feature];
+    if (!engines) {
+      throw new Error('Unknown environment feature: ' + feature);
+    }
+    return this.matchesEngines(engines, defaultValue);
+  }
+}
+exports.default = Environment;
+function getExcludedBrowsers(minVersions) {
+  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;
+}