@jsenv/ast 3.0.7 → 3.0.8

package/src/js/js_static_analysis/helpers.js

@@ -1,17 +1,17 @@
 export const getTypePropertyNode = (node) => {
   if (node.type !== "ObjectExpression") {
-    return null
+    return null;
   }
-  const { properties } = node
+  const { properties } = node;
   return properties.find((property) => {
     return (
       property.type === "Property" &&
       property.key.type === "Identifier" &&
       property.key.name === "type"
-    )
-  })
-}
+    );
+  });
+};
 
 export const isStringLiteralNode = (node) => {
-  return node.type === "Literal" && typeof node.value === "string"
-}
+  return node.type === "Literal" && typeof node.value === "string";
+};

package/src/js/js_static_analysis/import_export.js

@@ -1,8 +1,8 @@
-import { isStringLiteralNode } from "./helpers.js"
+import { isStringLiteralNode } from "./helpers.js";
 
 export const analyzeImportDeclaration = (node, { onUrl }) => {
-  const specifierNode = node.source
-  const assertionInfo = extractImportAssertionsInfo(node)
+  const specifierNode = node.source;
+  const assertionInfo = extractImportAssertionsInfo(node);
   onUrl({
     type: "js_import",
     subtype: "import_static",
@@ -13,14 +13,14 @@ export const analyzeImportDeclaration = (node, { onUrl }) => {
     column: specifierNode.loc.start.column,
     expectedType: assertionInfo ? assertionInfo.assert.type : "js_module",
     ...assertionInfo,
-  })
-}
+  });
+};
 export const analyzeImportExpression = (node, { onUrl }) => {
-  const specifierNode = node.source
+  const specifierNode = node.source;
   if (!isStringLiteralNode(specifierNode)) {
-    return
+    return;
   }
-  const assertionInfo = extractImportAssertionsInfo(node)
+  const assertionInfo = extractImportAssertionsInfo(node);
 
   onUrl({
     type: "js_import",
@@ -32,17 +32,17 @@ export const analyzeImportExpression = (node, { onUrl }) => {
     column: specifierNode.loc.start.column,
     expectedType: assertionInfo ? assertionInfo.assert.type : "js_module",
     ...assertionInfo,
-  })
-}
+  });
+};
 export const analyzeExportNamedDeclaration = (node, { onUrl }) => {
-  const specifierNode = node.source
+  const specifierNode = node.source;
   if (!specifierNode) {
     // This export has no "source", so it's probably
     // a local variable or function, e.g.
     // export { varName }
     // export const constName = ...
     // export function funcName() {}
-    return
+    return;
   }
   onUrl({
     type: "js_import",
@@ -52,10 +52,10 @@ export const analyzeExportNamedDeclaration = (node, { onUrl }) => {
     end: specifierNode.end,
     line: specifierNode.loc.start.line,
     column: specifierNode.loc.start.column,
-  })
-}
+  });
+};
 export const analyzeExportAllDeclaration = (node, { onUrl }) => {
-  const specifierNode = node.source
+  const specifierNode = node.source;
   onUrl({
     type: "js_import",
     subtype: "export_all",
@@ -64,72 +64,72 @@ export const analyzeExportAllDeclaration = (node, { onUrl }) => {
     end: specifierNode.end,
     line: specifierNode.loc.start.line,
     column: specifierNode.loc.start.column,
-  })
-}
+  });
+};
 
 const extractImportAssertionsInfo = (node) => {
   if (node.type === "ImportDeclaration") {
     // static import
-    const { assertions } = node
+    const { assertions } = node;
     if (!assertions) {
-      return null
+      return null;
     }
     if (assertions.length === 0) {
-      return null
+      return null;
     }
     const typeAssertionNode = assertions.find(
       (assertion) => assertion.key.name === "type",
-    )
+    );
     if (!typeAssertionNode) {
-      return null
+      return null;
     }
-    const typeNode = typeAssertionNode.value
+    const typeNode = typeAssertionNode.value;
     if (!isStringLiteralNode(typeNode)) {
-      return null
+      return null;
     }
     return {
       assertNode: typeAssertionNode,
       assert: {
         type: typeNode.value,
       },
-    }
+    };
   }
   // dynamic import
-  const args = node.arguments
+  const args = node.arguments;
   if (!args) {
     // acorn keeps node.arguments undefined for dynamic import without a second argument
-    return null
+    return null;
   }
-  const firstArgNode = args[0]
+  const firstArgNode = args[0];
   if (!firstArgNode) {
-    return null
+    return null;
   }
-  const { properties } = firstArgNode
+  const { properties } = firstArgNode;
   const assertProperty = properties.find((property) => {
-    return property.key.name === "assert"
-  })
+    return property.key.name === "assert";
+  });
   if (!assertProperty) {
-    return null
+    return null;
   }
-  const assertValueNode = assertProperty.value
+  const assertValueNode = assertProperty.value;
   if (assertValueNode.type !== "ObjectExpression") {
-    return null
+    return null;
   }
-  const assertValueProperties = assertValueNode.properties
+  const assertValueProperties = assertValueNode.properties;
   const typePropertyNode = assertValueProperties.find((property) => {
-    return property.key.name === "type"
-  })
+    return property.key.name === "type";
+  });
   if (!typePropertyNode) {
-    return null
+    return null;
   }
-  const typePropertyValue = typePropertyNode.value
+  const typePropertyValue = typePropertyNode.value;
   if (!isStringLiteralNode(typePropertyValue)) {
-    return null
+    return null;
   }
   return {
     assertNode: firstArgNode,
     assert: {
       type: typePropertyValue.value,
     },
-  }
-}
+  };
+};

package/src/js/js_static_analysis/import_meta_resolve.js

@@ -1,4 +1,4 @@
-import { isStringLiteralNode } from "./helpers.js"
+import { isStringLiteralNode } from "./helpers.js";
 
 export const isImportMetaResolveCall = (node) => {
   return (
@@ -7,11 +7,11 @@ export const isImportMetaResolveCall = (node) => {
     node.callee.object.type === "MetaProperty" &&
     node.callee.property.type === "Identifier" &&
     node.callee.property.name === "resolve"
-  )
-}
+  );
+};
 
 export const analyzeImportMetaResolveCall = (node, { onUrl }) => {
-  const firstArg = node.arguments[0]
+  const firstArg = node.arguments[0];
   if (firstArg && isStringLiteralNode(firstArg)) {
     onUrl({
       node,
@@ -22,6 +22,6 @@ export const analyzeImportMetaResolveCall = (node, { onUrl }) => {
       end: firstArg.end,
       line: firstArg.loc.start.line,
       column: firstArg.loc.start.column,
-    })
+    });
   }
-}
+};

package/src/js/js_static_analysis/new_url.js

@@ -1,18 +1,18 @@
-import { isStringLiteralNode } from "./helpers.js"
+import { isStringLiteralNode } from "./helpers.js";
 
 export const isNewUrlCall = (node) => {
   return (
     node.type === "NewExpression" &&
     node.callee.type === "Identifier" &&
     node.callee.name === "URL"
-  )
-}
+  );
+};
 export const analyzeNewUrlCall = (node, { isJsModule, onUrl }) => {
   if (node.arguments.length === 1) {
-    const firstArgNode = node.arguments[0]
-    const urlType = analyzeUrlNodeType(firstArgNode, { isJsModule })
+    const firstArgNode = node.arguments[0];
+    const urlType = analyzeUrlNodeType(firstArgNode, { isJsModule });
     if (urlType === "StringLiteral") {
-      const specifierNode = firstArgNode
+      const specifierNode = firstArgNode;
       onUrl({
         type: "js_url",
         subtype: "new_url_first_arg",
@@ -21,14 +21,14 @@ export const analyzeNewUrlCall = (node, { isJsModule, onUrl }) => {
         end: specifierNode.end,
         line: specifierNode.loc.start.line,
         column: specifierNode.loc.start.column,
-      })
+      });
     }
-    return
+    return;
   }
   if (node.arguments.length === 2) {
-    const firstArgNode = node.arguments[0]
-    const secondArgNode = node.arguments[1]
-    const baseUrlType = analyzeUrlNodeType(secondArgNode, { isJsModule })
+    const firstArgNode = node.arguments[0];
+    const secondArgNode = node.arguments[1];
+    const baseUrlType = analyzeUrlNodeType(secondArgNode, { isJsModule });
     if (baseUrlType) {
       // we can understand the second argument
       if (
@@ -36,12 +36,12 @@ export const analyzeNewUrlCall = (node, { isJsModule, onUrl }) => {
         secondArgNode.value === "file:///"
       ) {
         // ignore new URL(specifier, "file:///")
-        return
+        return;
       }
-      const urlType = analyzeUrlNodeType(firstArgNode, { isJsModule })
+      const urlType = analyzeUrlNodeType(firstArgNode, { isJsModule });
       if (urlType === "StringLiteral") {
         // we can understand the first argument
-        const specifierNode = firstArgNode
+        const specifierNode = firstArgNode;
         onUrl({
           type: "js_url",
           subtype: "new_url_first_arg",
@@ -53,10 +53,10 @@ export const analyzeNewUrlCall = (node, { isJsModule, onUrl }) => {
           baseUrlType,
           baseUrl:
             baseUrlType === "StringLiteral" ? secondArgNode.value : undefined,
-        })
+        });
       }
       if (baseUrlType === "StringLiteral") {
-        const specifierNode = secondArgNode
+        const specifierNode = secondArgNode;
         onUrl({
           type: "js_url",
           subtype: "new_url_second_arg",
@@ -65,31 +65,31 @@ export const analyzeNewUrlCall = (node, { isJsModule, onUrl }) => {
           end: specifierNode.end,
           line: specifierNode.loc.start.line,
           column: specifierNode.loc.start.column,
-        })
+        });
       }
     }
   }
-}
+};
 
 const analyzeUrlNodeType = (secondArgNode, { isJsModule }) => {
   if (isStringLiteralNode(secondArgNode)) {
-    return "StringLiteral"
+    return "StringLiteral";
   }
   if (isImportMetaUrl(secondArgNode)) {
-    return "import.meta.url"
+    return "import.meta.url";
   }
   if (isWindowLocation(secondArgNode)) {
-    return "window.location"
+    return "window.location";
   }
   if (isWindowOrigin(secondArgNode)) {
-    return "window.origin"
+    return "window.origin";
   }
   if (!isJsModule && isContextMetaUrlFromSystemJs(secondArgNode)) {
-    return "context.meta.url"
+    return "context.meta.url";
   }
   if (!isJsModule) {
     if (isDocumentCurrentScriptSrc(secondArgNode)) {
-      return "document.currentScript.src"
+      return "document.currentScript.src";
     }
     // new URL('specifier', document.currentScript.src)
     // becomes
@@ -97,11 +97,11 @@ const analyzeUrlNodeType = (secondArgNode, { isJsModule }) => {
     // new URL('specifier', currentUrl)
     // (search for scope.generateUidIdentifier("currentUrl")
     if (secondArgNode.type === "Identifier") {
-      return "document.currentScript.src"
+      return "document.currentScript.src";
     }
   }
-  return null
-}
+  return null;
+};
 
 const isImportMetaUrl = (node) => {
   return (
@@ -109,8 +109,8 @@ const isImportMetaUrl = (node) => {
     node.object.type === "MetaProperty" &&
     node.property.type === "Identifier" &&
     node.property.name === "url"
-  )
-}
+  );
+};
 
 const isWindowLocation = (node) => {
   return (
@@ -119,8 +119,8 @@ const isWindowLocation = (node) => {
     node.object.name === "window" &&
     node.property.type === "Identifier" &&
     node.property.name === "location"
-  )
-}
+  );
+};
 
 const isWindowOrigin = (node) => {
   return (
@@ -129,8 +129,8 @@ const isWindowOrigin = (node) => {
     node.object.name === "window" &&
     node.property.type === "Identifier" &&
     node.property.name === "origin"
-  )
-}
+  );
+};
 
 const isContextMetaUrlFromSystemJs = (node) => {
   return (
@@ -145,8 +145,8 @@ const isContextMetaUrlFromSystemJs = (node) => {
     node.object.property.name === "meta" &&
     node.property.type === "Identifier" &&
     node.property.name === "url"
-  )
-}
+  );
+};
 
 const isDocumentCurrentScriptSrc = (node) => {
   return (
@@ -158,5 +158,5 @@ const isDocumentCurrentScriptSrc = (node) => {
     node.object.property.name === "currentScript" &&
     node.property.type === "Identifier" &&
     node.property.name === "src"
-  )
-}
+  );
+};

package/src/js/js_static_analysis/system.js

@@ -1,34 +1,34 @@
-import { isStringLiteralNode } from "./helpers.js"
+import { isStringLiteralNode } from "./helpers.js";
 
 export const isSystemRegisterCall = (node) => {
-  const callee = node.callee
+  const callee = node.callee;
   return (
     callee.type === "MemberExpression" &&
     callee.object.type === "Identifier" &&
     callee.object.name === "System" &&
     callee.property.type === "Identifier" &&
     callee.property.name === "register"
-  )
-}
+  );
+};
 export const analyzeSystemRegisterCall = (node, { onUrl }) => {
-  const firstArgNode = node.arguments[0]
+  const firstArgNode = node.arguments[0];
   if (firstArgNode.type === "ArrayExpression") {
-    analyzeSystemRegisterDeps(firstArgNode, { onUrl })
-    return
+    analyzeSystemRegisterDeps(firstArgNode, { onUrl });
+    return;
   }
   if (isStringLiteralNode(firstArgNode)) {
-    const secondArgNode = node.arguments[1]
+    const secondArgNode = node.arguments[1];
     if (secondArgNode.type === "ArrayExpression") {
-      analyzeSystemRegisterDeps(secondArgNode, { onUrl })
-      return
+      analyzeSystemRegisterDeps(secondArgNode, { onUrl });
+      return;
     }
   }
-}
+};
 const analyzeSystemRegisterDeps = (node, { onUrl }) => {
-  const elements = node.elements
+  const elements = node.elements;
   elements.forEach((element) => {
     if (isStringLiteralNode(element)) {
-      const specifierNode = element
+      const specifierNode = element;
       onUrl({
         type: "js_url",
         subtype: "system_register_arg",
@@ -38,13 +38,13 @@ const analyzeSystemRegisterDeps = (node, { onUrl }) => {
         end: specifierNode.end,
         line: specifierNode.loc.start.line,
         column: specifierNode.loc.start.column,
-      })
+      });
     }
-  })
-}
+  });
+};
 
 export const isSystemImportCall = (node) => {
-  const callee = node.callee
+  const callee = node.callee;
   return (
     callee.type === "MemberExpression" &&
     callee.object.type === "Identifier" &&
@@ -54,12 +54,12 @@ export const isSystemImportCall = (node) => {
     // callee.object.name === "_context" &&
     callee.property.type === "Identifier" &&
     callee.property.name === "import"
-  )
-}
+  );
+};
 export const analyzeSystemImportCall = (node, { onUrl }) => {
-  const firstArgNode = node.arguments[0]
+  const firstArgNode = node.arguments[0];
   if (isStringLiteralNode(firstArgNode)) {
-    const specifierNode = firstArgNode
+    const specifierNode = firstArgNode;
     onUrl({
       type: "js_url",
       subtype: "system_import_arg",
@@ -69,12 +69,12 @@ export const analyzeSystemImportCall = (node, { onUrl }) => {
       end: specifierNode.end,
       line: specifierNode.loc.start.line,
       column: specifierNode.loc.start.column,
-    })
+    });
   }
-}
+};
 
 export const isSystemResolveCall = (node) => {
-  const callee = node.callee
+  const callee = node.callee;
   return (
     callee.type === "MemberExpression" &&
     callee.object.type === "MemberExpression" &&
@@ -87,12 +87,12 @@ export const isSystemResolveCall = (node) => {
     callee.object.property.name === "meta" &&
     callee.property.type === "Identifier" &&
     callee.property.name === "resolve"
-  )
-}
+  );
+};
 export const analyzeSystemResolveCall = (node, { onUrl }) => {
-  const firstArgNode = node.arguments[0]
+  const firstArgNode = node.arguments[0];
   if (isStringLiteralNode(firstArgNode)) {
-    const specifierNode = firstArgNode
+    const specifierNode = firstArgNode;
     onUrl({
       type: "js_url",
       subtype: "system_resolve_arg",
@@ -101,6 +101,6 @@ export const analyzeSystemResolveCall = (node, { onUrl }) => {
       end: specifierNode.end,
       line: specifierNode.loc.start.line,
       column: specifierNode.loc.start.column,
-    })
+    });
   }
-}
+};

package/src/js/js_static_analysis/web_worker.js

@@ -1,9 +1,9 @@
-import { isStringLiteralNode } from "./helpers.js"
+import { isStringLiteralNode } from "./helpers.js";
 
 export const isImportScriptsCall = (node) => {
-  const callee = node.callee
+  const callee = node.callee;
   if (callee.type === "Identifier" && callee.name === "importScripts") {
-    return true
+    return true;
   }
   return (
     callee.type === "MemberExpression" &&
@@ -11,12 +11,12 @@ export const isImportScriptsCall = (node) => {
     callee.object.name === "self" &&
     callee.property.type === "Identifier" &&
     callee.property.name === "importScripts"
-  )
-}
+  );
+};
 export const analyzeImportScriptCalls = (node, { onUrl }) => {
   node.arguments.forEach((arg) => {
     if (isStringLiteralNode(arg)) {
-      const specifierNode = arg
+      const specifierNode = arg;
       onUrl({
         type: "js_url",
         subtype: "self_import_scripts_arg",
@@ -26,7 +26,7 @@ export const analyzeImportScriptCalls = (node, { onUrl }) => {
         end: specifierNode.end,
         line: specifierNode.loc.start.line,
         column: specifierNode.loc.start.column,
-      })
+      });
     }
-  })
-}
+  });
+};