@atlaspack/core 2.14.0 → 2.14.1-canary.10

package/lib/worker.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.childInit = childInit;
+exports.clearWorkerBuildCaches = clearWorkerBuildCaches;
+exports.invalidateRequireCache = invalidateRequireCache;
+exports.ping = ping;
+exports.runPackage = runPackage;
+exports.runTransform = runTransform;
+exports.runValidate = runValidate;
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+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;
+}
+var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
+var _Transformation = _interopRequireDefault(require("./Transformation"));
+var _ReporterRunner = require("./ReporterRunner");
+var _PackagerRunner = _interopRequireDefault(require("./PackagerRunner"));
+var _Validation = _interopRequireDefault(require("./Validation"));
+var _AtlaspackConfig = require("./AtlaspackConfig");
+var _registerCoreWithSerializer = require("./registerCoreWithSerializer");
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = require("@parcel/source-map");
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _workers() {
+  const data = _interopRequireDefault(require("@atlaspack/workers"));
+  _workers = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+require("@atlaspack/cache");
+require("@atlaspack/package-manager");
+require("@atlaspack/fs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// register with serializer
+// $FlowFixMe
+if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
+  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
+  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
+  // $FlowFixMe
+  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
+  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
+}
+
+(0, _registerCoreWithSerializer.registerCoreWithSerializer)();
+
+// Remove the workerApi type from the TransformationOpts and ValidationOpts types:
+// https://github.com/facebook/flow/issues/2835
+// TODO: this should eventually be replaced by an in memory cache layer
+let atlaspackConfigCache = new Map();
+function loadOptions(ref, workerApi) {
+  return (0, _nullthrows().default)(workerApi.getSharedReference(ref
+  // $FlowFixMe
+  ));
+}
+
+async function loadConfig(cachePath, options) {
+  let config = atlaspackConfigCache.get(cachePath);
+  if (config && config.options === options) {
+    return config;
+  }
+  let processedConfig = (0, _nullthrows().default)(await options.cache.get(cachePath));
+  config = new _AtlaspackConfig.AtlaspackConfig(processedConfig, options);
+  atlaspackConfigCache.set(cachePath, config);
+  (0, _featureFlags().setFeatureFlags)(options.featureFlags);
+  return config;
+}
+function clearWorkerBuildCaches() {
+  _utils().loadConfig.clear();
+  (0, _buildCache().clearBuildCaches)();
+}
+async function runTransform(workerApi, opts) {
+  let {
+    optionsRef,
+    configCachePath,
+    ...rest
+  } = opts;
+  let options = loadOptions(optionsRef, workerApi);
+  let config = await loadConfig(configCachePath, options);
+  return new _Transformation.default({
+    workerApi,
+    options,
+    config,
+    ...rest
+  }).run();
+}
+async function runValidate(workerApi, opts) {
+  let {
+    optionsRef,
+    configCachePath,
+    ...rest
+  } = opts;
+  let options = loadOptions(optionsRef, workerApi);
+  let config = await loadConfig(configCachePath, options);
+  return new _Validation.default({
+    workerApi,
+    report: _ReporterRunner.reportWorker.bind(null, workerApi),
+    options,
+    config,
+    ...rest
+  }).run();
+}
+async function runPackage(workerApi, {
+  bundle,
+  bundleGraphReference,
+  configCachePath,
+  optionsRef,
+  previousDevDeps,
+  invalidDevDeps,
+  previousInvalidations
+}) {
+  let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+  (0, _assert().default)(bundleGraph instanceof _BundleGraph.default);
+  let options = loadOptions(optionsRef, workerApi);
+  let atlaspackConfig = await loadConfig(configCachePath, options);
+  let runner = new _PackagerRunner.default({
+    config: atlaspackConfig,
+    options,
+    report: _workers().default.isWorker() ? _ReporterRunner.reportWorker.bind(null, workerApi) : _ReporterRunner.report,
+    previousDevDeps,
+    previousInvalidations
+  });
+  return runner.run(bundleGraph, bundle, invalidDevDeps);
+}
+async function childInit() {
+  await _sourceMap().init;
+  await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
+}
+const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
+function invalidateRequireCache() {
+  throw new Error('invalidateRequireCache is only for tests');
+}
+
+/**
+ * This is used to wait until workers are responding to messages.
+ */
+function ping() {
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.14.0",
+  "version": "2.14.1-canary.10+3b66d6b4b",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,22 +20,22 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
+    "@atlaspack/build-cache": "2.13.3-canary.10+3b66d6b4b",
+    "@atlaspack/cache": "2.13.3-canary.10+3b66d6b4b",
+    "@atlaspack/diagnostic": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/events": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/feature-flags": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/fs": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/graph": "3.4.1-canary.10+3b66d6b4b",
+    "@atlaspack/logger": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/package-manager": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/plugin": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/profiler": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/rust": "3.0.1-canary.10+3b66d6b4b",
+    "@atlaspack/types": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/utils": "2.14.1-canary.10+3b66d6b4b",
+    "@atlaspack/workers": "2.14.1-canary.10+3b66d6b4b",
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.2",
-    "@atlaspack/cache": "2.13.2",
-    "@atlaspack/diagnostic": "2.14.0",
-    "@atlaspack/events": "2.14.0",
-    "@atlaspack/feature-flags": "2.14.0",
-    "@atlaspack/fs": "2.14.0",
-    "@atlaspack/graph": "3.4.0",
-    "@atlaspack/logger": "2.14.0",
-    "@atlaspack/package-manager": "2.14.0",
-    "@atlaspack/plugin": "2.14.0",
-    "@atlaspack/profiler": "2.14.0",
-    "@atlaspack/rust": "3.0.0",
-    "@atlaspack/types": "2.14.0",
-    "@atlaspack/utils": "2.14.0",
-    "@atlaspack/workers": "2.14.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -50,9 +50,9 @@
   "devDependencies": {
     "@atlaspack/babel-register": "2.14.0",
     "@types/node": ">= 18",
-    "rfdc": "1",
-    "jest-diff": "*",
     "graphviz": "^0.0.9",
+    "jest-diff": "*",
+    "rfdc": "1",
     "tempy": "^0.2.1"
   },
   "exports": {
@@ -66,5 +66,6 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "gitHead": "3b66d6b4bfd652ab3b41e86aacf3e47d39cd5a70"
 }

package/src/loadAtlaspackPlugin.js

@@ -3,16 +3,13 @@ import type {FilePath, PackageName, Semver} from '@atlaspack/types';
 import type {AtlaspackOptions} from './types';
 
 import path from 'path';
-import semver from 'semver';
-import logger from '@atlaspack/logger';
 import nullthrows from 'nullthrows';
 import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
   md,
 } from '@atlaspack/diagnostic';
-import {findAlternativeNodeModules, resolveConfig} from '@atlaspack/utils';
+import {findAlternativeNodeModules} from '@atlaspack/utils';
 import {type ProjectPath, toProjectPath} from './projectPath';
-import {version as ATLASPACK_VERSION} from '../package.json';
 
 const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
 const CONFIG = Symbol.for('parcel-plugin-config');
@@ -56,13 +53,11 @@ export default async function loadPlugin<T>(
     });
   }
 
-  let resolved, pkg;
+  let pkg;
   try {
-    ({resolved, pkg} = await options.packageManager.resolve(
-      pluginName,
-      resolveFrom,
-      {shouldAutoInstall: options.shouldAutoInstall},
-    ));
+    ({pkg} = await options.packageManager.resolve(pluginName, resolveFrom, {
+      shouldAutoInstall: options.shouldAutoInstall,
+    }));
   } catch (err) {
     if (err.code !== 'MODULE_NOT_FOUND') {
       throw err;
@@ -102,61 +97,6 @@ export default async function loadPlugin<T>(
     });
   }
 
-  // Remove plugin version compatiblility validation in canary builds as they don't use semver
-  if (!process.env.SKIP_PLUGIN_COMPATIBILITY_CHECK) {
-    if (!pluginName.startsWith('.')) {
-      // Validate the plugin engines field
-      let key = 'atlaspack';
-      let atlaspackVersionRange;
-      if (pkg?.engines?.atlaspack) {
-        atlaspackVersionRange = pkg.engines.atlaspack;
-      } else if (pkg?.engines?.parcel) {
-        key = 'parcel';
-        atlaspackVersionRange = pkg.engines.parcel;
-      }
-
-      if (!atlaspackVersionRange) {
-        logger.warn({
-          origin: '@atlaspack/core',
-          message: `The plugin "${pluginName}" needs to specify a \`package.json#engines.atlaspack\` field with the supported Atlaspack version range.`,
-        });
-      }
-
-      if (
-        atlaspackVersionRange &&
-        !semver.satisfies(ATLASPACK_VERSION, atlaspackVersionRange)
-      ) {
-        let pkgFile = nullthrows(
-          await resolveConfig(
-            options.inputFS,
-            resolved,
-            ['package.json'],
-            options.projectRoot,
-          ),
-        );
-        let pkgContents = await options.inputFS.readFile(pkgFile, 'utf8');
-        throw new ThrowableDiagnostic({
-          diagnostic: {
-            message: md`The plugin "${pluginName}" is not compatible with the current version of Atlaspack. Requires "${atlaspackVersionRange}" but the current version is "${ATLASPACK_VERSION}".`,
-            origin: '@atlaspack/core',
-            codeFrames: [
-              {
-                filePath: pkgFile,
-                language: 'json5',
-                code: pkgContents,
-                codeHighlights: generateJSONCodeHighlights(pkgContents, [
-                  {
-                    key: `/engines/${key}`,
-                  },
-                ]),
-              },
-            ],
-          },
-        });
-      }
-    }
-  }
-
   let plugin = await options.packageManager.require(pluginName, resolveFrom, {
     shouldAutoInstall: options.shouldAutoInstall,
   });

package/test/AtlaspackConfig.test.js

@@ -3,10 +3,6 @@
 import assert from 'assert';
 import path from 'path';
 
-import logger from '@atlaspack/logger';
-import {inputFS} from '@atlaspack/test-utils';
-import sinon from 'sinon';
-
 import {AtlaspackConfig} from '../src/AtlaspackConfig';
 import {toProjectPath} from '../src/projectPath';
 import {parseAndProcessConfig} from '../src/requests/AtlaspackConfigRequest';
@@ -127,167 +123,6 @@ describe('AtlaspackConfig', () => {
   });
 
   describe('loadPlugin', () => {
-    it('should warn if a plugin needs to specify an engines.atlaspack field in package.json', async () => {
-      let projectRoot = path.join(__dirname, 'fixtures', 'plugins');
-      let configFilePath = toProjectPath(
-        projectRoot,
-        path.join(projectRoot, '.parcelrc'),
-      );
-
-      let config = new AtlaspackConfig(
-        {
-          filePath: configFilePath,
-          bundler: undefined,
-          transformers: {
-            '*.js': [
-              {
-                packageName: 'atlaspack-transformer-no-engines',
-                resolveFrom: configFilePath,
-                keyPath: '/transformers/*.js/0',
-              },
-            ],
-          },
-        },
-        {...DEFAULT_OPTIONS, projectRoot},
-      );
-
-      let warnStub = sinon.stub(logger, 'warn');
-      let {plugin} = await config.loadPlugin({
-        packageName: 'atlaspack-transformer-no-engines',
-        resolveFrom: configFilePath,
-        keyPath: '/transformers/*.js/0',
-      });
-
-      assert.equal(typeof plugin?.transform, 'function');
-      assert(warnStub.calledOnce);
-      assert.deepEqual(warnStub.getCall(0).args[0], {
-        origin: '@atlaspack/core',
-        message:
-          'The plugin "atlaspack-transformer-no-engines" needs to specify a `package.json#engines.atlaspack` field with the supported Atlaspack version range.',
-      });
-      warnStub.restore();
-    });
-
-    it('should error if a plugin specifies an invalid engines.atlaspack field in package.json', async () => {
-      let projectRoot = path.join(__dirname, 'fixtures', 'plugins');
-      let configFilePath = toProjectPath(
-        projectRoot,
-        path.join(projectRoot, '.parcelrc'),
-      );
-
-      let config = new AtlaspackConfig(
-        {
-          filePath: configFilePath,
-          bundler: undefined,
-          transformers: {},
-        },
-        {...DEFAULT_OPTIONS, projectRoot},
-      );
-
-      // $FlowFixMe[untyped-import]
-      let atlaspackVersion = require('../package.json').version;
-      let pkgJSON = path.join(
-        projectRoot,
-        'node_modules',
-        'atlaspack-transformer-bad-engines',
-        'package.json',
-      );
-      let code = inputFS.readFileSync(pkgJSON, 'utf8');
-
-      // $FlowFixMe
-      await assert.rejects(
-        () =>
-          config.loadPlugin({
-            packageName: 'atlaspack-transformer-bad-engines',
-            resolveFrom: configFilePath,
-            keyPath: '/transformers/*.js/0',
-          }),
-        {
-          name: 'Error',
-          diagnostics: [
-            {
-              message: `The plugin "atlaspack-transformer-bad-engines" is not compatible with the current version of Atlaspack. Requires "1.x" but the current version is "${atlaspackVersion}".`,
-              origin: '@atlaspack/core',
-              codeFrames: [
-                {
-                  filePath: pkgJSON,
-                  language: 'json5',
-                  code,
-                  codeHighlights: [
-                    {
-                      start: {line: 5, column: 5},
-                      end: {line: 5, column: 22},
-                      message: undefined,
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      );
-    });
-
-    it('should error if a plugin specifies an invalid engines.parcel field in package.json', async () => {
-      let projectRoot = path.join(__dirname, 'fixtures', 'plugins');
-      let configFilePath = toProjectPath(
-        projectRoot,
-        path.join(projectRoot, '.parcelrc'),
-      );
-
-      let config = new AtlaspackConfig(
-        {
-          filePath: configFilePath,
-          bundler: undefined,
-          transformers: {},
-        },
-        {...DEFAULT_OPTIONS, projectRoot},
-      );
-
-      // $FlowFixMe[untyped-import]
-      let atlaspackVersion = require('../package.json').version;
-      let pkgJSON = path.join(
-        projectRoot,
-        'node_modules',
-        'atlaspack-transformer-bad-parcel-engines',
-        'package.json',
-      );
-      let code = inputFS.readFileSync(pkgJSON, 'utf8');
-
-      // $FlowFixMe
-      await assert.rejects(
-        () =>
-          config.loadPlugin({
-            packageName: 'atlaspack-transformer-bad-parcel-engines',
-            resolveFrom: configFilePath,
-            keyPath: '/transformers/*.js/0',
-          }),
-        {
-          name: 'Error',
-          diagnostics: [
-            {
-              message: `The plugin "atlaspack-transformer-bad-parcel-engines" is not compatible with the current version of Atlaspack. Requires "1.x" but the current version is "${atlaspackVersion}".`,
-              origin: '@atlaspack/core',
-              codeFrames: [
-                {
-                  filePath: pkgJSON,
-                  language: 'json5',
-                  code,
-                  codeHighlights: [
-                    {
-                      start: {line: 5, column: 5},
-                      end: {line: 5, column: 19},
-                      message: undefined,
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-        },
-      );
-    });
-
     it('should error with a codeframe if a plugin is not resolved', async () => {
       let configFilePath = path.join(
         __dirname,

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-engines/index.js

@@ -1,7 +0,0 @@
-const {Transformer} = require('@atlaspack/plugin');
-
-module.exports = new Transformer({
-  transform(asset) {
-    return [asset];
-  }
-});

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-engines/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "atlaspack-transformer-bad-engines",
-  "version": "1.0.0",
-  "engines": {
-    "atlaspack": "1.x"
-  }
-}

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-parcel-engines/index.js

@@ -1,7 +0,0 @@
-const {Transformer} = require('@atlaspack/plugin');
-
-module.exports = new Transformer({
-  transform(asset) {
-    return [asset];
-  }
-});

package/test/fixtures/plugins/node_modules/atlaspack-transformer-bad-parcel-engines/package.json

@@ -1,7 +0,0 @@
-{
-  "name": "atlaspack-transformer-bad-parcel-engines",
-  "version": "1.0.0",
-  "engines": {
-    "parcel": "1.x"
-  }
-}

package/test/fixtures/plugins/node_modules/atlaspack-transformer-no-engines/index.js

@@ -1,7 +0,0 @@
-const {Transformer} = require('@atlaspack/plugin');
-
-module.exports = new Transformer({
-  transform(asset) {
-    return [asset];
-  }
-});

package/test/fixtures/plugins/node_modules/atlaspack-transformer-no-engines/package.json

@@ -1,4 +0,0 @@
-{
-  "name": "atlaspack-transformer-no-engines",
-  "version": "1.0.0"
-}