@atlaspack/core 2.13.2-dev.3674 → 2.13.2-dev.3689

package/lib/loadAtlaspackPlugin.js

@@ -41,57 +41,26 @@ const NODE_MODULES = `${_path().default.sep}node_modules${_path().default.sep}`;
 const CONFIG = Symbol.for('parcel-plugin-config');
 async function loadPlugin(pluginName, configPath, keyPath, options) {
   let resolveFrom = configPath;
-  let range;
-  if (resolveFrom.includes(NODE_MODULES)) {
-    var _configPkg$config$dep;
-    // Config packages can reference plugins, but cannot contain other plugins within them.
-    // This forces every published plugin to be published separately so they can be mixed and matched if needed.
-    if (pluginName.startsWith('.')) {
-      let configContents = await options.inputFS.readFile(configPath, 'utf8');
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: (0, _diagnostic().md)`Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
-          origin: '@atlaspack/core',
-          codeFrames: keyPath ? [{
-            filePath: configPath,
-            language: 'json5',
-            code: configContents,
-            codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(configContents, [{
-              key: keyPath,
-              type: 'value'
-            }])
-          }] : undefined
-        }
-      });
-    }
-    let configPkg = await (0, _utils().loadConfig)(options.inputFS, resolveFrom, ['package.json'], options.projectRoot);
-    if (configPkg != null && ((_configPkg$config$dep = configPkg.config.dependencies) === null || _configPkg$config$dep === void 0 ? void 0 : _configPkg$config$dep[pluginName]) == null) {
-      var _configPkg$config$par;
-      // If not in the config's dependencies, the plugin will be auto installed with
-      // the version declared in "parcelDependencies".
-      range = (_configPkg$config$par = configPkg.config.parcelDependencies) === null || _configPkg$config$par === void 0 ? void 0 : _configPkg$config$par[pluginName];
-      if (range == null) {
-        let contents = await options.inputFS.readFile(configPkg.files[0].filePath, 'utf8');
-        throw new (_diagnostic().default)({
-          diagnostic: {
-            message: (0, _diagnostic().md)`Could not determine version of ${pluginName} in ${_path().default.relative(process.cwd(), resolveFrom)}. Either include it in "dependencies" or "parcelDependencies".`,
-            origin: '@atlaspack/core',
-            codeFrames: configPkg.config.dependencies || configPkg.config.parcelDependencies ? [{
-              filePath: configPkg.files[0].filePath,
-              language: 'json5',
-              code: contents,
-              codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(contents, [{
-                key: configPkg.config.parcelDependencies ? '/parcelDependencies' : '/dependencies',
-                type: 'key'
-              }])
-            }] : undefined
-          }
-        });
-      }
 
-      // Resolve from project root if not in the config's dependencies.
-      resolveFrom = _path().default.join(options.projectRoot, 'index');
-    }
+  // Config packages can reference plugins, but cannot contain other plugins within them.
+  // This forces every published plugin to be published separately so they can be mixed and matched if needed.
+  if (resolveFrom.includes(NODE_MODULES) && pluginName.startsWith('.')) {
+    let configContents = await options.inputFS.readFile(configPath, 'utf8');
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: (0, _diagnostic().md)`Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
+        origin: '@atlaspack/core',
+        codeFrames: keyPath ? [{
+          filePath: configPath,
+          language: 'json5',
+          code: configContents,
+          codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(configContents, [{
+            key: keyPath,
+            type: 'value'
+          }])
+        }] : undefined
+      }
+    });
   }
   let resolved, pkg;
   try {
@@ -99,8 +68,7 @@ async function loadPlugin(pluginName, configPath, keyPath, options) {
       resolved,
       pkg
     } = await options.packageManager.resolve(pluginName, resolveFrom, {
-      shouldAutoInstall: options.shouldAutoInstall,
-      range
+      shouldAutoInstall: options.shouldAutoInstall
     }));
   } catch (err) {
     if (err.code !== 'MODULE_NOT_FOUND') {
@@ -142,7 +110,6 @@ async function loadPlugin(pluginName, configPath, keyPath, options) {
   return {
     plugin,
     version: (0, _nullthrows().default)(pkg).version,
-    resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, resolveFrom),
-    range
+    resolveFrom: (0, _projectPath.toProjectPath)(options.projectRoot, resolveFrom)
   };
 }

package/lib/projectPath.js

@@ -22,17 +22,31 @@ function _utils() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * A path that's relative to the project root.
  */
+/**
+ * Converts a file path to a project-relative path.
+ *
+ * @param projectRoot - The project root.
+ * @param p - The file path to convert.
+ * @returns The project path.
+ */
 function toProjectPath_(projectRoot, p) {
   // If the file path is not provided, then treat it as though it is already from the project root
   if (p == null) {
     return p;
   }
 
-  // If the file path is already relative and it does not begin with . then treat the path as if it
+  // If the file path is already relative and it does not begin with '.', then treat the path as if it
   // is already from the project root. This prevents relative paths from being processed twice,
   // most often within `toInternalSourceLocation` when handling loc types from symbols and asset
   // dependencies.
@@ -45,6 +59,10 @@ function toProjectPath_(projectRoot, p) {
   // the project root is not portable anyway.
   let relative = (0, _utils().relativePath)(projectRoot, p, false);
   if (relative.startsWith('..')) {
+    // e.g given projectRoot = '/Users/monorepo/project' and p = '/Users/monorepo/other-project/src/index.js' --> relative = '../other-project/src/index.js'
+    if ((0, _featureFlags().getFeatureFlagValue)('patchProjectPaths')) {
+      return relative;
+    }
     return process.platform === 'win32' ? (0, _utils().normalizeSeparators)(p) : p;
   }
   return relative;

package/lib/requests/AtlaspackBuildRequest.js

@@ -33,7 +33,8 @@ function createAtlaspackBuildRequest(input) {
 async function run({
   input,
   api,
-  options
+  options,
+  rustAtlaspack
 }) {
   let {
     optionsRef,
@@ -50,7 +51,7 @@ async function run({
     changedAssets,
     assetRequests
   } = await api.runRequest(bundleGraphRequest, {
-    force: options.shouldBuildLazily && requestedAssetIds.size > 0
+    force: Boolean(rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
   });
 
   // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)

package/lib/requests/BundleGraphRequest.js

@@ -146,7 +146,7 @@ function createBundleGraphRequest(input) {
         changedAssets,
         assetRequests
       } = await api.runRequest(request, {
-        force: options.shouldBuildLazily && requestedAssetIds.size > 0
+        force: Boolean(input.rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
       });
       if ((_input$options$featur = input.options.featureFlags) !== null && _input$options$featur !== void 0 && _input$options$featur.loadableSideEffects) {
         applySideEffectsForLoadableImports(assetGraph);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.13.2-dev.3674+d7732a10a",
+  "version": "2.13.2-dev.3689+7a2e6e783",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/cache": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/diagnostic": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/events": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/feature-flags": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/fs": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/graph": "3.3.2-dev.3674+d7732a10a",
-    "@atlaspack/logger": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/package-manager": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/plugin": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/profiler": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/rust": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/types": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/utils": "2.13.2-dev.3674+d7732a10a",
-    "@atlaspack/workers": "2.13.2-dev.3674+d7732a10a",
+    "@atlaspack/build-cache": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/cache": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/diagnostic": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/events": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/feature-flags": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/fs": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/graph": "3.3.2-dev.3689+7a2e6e783",
+    "@atlaspack/logger": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/package-manager": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/plugin": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/profiler": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/rust": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/types": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/utils": "2.13.2-dev.3689+7a2e6e783",
+    "@atlaspack/workers": "2.13.2-dev.3689+7a2e6e783",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -66,5 +66,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "d7732a10a9a123de06d5eedcf9800d621e740229"
+  "gitHead": "7a2e6e7835fa846b27021b374097c6a4f37541ba"
 }

package/src/AtlaspackConfig.js

@@ -12,7 +12,6 @@ import type {
   Packager,
   Reporter,
   Semver,
-  SemverRange,
   Validator,
   FilePath,
 } from '@atlaspack/types';
@@ -52,7 +51,6 @@ export type LoadedPlugin<T> = {|
   plugin: T,
   resolveFrom: ProjectPath,
   keyPath?: string,
-  range?: ?SemverRange,
 |};
 
 export class AtlaspackConfig {
@@ -120,7 +118,6 @@ export class AtlaspackConfig {
     plugin: T,
     version: Semver,
     resolveFrom: ProjectPath,
-    range: ?SemverRange,
   |}> {
     let plugin = this.pluginCache.get(node.packageName);
     if (plugin) {

package/src/atlaspack-v3/AtlaspackV3.js

@@ -65,7 +65,7 @@ export class AtlaspackV3 {
     return graph;
   }
 
-  respondToFsEvents(events: Array<Event>): boolean {
+  respondToFsEvents(events: Array<Event>): Promise<boolean> {
     return this._internal.respondToFsEvents(events);
   }
 }

package/src/loadAtlaspackPlugin.js

@@ -1,10 +1,5 @@
 // @flow
-import type {
-  FilePath,
-  PackageName,
-  Semver,
-  SemverRange,
-} from '@atlaspack/types';
+import type {FilePath, PackageName, Semver} from '@atlaspack/types';
 import type {AtlaspackOptions} from './types';
 
 import path from 'path';
@@ -15,11 +10,7 @@ import ThrowableDiagnostic, {
   generateJSONCodeHighlights,
   md,
 } from '@atlaspack/diagnostic';
-import {
-  findAlternativeNodeModules,
-  loadConfig,
-  resolveConfig,
-} from '@atlaspack/utils';
+import {findAlternativeNodeModules, resolveConfig} from '@atlaspack/utils';
 import {type ProjectPath, toProjectPath} from './projectPath';
 import {version as ATLASPACK_VERSION} from '../package.json';
 
@@ -35,90 +26,34 @@ export default async function loadPlugin<T>(
   plugin: T,
   version: Semver,
   resolveFrom: ProjectPath,
-  range: ?SemverRange,
 |}> {
   let resolveFrom = configPath;
-  let range;
-  if (resolveFrom.includes(NODE_MODULES)) {
-    // Config packages can reference plugins, but cannot contain other plugins within them.
-    // This forces every published plugin to be published separately so they can be mixed and matched if needed.
-    if (pluginName.startsWith('.')) {
-      let configContents = await options.inputFS.readFile(configPath, 'utf8');
-      throw new ThrowableDiagnostic({
-        diagnostic: {
-          message: md`Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
-          origin: '@atlaspack/core',
-          codeFrames: keyPath
-            ? [
-                {
-                  filePath: configPath,
-                  language: 'json5',
-                  code: configContents,
-                  codeHighlights: generateJSONCodeHighlights(configContents, [
-                    {
-                      key: keyPath,
-                      type: 'value',
-                    },
-                  ]),
-                },
-              ]
-            : undefined,
-        },
-      });
-    }
-
-    let configPkg = await loadConfig(
-      options.inputFS,
-      resolveFrom,
-      ['package.json'],
-      options.projectRoot,
-    );
-    if (
-      configPkg != null &&
-      configPkg.config.dependencies?.[pluginName] == null
-    ) {
-      // If not in the config's dependencies, the plugin will be auto installed with
-      // the version declared in "parcelDependencies".
-      range = configPkg.config.parcelDependencies?.[pluginName];
 
-      if (range == null) {
-        let contents = await options.inputFS.readFile(
-          configPkg.files[0].filePath,
-          'utf8',
-        );
-        throw new ThrowableDiagnostic({
-          diagnostic: {
-            message: md`Could not determine version of ${pluginName} in ${path.relative(
-              process.cwd(),
-              resolveFrom,
-            )}. Either include it in "dependencies" or "parcelDependencies".`,
-            origin: '@atlaspack/core',
-            codeFrames:
-              configPkg.config.dependencies ||
-              configPkg.config.parcelDependencies
-                ? [
-                    {
-                      filePath: configPkg.files[0].filePath,
-                      language: 'json5',
-                      code: contents,
-                      codeHighlights: generateJSONCodeHighlights(contents, [
-                        {
-                          key: configPkg.config.parcelDependencies
-                            ? '/parcelDependencies'
-                            : '/dependencies',
-                          type: 'key',
-                        },
-                      ]),
-                    },
-                  ]
-                : undefined,
-          },
-        });
-      }
-
-      // Resolve from project root if not in the config's dependencies.
-      resolveFrom = path.join(options.projectRoot, 'index');
-    }
+  // Config packages can reference plugins, but cannot contain other plugins within them.
+  // This forces every published plugin to be published separately so they can be mixed and matched if needed.
+  if (resolveFrom.includes(NODE_MODULES) && pluginName.startsWith('.')) {
+    let configContents = await options.inputFS.readFile(configPath, 'utf8');
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        message: md`Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
+        origin: '@atlaspack/core',
+        codeFrames: keyPath
+          ? [
+              {
+                filePath: configPath,
+                language: 'json5',
+                code: configContents,
+                codeHighlights: generateJSONCodeHighlights(configContents, [
+                  {
+                    key: keyPath,
+                    type: 'value',
+                  },
+                ]),
+              },
+            ]
+          : undefined,
+      },
+    });
   }
 
   let resolved, pkg;
@@ -126,10 +61,7 @@ export default async function loadPlugin<T>(
     ({resolved, pkg} = await options.packageManager.resolve(
       pluginName,
       resolveFrom,
-      {
-        shouldAutoInstall: options.shouldAutoInstall,
-        range,
-      },
+      {shouldAutoInstall: options.shouldAutoInstall},
     ));
   } catch (err) {
     if (err.code !== 'MODULE_NOT_FOUND') {
@@ -242,6 +174,5 @@ export default async function loadPlugin<T>(
     plugin,
     version: nullthrows(pkg).version,
     resolveFrom: toProjectPath(options.projectRoot, resolveFrom),
-    range,
   };
 }

package/src/projectPath.js

@@ -2,19 +2,27 @@
 import type {FilePath} from '@atlaspack/types';
 import path from 'path';
 import {relativePath, normalizeSeparators} from '@atlaspack/utils';
+import {getFeatureFlagValue} from '@atlaspack/feature-flags';
 
 /**
  * A path that's relative to the project root.
  */
 export opaque type ProjectPath = string;
 
+/**
+ * Converts a file path to a project-relative path.
+ *
+ * @param projectRoot - The project root.
+ * @param p - The file path to convert.
+ * @returns The project path.
+ */
 function toProjectPath_(projectRoot: FilePath, p: FilePath): ProjectPath {
   // If the file path is not provided, then treat it as though it is already from the project root
   if (p == null) {
     return p;
   }
 
-  // If the file path is already relative and it does not begin with . then treat the path as if it
+  // If the file path is already relative and it does not begin with '.', then treat the path as if it
   // is already from the project root. This prevents relative paths from being processed twice,
   // most often within `toInternalSourceLocation` when handling loc types from symbols and asset
   // dependencies.
@@ -27,6 +35,11 @@ function toProjectPath_(projectRoot: FilePath, p: FilePath): ProjectPath {
   // the project root is not portable anyway.
   let relative = relativePath(projectRoot, p, false);
   if (relative.startsWith('..')) {
+    // e.g given projectRoot = '/Users/monorepo/project' and p = '/Users/monorepo/other-project/src/index.js' --> relative = '../other-project/src/index.js'
+    if (getFeatureFlagValue('patchProjectPaths')) {
+      return relative;
+    }
+
     return process.platform === 'win32' ? normalizeSeparators(p) : p;
   }
 

package/src/requests/AtlaspackBuildRequest.js

@@ -61,7 +61,7 @@ export default function createAtlaspackBuildRequest(
   };
 }
 
-async function run({input, api, options}) {
+async function run({input, api, options, rustAtlaspack}) {
   let {optionsRef, requestedAssetIds, signal} = input;
 
   let bundleGraphRequest = createBundleGraphRequest({
@@ -72,7 +72,9 @@ async function run({input, api, options}) {
 
   let {bundleGraph, changedAssets, assetRequests}: BundleGraphResult =
     await api.runRequest(bundleGraphRequest, {
-      force: options.shouldBuildLazily && requestedAssetIds.size > 0,
+      force:
+        Boolean(rustAtlaspack) ||
+        (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
 
   // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)

package/src/requests/BundleGraphRequest.js

@@ -163,7 +163,9 @@ export default function createBundleGraphRequest(
       let {assetGraph, changedAssets, assetRequests} = await api.runRequest(
         request,
         {
-          force: options.shouldBuildLazily && requestedAssetIds.size > 0,
+          force:
+            Boolean(input.rustAtlaspack) ||
+            (options.shouldBuildLazily && requestedAssetIds.size > 0),
         },
       );