@atlaspack/core 2.13.2-dev.3689 → 2.14.0

package/lib/requests/DevDepRequest.js

@@ -1,193 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createDevDependency = createDevDependency;
-exports.getDevDepRequests = getDevDepRequests;
-exports.getWorkerDevDepRequests = getWorkerDevDepRequests;
-exports.invalidateDevDeps = invalidateDevDeps;
-exports.resolveDevDepRequestRef = resolveDevDepRequestRef;
-exports.runDevDepRequest = runDevDepRequest;
-function _buildCache() {
-  const data = require("@atlaspack/build-cache");
-  _buildCache = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-var _assetUtils = require("../assetUtils");
-var _utils = require("../utils");
-var _projectPath = require("../projectPath");
-var _RequestTracker = require("../RequestTracker");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// A cache of dev dep requests keyed by invalidations.
-// If the package manager returns the same invalidation object, then
-// we can reuse the dev dep request rather than recomputing the project
-// paths and hashes.
-const devDepRequestCache = new WeakMap();
-async function createDevDependency(opts, requestDevDeps, options) {
-  let {
-    specifier,
-    resolveFrom,
-    additionalInvalidations
-  } = opts;
-  let key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
-
-  // If the request sent us a hash, we know the dev dep and all of its dependencies didn't change.
-  // Reuse the same hash in the response. No need to send back invalidations as the request won't
-  // be re-run anyway.
-  let hash = requestDevDeps.get(key);
-  if (hash != null) {
-    return {
-      type: 'ref',
-      specifier,
-      resolveFrom,
-      hash
-    };
-  }
-  let resolveFromAbsolute = (0, _projectPath.fromProjectPath)(options.projectRoot, resolveFrom);
-
-  // Ensure that the package manager has an entry for this resolution.
-  try {
-    await options.packageManager.resolve(specifier, resolveFromAbsolute);
-  } catch (err) {
-    // ignore
-  }
-  let invalidations = options.packageManager.getInvalidations(specifier, resolveFromAbsolute);
-  let cached = devDepRequestCache.get(invalidations);
-  if (cached != null) {
-    return cached;
-  }
-  let invalidateOnFileChangeProject = [...invalidations.invalidateOnFileChange].map(f => (0, _projectPath.toProjectPath)(options.projectRoot, f));
-
-  // It is possible for a transformer to have multiple different hashes due to
-  // different dependencies (e.g. conditional requires) so we must always
-  // recompute the hash and compare rather than only sending a transformer
-  // dev dependency once.
-  hash = await (0, _assetUtils.getInvalidationHash)(invalidateOnFileChangeProject.map(f => ({
-    type: 'file',
-    filePath: f
-  })), options);
-  let devDepRequest = {
-    specifier,
-    resolveFrom,
-    hash,
-    invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map(i => (0, _utils.invalidateOnFileCreateToInternal)(options.projectRoot, i)),
-    invalidateOnFileChange: new Set(invalidateOnFileChangeProject),
-    invalidateOnStartup: invalidations.invalidateOnStartup,
-    additionalInvalidations
-  };
-  devDepRequestCache.set(invalidations, devDepRequest);
-  return devDepRequest;
-}
-async function getDevDepRequests(api) {
-  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
-  return {
-    devDeps: new Map([...previousDevDepRequests.entries()].filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
-    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()].filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
-      return [{
-        specifier: req.specifier,
-        resolveFrom: req.resolveFrom
-      }, ...(req.additionalInvalidations ?? []).map(i => ({
-        specifier: i.specifier,
-        resolveFrom: i.resolveFrom
-      }))];
-    }))
-  };
-}
-
-// Tracks dev deps that have been invalidated during this build
-// so we don't invalidate the require cache more than once.
-const invalidatedDevDeps = (0, _buildCache().createBuildCache)();
-function invalidateDevDeps(invalidDevDeps, options, config) {
-  for (let {
-    specifier,
-    resolveFrom
-  } of invalidDevDeps) {
-    let key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
-    if (!invalidatedDevDeps.has(key)) {
-      config.invalidatePlugin(specifier);
-      options.packageManager.invalidate(specifier, (0, _projectPath.fromProjectPath)(options.projectRoot, resolveFrom));
-      invalidatedDevDeps.set(key, true);
-    }
-  }
-}
-const devDepRequests = (0, _buildCache().createBuildCache)();
-function resolveDevDepRequestRef(devDepRequestRef) {
-  const devDepRequest = devDepRequestRef.type === 'ref' ? devDepRequests.get(devDepRequestRef.hash) : devDepRequestRef;
-  if (devDepRequest == null) {
-    throw new Error(`Worker send back a reference to a missing dev dep request.
-
-This might happen due to internal in-memory build caches not being cleared
-between builds or due a race condition.
-${process.env.NODE_ENV === 'test' ? `If this is a unit test, call atlaspack.clearBuildCaches() between tests` : ''}
-
-This is a bug in Atlaspack.`);
-  }
-  if (devDepRequestRef.type !== 'ref') {
-    devDepRequests.set(devDepRequest.hash, devDepRequest);
-  }
-  return devDepRequest;
-}
-async function runDevDepRequest(api, devDepRequestRef) {
-  await api.runRequest({
-    id: 'dev_dep_request:' + devDepRequestRef.specifier + ':' + devDepRequestRef.hash,
-    type: _RequestTracker.requestTypes.dev_dep_request,
-    run: ({
-      api
-    }) => {
-      const devDepRequest = resolveDevDepRequestRef(devDepRequestRef);
-      for (let filePath of (0, _nullthrows().default)(devDepRequest.invalidateOnFileChange, 'DevDepRequest missing invalidateOnFileChange')) {
-        api.invalidateOnFileUpdate(filePath);
-        api.invalidateOnFileDelete(filePath);
-      }
-      for (let invalidation of (0, _nullthrows().default)(devDepRequest.invalidateOnFileCreate, 'DevDepRequest missing invalidateOnFileCreate')) {
-        api.invalidateOnFileCreate(invalidation);
-      }
-      if (devDepRequest.invalidateOnStartup) {
-        api.invalidateOnStartup();
-      }
-      api.storeResult({
-        specifier: devDepRequest.specifier,
-        resolveFrom: devDepRequest.resolveFrom,
-        hash: devDepRequest.hash,
-        additionalInvalidations: devDepRequest.additionalInvalidations
-      });
-    },
-    input: null
-  });
-}
-
-// A cache of plugin dependency hashes that we've already sent to the main thread.
-// Automatically cleared before each build.
-const pluginCache = (0, _buildCache().createBuildCache)();
-function getWorkerDevDepRequests(devDepRequests) {
-  return devDepRequests.map(devDepRequest => {
-    // If we've already sent a matching transformer + hash to the main thread during this build,
-    // there's no need to repeat ourselves.
-    let {
-      specifier,
-      resolveFrom,
-      hash
-    } = devDepRequest;
-    if (hash === pluginCache.get(specifier)) {
-      return {
-        type: 'ref',
-        specifier,
-        resolveFrom,
-        hash
-      };
-    } else {
-      pluginCache.set(specifier, hash);
-      return devDepRequest;
-    }
-  });
-}

package/lib/requests/EntryRequest.js

@@ -1,295 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.EntryResolver = void 0;
-exports.default = createEntryRequest;
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _jsonSourcemap() {
-  const data = require("@mischnic/json-sourcemap");
-  _jsonSourcemap = function () {
-    return data;
-  };
-  return data;
-}
-var _RequestTracker = require("../RequestTracker");
-var _projectPath = require("../projectPath");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-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; }
-const type = 'entry_request';
-function createEntryRequest(input) {
-  return {
-    id: `${type}:${(0, _projectPath.fromProjectPathRelative)(input)}`,
-    type: _RequestTracker.requestTypes.entry_request,
-    run,
-    input
-  };
-}
-async function run({
-  input,
-  api,
-  options
-}) {
-  let entryResolver = new EntryResolver(options);
-  let filePath = (0, _projectPath.fromProjectPath)(options.projectRoot, input);
-  let result = await entryResolver.resolveEntry(filePath);
-
-  // Connect files like package.json that affect the entry
-  // resolution so we invalidate when they change.
-  for (let file of result.files) {
-    api.invalidateOnFileUpdate(file.filePath);
-    api.invalidateOnFileDelete(file.filePath);
-  }
-
-  // If the entry specifier is a glob, add a glob node so
-  // we invalidate when a new file matches.
-  for (let glob of result.globs) {
-    api.invalidateOnFileCreate({
-      glob: (0, _projectPath.toProjectPath)(options.projectRoot, glob)
-    });
-  }
-
-  // Invalidate whenever an entry is deleted.
-  // If the entry was a glob, we'll re-evaluate it, and otherwise
-  // a proper entry error will be thrown.
-  for (let entry of result.entries) {
-    api.invalidateOnFileDelete(entry.filePath);
-  }
-  return result;
-}
-async function assertFile(fs, entry, relativeSource, pkgFilePath, keyPath, options) {
-  let source = _path().default.join(entry, relativeSource);
-  let stat;
-  try {
-    stat = await fs.stat(source);
-  } catch (err) {
-    let contents = await fs.readFile(pkgFilePath, 'utf8');
-    let alternatives = await (0, _utils().findAlternativeFiles)(fs, relativeSource, entry, options.projectRoot, false);
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        origin: '@atlaspack/core',
-        message: (0, _diagnostic().md)`${_path().default.relative(process.cwd(), source)} does not exist.`,
-        codeFrames: [{
-          filePath: pkgFilePath,
-          codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(contents, [{
-            key: keyPath,
-            type: 'value'
-          }])
-        }],
-        hints: alternatives.map(r => {
-          return (0, _diagnostic().md)`Did you mean '__${r}__'?`;
-        })
-      }
-    });
-  }
-  if (!stat.isFile()) {
-    let contents = await fs.readFile(pkgFilePath, 'utf8');
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        origin: '@atlaspack/core',
-        message: (0, _diagnostic().md)`${_path().default.relative(process.cwd(), source)} is not a file.`,
-        codeFrames: [{
-          filePath: pkgFilePath,
-          codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(contents, [{
-            key: keyPath,
-            type: 'value'
-          }])
-        }]
-      }
-    });
-  }
-}
-class EntryResolver {
-  constructor(options) {
-    this.options = options;
-  }
-  async resolveEntry(entry) {
-    let stat;
-    try {
-      stat = await this.options.inputFS.stat(entry);
-    } catch (err) {
-      if (!(0, _utils().isGlob)(entry)) {
-        throw new (_diagnostic().default)({
-          diagnostic: {
-            message: (0, _diagnostic().md)`Entry ${entry} does not exist`
-          }
-        });
-      }
-      let files = await (0, _utils().glob)(entry, this.options.inputFS, {
-        absolute: true,
-        onlyFiles: false
-      });
-      let results = await Promise.all(files.map(f => this.resolveEntry(_path().default.normalize(f))));
-      return results.reduce((p, res) => ({
-        entries: p.entries.concat(res.entries),
-        files: p.files.concat(res.files),
-        globs: p.globs.concat(res.globs)
-      }), {
-        entries: [],
-        files: [],
-        globs: [entry]
-      });
-    }
-    if (stat.isDirectory()) {
-      let pkg = await this.readPackage(entry);
-      if (pkg) {
-        let {
-          filePath
-        } = pkg;
-        let entries = [];
-        let files = [{
-          filePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, filePath)
-        }];
-        let globs = [];
-        let targetsWithSources = 0;
-        if (pkg.targets) {
-          for (let targetName in pkg.targets) {
-            let target = pkg.targets[targetName];
-            if (target.source != null) {
-              targetsWithSources++;
-              let targetSources = Array.isArray(target.source) ? target.source : [target.source];
-              let i = 0;
-              for (let source of targetSources) {
-                let sources;
-                if ((0, _utils().isGlob)(source)) {
-                  globs.push(source);
-                  sources = await (0, _utils().glob)(source, this.options.inputFS, {
-                    onlyFiles: true,
-                    cwd: entry
-                  });
-                } else {
-                  sources = [source];
-                }
-                let keyPath = `/targets/${targetName}/source${Array.isArray(target.source) ? `/${i}` : ''}`;
-                for (let relativeSource of sources) {
-                  let source = _path().default.join(entry, relativeSource);
-                  await assertFile(this.options.inputFS, entry, relativeSource, filePath, keyPath, this.options);
-                  entries.push({
-                    filePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, source),
-                    packagePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, entry),
-                    target: targetName,
-                    loc: {
-                      filePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, pkg.filePath),
-                      ...(0, _diagnostic().getJSONSourceLocation)(pkg.map.pointers[keyPath], 'value')
-                    }
-                  });
-                  i++;
-                }
-              }
-            }
-          }
-        }
-        let allTargetsHaveSource = targetsWithSources > 0 && pkg != null && pkg.targets != null && Object.keys(pkg.targets).length === targetsWithSources;
-        if (!allTargetsHaveSource && pkg.source != null) {
-          let pkgSources = Array.isArray(pkg.source) ? pkg.source : [pkg.source];
-          let i = 0;
-          for (let pkgSource of pkgSources) {
-            let sources;
-            if ((0, _utils().isGlob)(pkgSource)) {
-              globs.push(pkgSource);
-              sources = await (0, _utils().glob)(pkgSource, this.options.inputFS, {
-                onlyFiles: true,
-                cwd: _path().default.dirname(filePath)
-              });
-            } else {
-              sources = [pkgSource];
-            }
-            let keyPath = `/source${Array.isArray(pkg.source) ? `/${i}` : ''}`;
-            for (let relativeSource of sources) {
-              let source = _path().default.join(_path().default.dirname(filePath), relativeSource);
-              await assertFile(this.options.inputFS, entry, relativeSource, filePath, keyPath, this.options);
-              entries.push({
-                filePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, source),
-                packagePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, entry),
-                loc: {
-                  filePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, pkg.filePath),
-                  ...(0, _diagnostic().getJSONSourceLocation)(pkg.map.pointers[keyPath], 'value')
-                }
-              });
-              i++;
-            }
-          }
-        }
-
-        // Only return if we found any valid entries
-        if (entries.length && files.length) {
-          return {
-            entries,
-            files,
-            globs
-          };
-        }
-      }
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: (0, _diagnostic().md)`Could not find entry: ${entry}`
-        }
-      });
-    } else if (stat.isFile()) {
-      let projectRoot = this.options.projectRoot;
-      let packagePath = (0, _utils().isDirectoryInside)(this.options.inputFS.cwd(), projectRoot) ? this.options.inputFS.cwd() : projectRoot;
-      return {
-        entries: [{
-          filePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, entry),
-          packagePath: (0, _projectPath.toProjectPath)(this.options.projectRoot, packagePath)
-        }],
-        files: [],
-        globs: []
-      };
-    }
-    throw new (_diagnostic().default)({
-      diagnostic: {
-        message: (0, _diagnostic().md)`Unknown entry: ${entry}`
-      }
-    });
-  }
-  async readPackage(entry) {
-    let content, pkg;
-    let pkgFile = _path().default.join(entry, 'package.json');
-    try {
-      content = await this.options.inputFS.readFile(pkgFile, 'utf8');
-    } catch (err) {
-      return null;
-    }
-    try {
-      pkg = JSON.parse(content);
-    } catch (err) {
-      // TODO: code frame?
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: (0, _diagnostic().md)`Error parsing ${_path().default.relative(this.options.inputFS.cwd(), pkgFile)}: ${err.message}`
-        }
-      });
-    }
-    return {
-      ...pkg,
-      filePath: pkgFile,
-      map: (0, _jsonSourcemap().parse)(content, undefined, {
-        tabWidth: 1
-      })
-    };
-  }
-}
-exports.EntryResolver = EntryResolver;

package/lib/requests/PackageRequest.js

@@ -1,88 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createPackageRequest = createPackageRequest;
-var _RequestTracker = require("../RequestTracker");
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-var _ConfigRequest = require("./ConfigRequest");
-var _DevDepRequest = require("./DevDepRequest");
-var _AtlaspackConfigRequest = _interopRequireDefault(require("./AtlaspackConfigRequest"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function createPackageRequest(input) {
-  return {
-    type: _RequestTracker.requestTypes.package_request,
-    id: input.bundleGraph.getHash(input.bundle),
-    run,
-    input
-  };
-}
-async function run({
-  input,
-  api,
-  farm
-}) {
-  let {
-    bundleGraphReference,
-    optionsRef,
-    bundle,
-    useMainThread
-  } = input;
-  let runPackage = farm.createHandle('runPackage', useMainThread);
-  let start = Date.now();
-  let {
-    devDeps,
-    invalidDevDeps
-  } = await (0, _DevDepRequest.getDevDepRequests)(api);
-  let {
-    cachePath
-  } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
-  let {
-    devDepRequests,
-    configRequests,
-    bundleInfo,
-    invalidations
-  } = await runPackage({
-    bundle,
-    bundleGraphReference,
-    optionsRef,
-    configCachePath: cachePath,
-    previousDevDeps: devDeps,
-    invalidDevDeps,
-    previousInvalidations: api.getInvalidations()
-  });
-  for (let devDepRequest of devDepRequests) {
-    await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
-  }
-  for (let configRequest of configRequests) {
-    await (0, _ConfigRequest.runConfigRequest)(api, configRequest);
-  }
-  for (let invalidation of invalidations) {
-    switch (invalidation.type) {
-      case 'file':
-        api.invalidateOnFileUpdate(invalidation.filePath);
-        api.invalidateOnFileDelete(invalidation.filePath);
-        break;
-      case 'env':
-        api.invalidateOnEnvChange(invalidation.key);
-        break;
-      case 'option':
-        api.invalidateOnOptionChange(invalidation.key);
-        break;
-      default:
-        throw new Error(`Unknown invalidation type: ${invalidation.type}`);
-    }
-  }
-
-  // $FlowFixMe[cannot-write] time is marked read-only, but this is the exception
-  bundleInfo.time = Date.now() - start;
-  api.storeResult(bundleInfo);
-  return bundleInfo;
-}