@atlaspack/core 2.12.1-canary.3452 → 2.12.1-canary.3454

package/lib/SymbolPropagation.js

@@ -438,15 +438,7 @@ function propagateSymbolsDown(assetGraph, changedAssets, assetGroupsWithRemovedP
       wasNodeDirty = node.usedSymbolsDownDirty;
       node.usedSymbolsDownDirty = false;
     } else if (node.type === 'asset' && node.usedSymbolsDownDirty) {
-      visit(node, assetGraph.getIncomingDependencies(node.value).map(d => {
-        let dep = assetGraph.getNodeByContentKey(d.id);
-        (0, _assert().default)(dep && dep.type === 'dependency');
-        return dep;
-      }), outgoing.map(dep => {
-        let depNode = (0, _nullthrows().default)(assetGraph.getNode(dep));
-        (0, _assert().default)(depNode.type === 'dependency');
-        return depNode;
-      }));
+      visit(node, incomingDependencyNodesFromAsset(assetGraph, node.value), dependencyNodesFromIds(assetGraph, outgoing));
       node.usedSymbolsDownDirty = false;
     }
     for (let child of outgoing) {
@@ -494,23 +486,15 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
     let rootNodeId = (0, _nullthrows().default)(assetGraph.rootNodeId, 'A root node is required to traverse');
     const nodeVisitor = nodeId => {
       let node = (0, _nullthrows().default)(assetGraph.getNode(nodeId));
-      let outgoing = assetGraph.getNodeIdsConnectedFrom(nodeId);
-      for (let childId of outgoing) {
-        let child = (0, _nullthrows().default)(assetGraph.getNode(childId));
-        if (node.type === 'asset') {
-          (0, _assert().default)(child.type === 'dependency');
+      if (node.type === 'asset') {
+        let outgoing = outgoingDependencyNodesFromAsset(assetGraph, nodeId);
+        for (let child of outgoing) {
           if (child.usedSymbolsUpDirtyUp) {
             node.usedSymbolsUpDirty = true;
             child.usedSymbolsUpDirtyUp = false;
           }
         }
-      }
-      if (node.type === 'asset') {
-        let incoming = assetGraph.getIncomingDependencies(node.value).map(d => {
-          let n = assetGraph.getNodeByContentKey(d.id);
-          (0, _assert().default)(n && n.type === 'dependency');
-          return n;
-        });
+        let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
         for (let dep of incoming) {
           if (dep.usedSymbolsUpDirtyDown) {
             dep.usedSymbolsUpDirtyDown = false;
@@ -518,11 +502,7 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
           }
         }
         if (node.usedSymbolsUpDirty) {
-          let e = visit(node, incoming, outgoing.map(depNodeId => {
-            let depNode = (0, _nullthrows().default)(assetGraph.getNode(depNodeId));
-            (0, _assert().default)(depNode.type === 'dependency');
-            return depNode;
-          }));
+          let e = visit(node, incoming, outgoing);
           if (e.length > 0) {
             node.usedSymbolsUpDirty = true;
             errors.set(nodeId, e);
@@ -548,22 +528,14 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
     let queuedNodeId = setPop(queue);
     let node = (0, _nullthrows().default)(assetGraph.getNode(queuedNodeId));
     if (node.type === 'asset') {
-      let incoming = assetGraph.getIncomingDependencies(node.value).map(dep => {
-        let depNode = assetGraph.getNodeByContentKey(dep.id);
-        (0, _assert().default)(depNode && depNode.type === 'dependency');
-        return depNode;
-      });
+      let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
       for (let dep of incoming) {
         if (dep.usedSymbolsUpDirtyDown) {
           dep.usedSymbolsUpDirtyDown = false;
           node.usedSymbolsUpDirty = true;
         }
       }
-      let outgoing = assetGraph.getNodeIdsConnectedFrom(queuedNodeId).map(depNodeId => {
-        let depNode = (0, _nullthrows().default)(assetGraph.getNode(depNodeId));
-        (0, _assert().default)(depNode.type === 'dependency');
-        return depNode;
-      });
+      let outgoing = outgoingDependencyNodesFromAsset(assetGraph, queuedNodeId);
       for (let dep of outgoing) {
         if (dep.usedSymbolsUpDirtyUp) {
           node.usedSymbolsUpDirty = true;
@@ -622,4 +594,21 @@ function setPop(set) {
   let v = (0, _nullthrows().default)(set.values().next().value);
   set.delete(v);
   return v;
+}
+function outgoingDependencyNodesFromAsset(assetGraph, assetNode) {
+  return dependencyNodesFromIds(assetGraph, assetGraph.getNodeIdsConnectedFrom(assetNode));
+}
+function dependencyNodesFromIds(assetGraph, dependencyIds) {
+  return dependencyIds.map(depNodeId => {
+    let depNode = (0, _nullthrows().default)(assetGraph.getNode(depNodeId));
+    (0, _assert().default)(depNode.type === 'dependency');
+    return depNode;
+  });
+}
+function incomingDependencyNodesFromAsset(assetGraph, assetNodeValue) {
+  return assetGraph.getIncomingDependencies(assetNodeValue).map(d => {
+    let n = assetGraph.getNodeByContentKey(d.id);
+    (0, _assert().default)(n && n.type === 'dependency');
+    return n;
+  });
 }

package/lib/projectPath.js

@@ -27,14 +27,22 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * A path that's relative to the project root.
  */
 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 is outside the project root, store an absolute path rather
-  // than a relative one. This way if the project root is moved, the file
-  // references still work. Accessing files outside the project root is not
-  // portable anyway.
+  // 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.
+  if (p[0] !== '.' && !_path().default.isAbsolute(p)) {
+    return p;
+  }
+
+  // If the file is outside the project root, store an absolute path rather than a relative one.
+  // This way if the project root is moved, the file references still work. Accessing files outside
+  // the project root is not portable anyway.
   let relative = (0, _utils().relativePath)(projectRoot, p, false);
   if (relative.startsWith('..')) {
     return process.platform === 'win32' ? (0, _utils().normalizeSeparators)(p) : p;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3452+2005ceb39",
+  "version": "2.12.1-canary.3454+731e572aa",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/diagnostic": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/events": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/feature-flags": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/fs": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/graph": "3.2.1-canary.3452+2005ceb39",
-    "@atlaspack/logger": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/package-manager": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/plugin": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/profiler": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/rust": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/types": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/utils": "2.12.1-canary.3452+2005ceb39",
-    "@atlaspack/workers": "2.12.1-canary.3452+2005ceb39",
+    "@atlaspack/cache": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/diagnostic": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/events": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/feature-flags": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/fs": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/graph": "3.2.1-canary.3454+731e572aa",
+    "@atlaspack/logger": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/package-manager": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/plugin": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/profiler": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/rust": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/types": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/utils": "2.12.1-canary.3454+731e572aa",
+    "@atlaspack/workers": "2.12.1-canary.3454+731e572aa",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "2005ceb391fdbf7ed5eb20d1549d3b721ccb6d95"
+  "gitHead": "731e572aae21fde994cedbf6485fbfbc1d497078"
 }

package/src/SymbolPropagation.js

@@ -558,16 +558,8 @@ function propagateSymbolsDown(
     } else if (node.type === 'asset' && node.usedSymbolsDownDirty) {
       visit(
         node,
-        assetGraph.getIncomingDependencies(node.value).map((d) => {
-          let dep = assetGraph.getNodeByContentKey(d.id);
-          invariant(dep && dep.type === 'dependency');
-          return dep;
-        }),
-        outgoing.map((dep) => {
-          let depNode = nullthrows(assetGraph.getNode(dep));
-          invariant(depNode.type === 'dependency');
-          return depNode;
-        }),
+        incomingDependencyNodesFromAsset(assetGraph, node.value),
+        dependencyNodesFromIds(assetGraph, outgoing),
       );
       node.usedSymbolsDownDirty = false;
     }
@@ -645,27 +637,16 @@ function propagateSymbolsUp(
 
     const nodeVisitor = (nodeId) => {
       let node = nullthrows(assetGraph.getNode(nodeId));
-      let outgoing = assetGraph.getNodeIdsConnectedFrom(nodeId);
 
-      for (let childId of outgoing) {
-        let child = nullthrows(assetGraph.getNode(childId));
-        if (node.type === 'asset') {
-          invariant(child.type === 'dependency');
+      if (node.type === 'asset') {
+        let outgoing = outgoingDependencyNodesFromAsset(assetGraph, nodeId);
+        for (let child of outgoing) {
           if (child.usedSymbolsUpDirtyUp) {
             node.usedSymbolsUpDirty = true;
             child.usedSymbolsUpDirtyUp = false;
           }
         }
-      }
-
-      if (node.type === 'asset') {
-        let incoming = assetGraph
-          .getIncomingDependencies(node.value)
-          .map((d) => {
-            let n = assetGraph.getNodeByContentKey(d.id);
-            invariant(n && n.type === 'dependency');
-            return n;
-          });
+        let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
         for (let dep of incoming) {
           if (dep.usedSymbolsUpDirtyDown) {
             dep.usedSymbolsUpDirtyDown = false;
@@ -673,15 +654,7 @@ function propagateSymbolsUp(
           }
         }
         if (node.usedSymbolsUpDirty) {
-          let e = visit(
-            node,
-            incoming,
-            outgoing.map((depNodeId) => {
-              let depNode = nullthrows(assetGraph.getNode(depNodeId));
-              invariant(depNode.type === 'dependency');
-              return depNode;
-            }),
-          );
+          let e = visit(node, incoming, outgoing);
           if (e.length > 0) {
             node.usedSymbolsUpDirty = true;
             errors.set(nodeId, e);
@@ -708,26 +681,14 @@ function propagateSymbolsUp(
     let queuedNodeId = setPop(queue);
     let node = nullthrows(assetGraph.getNode(queuedNodeId));
     if (node.type === 'asset') {
-      let incoming = assetGraph
-        .getIncomingDependencies(node.value)
-        .map((dep) => {
-          let depNode = assetGraph.getNodeByContentKey(dep.id);
-          invariant(depNode && depNode.type === 'dependency');
-          return depNode;
-        });
+      let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
       for (let dep of incoming) {
         if (dep.usedSymbolsUpDirtyDown) {
           dep.usedSymbolsUpDirtyDown = false;
           node.usedSymbolsUpDirty = true;
         }
       }
-      let outgoing = assetGraph
-        .getNodeIdsConnectedFrom(queuedNodeId)
-        .map((depNodeId) => {
-          let depNode = nullthrows(assetGraph.getNode(depNodeId));
-          invariant(depNode.type === 'dependency');
-          return depNode;
-        });
+      let outgoing = outgoingDependencyNodesFromAsset(assetGraph, queuedNodeId);
       for (let dep of outgoing) {
         if (dep.usedSymbolsUpDirtyUp) {
           node.usedSymbolsUpDirty = true;
@@ -799,3 +760,26 @@ function setPop<T>(set: Set<T>): T {
   set.delete(v);
   return v;
 }
+
+function outgoingDependencyNodesFromAsset(assetGraph, assetNode) {
+  return dependencyNodesFromIds(
+    assetGraph,
+    assetGraph.getNodeIdsConnectedFrom(assetNode),
+  );
+}
+
+function dependencyNodesFromIds(assetGraph, dependencyIds) {
+  return dependencyIds.map((depNodeId) => {
+    let depNode = nullthrows(assetGraph.getNode(depNodeId));
+    invariant(depNode.type === 'dependency');
+    return depNode;
+  });
+}
+
+function incomingDependencyNodesFromAsset(assetGraph, assetNodeValue) {
+  return assetGraph.getIncomingDependencies(assetNodeValue).map((d) => {
+    let n = assetGraph.getNodeByContentKey(d.id);
+    invariant(n && n.type === 'dependency');
+    return n;
+  });
+}

package/src/projectPath.js

@@ -9,14 +9,22 @@ import {relativePath, normalizeSeparators} from '@atlaspack/utils';
 export opaque type ProjectPath = string;
 
 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 is outside the project root, store an absolute path rather
-  // than a relative one. This way if the project root is moved, the file
-  // references still work. Accessing files outside the project root is not
-  // portable anyway.
+  // 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.
+  if (p[0] !== '.' && !path.isAbsolute(p)) {
+    return p;
+  }
+
+  // If the file is outside the project root, store an absolute path rather than a relative one.
+  // This way if the project root is moved, the file references still work. Accessing files outside
+  // the project root is not portable anyway.
   let relative = relativePath(projectRoot, p, false);
   if (relative.startsWith('..')) {
     return process.platform === 'win32' ? normalizeSeparators(p) : p;

package/test/requests/ConfigRequest.test.js

@@ -229,10 +229,7 @@ describe('ConfigRequest tests', () => {
       invalidateOnConfigKeyChange: [
         {
           configKey: 'key1',
-          filePath: toProjectPath(
-            projectRoot,
-            path.join('project_root', 'config.json'),
-          ),
+          filePath: toProjectPath(projectRoot, 'config.json'),
         },
       ],
     });