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

package/lib/loadAtlaspackPlugin.js

@@ -41,47 +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;
-  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) {
-      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)}. Include it in "dependencies".`,
-          origin: '@atlaspack/core',
-          codeFrames: configPkg.config.dependencies ? [{
-            filePath: configPkg.files[0].filePath,
-            language: 'json5',
-            code: contents,
-            codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(contents, [{
-              key: '/dependencies',
-              type: 'key'
-            }])
-          }] : undefined
-        }
-      });
-    }
+
+  // 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 {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.13.2-dev.3682+e6c0286ea",
+  "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.3682+e6c0286ea",
-    "@atlaspack/cache": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/diagnostic": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/events": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/feature-flags": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/fs": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/graph": "3.3.2-dev.3682+e6c0286ea",
-    "@atlaspack/logger": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/package-manager": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/plugin": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/profiler": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/rust": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/types": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/utils": "2.13.2-dev.3682+e6c0286ea",
-    "@atlaspack/workers": "2.13.2-dev.3682+e6c0286ea",
+    "@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": "e6c0286ea2a77c6a41c6c0f38d51caf420d61aae"
+  "gitHead": "7a2e6e7835fa846b27021b374097c6a4f37541ba"
 }

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

@@ -10,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';
 
@@ -32,73 +28,32 @@ export default async function loadPlugin<T>(
   resolveFrom: ProjectPath,
 |}> {
   let resolveFrom = configPath;
-  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
-    ) {
-      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,
-          )}. Include it in "dependencies".`,
-          origin: '@atlaspack/core',
-          codeFrames: configPkg.config.dependencies
-            ? [
-                {
-                  filePath: configPkg.files[0].filePath,
-                  language: 'json5',
-                  code: contents,
-                  codeHighlights: generateJSONCodeHighlights(contents, [
-                    {
-                      key: '/dependencies',
-                      type: 'key',
-                    },
-                  ]),
-                },
-              ]
-            : undefined,
-        },
-      });
-    }
+  // 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;

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;
   }