isLocalImport doesn’t need root

Author: mbostock

src/javascript/features.ts

@@ -16,7 +16,7 @@ export function findFeatures(node, root, sourcePath, references, input) {
       } = node;
 
       // Promote fetches with static literals to file attachment references.
-      if (isLocalFetch(node, references, root, sourcePath)) {
+      if (isLocalFetch(node, references, sourcePath)) {
         features.push({type: "FileAttachment", name: getStringLiteralValue(arg)});
         return;
       }
@@ -50,7 +50,7 @@ export function findFeatures(node, root, sourcePath, references, input) {
   return features;
 }
 
-export function isLocalFetch(node, references, root, sourcePath) {
+export function isLocalFetch(node, references, sourcePath) {
   if (node.type !== "CallExpression") return false;
   const {
     callee,
@@ -61,7 +61,7 @@ export function isLocalFetch(node, references, root, sourcePath) {
     callee.name === "fetch" &&
     !references.includes(callee) &&
     isStringLiteral(arg) &&
-    isLocalImport(getStringLiteralValue(arg), root, sourcePath)
+    isLocalImport(getStringLiteralValue(arg), sourcePath)
   );
 }
 

src/javascript/fetches.ts

@@ -4,7 +4,7 @@ import {isLocalFetch} from "./features.js";
 export function rewriteFetches(output, rootNode, root, sourcePath) {
   simple(rootNode.body, {
     CallExpression(node) {
-      if (isLocalFetch(node, rootNode.references, root, sourcePath)) {
+      if (isLocalFetch(node, rootNode.references, sourcePath)) {
         output.insertLeft(node.arguments[0].start + 3, "_file/");
       }
     }

src/javascript/imports.ts

@@ -32,7 +32,7 @@ export function findImports(body: Node, root: string, sourcePath: string) {
   function findImport(node) {
     if (isStringLiteral(node.source)) {
       const value = getStringLiteralValue(node.source);
-      if (isLocalImport(value, root, sourcePath)) {
+      if (isLocalImport(value, sourcePath)) {
         findLocalImports(normalize(value));
       } else {
         imports.push({name: value, type: "global"});
@@ -62,7 +62,7 @@ export function findImports(body: Node, root: string, sourcePath: string) {
     function findLocalImport(node) {
       if (isStringLiteral(node.source)) {
         const value = getStringLiteralValue(node.source);
-        if (isLocalImport(value, root, sourcePath)) {
+        if (isLocalImport(value, sourcePath)) {
           findLocalImports(join(dirname(path), value));
         } else {
           imports.push({name: value, type: "global"});
@@ -78,21 +78,21 @@ export function findImports(body: Node, root: string, sourcePath: string) {
 // TODO parallelize multiple static imports
 export function rewriteImports(output: any, rootNode: JavaScriptNode, root: string, sourcePath: string) {
   simple(rootNode.body, {
-    ImportExpression(node: any) {
+    ImportExpression(node) {
       if (isStringLiteral(node.source)) {
         const value = getStringLiteralValue(node.source);
         output.replaceLeft(
           node.source.start,
           node.source.end,
           JSON.stringify(
-            isLocalImport(value, root, sourcePath)
+            isLocalImport(value, sourcePath)
               ? join("/_import/", join(dirname(sourcePath), value))
               : resolveImport(value)
           )
         );
       }
     },
-    ImportDeclaration(node: any) {
+    ImportDeclaration(node) {
       if (isStringLiteral(node.source)) {
         const value = getStringLiteralValue(node.source);
         rootNode.async = true;
@@ -102,11 +102,9 @@ export function rewriteImports(output: any, rootNode: JavaScriptNode, root: stri
           `const ${
             node.specifiers.some(isNotNamespaceSpecifier)
               ? `{${node.specifiers.filter(isNotNamespaceSpecifier).map(rewriteImportSpecifier).join(", ")}}`
-              : node.specifiers.some(isNamespaceSpecifier)
-              ? node.specifiers.find(isNamespaceSpecifier).local.name
-              : "{}"
+              : node.specifiers.find(isNamespaceSpecifier)?.local.name ?? "{}"
           } = await import(${JSON.stringify(
-            isLocalImport(value, root, sourcePath)
+            isLocalImport(value, sourcePath)
               ? join("/_import/", join(dirname(sourcePath), value))
               : resolveImport(value)
           )});`
@@ -124,10 +122,10 @@ function rewriteImportSpecifier(node) {
     : `${node.imported.name}: ${node.local.name}`;
 }
 
-export function isLocalImport(value: string, root: string, sourcePath: string): boolean {
+export function isLocalImport(value: string, sourcePath: string): boolean {
   return (
     ["./", "../", "/"].some((prefix) => value.startsWith(prefix)) &&
-    join(root + "/", dirname(sourcePath), value).startsWith(root)
+    !join(".", dirname(sourcePath), value).startsWith("../")
   );
 }
 

test/isLocalImport-test.ts

@@ -12,31 +12,31 @@ describe("isLocalImport", () => {
     const sourcePath = "/hello.md";
     const importValue = "./helpers.js";
     assert.equal(pathFromRoot(importValue, root, sourcePath), "docs/helpers.js");
-    assert(isLocalImport(importValue, root, sourcePath));
+    assert(isLocalImport(importValue, sourcePath));
   });
 
   it("relative paths are correctly handled", async () => {
     const root = "docs";
     const sourcePath = "/subDocs/hello.md";
     const importValue = "./helpers.js";
     assert.equal(pathFromRoot(importValue, root, sourcePath), "docs/subDocs/helpers.js");
-    assert(isLocalImport(importValue, root, sourcePath));
+    assert(isLocalImport(importValue, sourcePath));
   });
 
   it("root and sourcePath arguments can correctly handle slashes", async () => {
     const root = "docs/";
     const sourcePath = "/hello.md/";
     const importValue = "./helpers.js";
     assert.equal(pathFromRoot(importValue, root, sourcePath), "docs/helpers.js");
-    assert(isLocalImport(importValue, root, sourcePath));
+    assert(isLocalImport(importValue, sourcePath));
   });
 
   it("identifies a local import from a nested sourcePath", async () => {
     const root = "docs";
     const sourcePath = "/subDocs/subDocs2/hello.md";
     const importValue = "../../random.js";
     assert.equal(pathFromRoot(importValue, root, sourcePath), "docs/random.js");
-    assert(isLocalImport(importValue, root, sourcePath));
+    assert(isLocalImport(importValue, sourcePath));
   });
 
   it("cannot go to an ancestor directory beyond the root", async () => {
@@ -45,14 +45,14 @@ describe("isLocalImport", () => {
 
     const importValue1 = "../../../random.js";
     assert.equal(pathFromRoot(importValue1, root, sourcePath), "../../random.js");
-    assert.equal(isLocalImport(importValue1, root, sourcePath), false);
+    assert.equal(isLocalImport(importValue1, sourcePath), false);
 
     const importValue2 = "./../../random.js";
     assert.equal(pathFromRoot(importValue2, root, sourcePath), "../random.js");
-    assert.equal(isLocalImport(importValue2, root, sourcePath), false);
+    assert.equal(isLocalImport(importValue2, sourcePath), false);
 
     const importValue3 = "/../../random.js";
     assert.equal(pathFromRoot(importValue3, root, sourcePath), "../random.js");
-    assert.equal(isLocalImport(importValue3, root, sourcePath), false);
+    assert.equal(isLocalImport(importValue3, sourcePath), false);
   });
 });