@jsenv/ast 3.0.8 → 4.0.2

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@jsenv/ast",
-  "version": "3.0.8",
+  "version": "4.0.2",
   "description": "Parse and transform HTML,CSS and JS",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/jsenv/core",
-    "directory": "packages/ast"
+    "directory": "packages/rest/ast"
   },
   "publishConfig": {
     "access": "public"
@@ -35,7 +35,7 @@
   "dependencies": {
     "@babel/parser": "7.21.8",
     "acorn": "8.8.2",
-    "acorn-import-assertions": "1.8.0",
+    "acorn-import-assertions": "1.9.0",
     "acorn-walk": "8.2.0",
     "parse5": "7.1.2",
     "postcss": "8.4.23",

package/src/html/html_parse.js

@@ -61,7 +61,11 @@ export const parseHtmlString = (
 
 export const stringifyHtmlAst = (
   htmlAst,
-  { cleanupJsenvAttributes = false, cleanupPositionAttributes = false } = {},
+  {
+    preserveLineBreaks = true,
+    cleanupJsenvAttributes = false,
+    cleanupPositionAttributes = false,
+  } = {},
 ) => {
   if (cleanupJsenvAttributes || cleanupPositionAttributes) {
     const htmlNode = findHtmlChildNode(
@@ -98,8 +102,10 @@ export const stringifyHtmlAst = (
       });
     }
   }
-  // ensure body and html have \n
-  ensureLineBreaksBetweenHtmlNodes(htmlAst);
+  if (preserveLineBreaks) {
+    // ensure body and html have \n
+    ensureLineBreaksBetweenHtmlNodes(htmlAst);
+  }
   const htmlString = serialize(htmlAst);
   return htmlString;
 };

package/src/js/js_static_analysis/helpers.js

@@ -15,3 +15,26 @@ export const getTypePropertyNode = (node) => {
 export const isStringLiteralNode = (node) => {
   return node.type === "Literal" && typeof node.value === "string";
 };
+
+export const extractContentInfo = (node) => {
+  if (isStringLiteralNode(node)) {
+    return {
+      nodeType: "StringLiteral",
+      quote: node.raw[0],
+      content: node.value,
+    };
+  }
+  if (node.type === "TemplateLiteral") {
+    const quasis = node.quasis;
+    if (quasis.length !== 1) {
+      return null;
+    }
+    const templateElementNode = quasis[0];
+    return {
+      nodeType: "TemplateLiteral",
+      quote: "`",
+      content: templateElementNode.value.cooked,
+    };
+  }
+  return null;
+};

package/src/js/js_static_analysis/json_parse.js

@@ -0,0 +1,33 @@
+import { extractContentInfo } from "./helpers.js";
+
+export const isJSONParseCall = (node) => {
+  const callee = node.callee;
+  return (
+    callee.type === "MemberExpression" &&
+    callee.object.type === "Identifier" &&
+    callee.object.name === "JSON" &&
+    callee.property.type === "Identifier" &&
+    callee.property.name === "parse"
+  );
+};
+
+export const analyzeJSONParseCall = (node, { onInlineContent }) => {
+  const nodeHoldingContent = node.arguments[0];
+  const contentInfo = extractContentInfo(nodeHoldingContent);
+  if (contentInfo) {
+    onInlineContent({
+      node: nodeHoldingContent,
+      type: "json_parse_first_arg",
+      contentType: "application/json",
+      start: nodeHoldingContent.start,
+      end: nodeHoldingContent.end,
+      line: nodeHoldingContent.loc.start.line,
+      column: nodeHoldingContent.loc.start.column,
+      lineEnd: nodeHoldingContent.loc.end.line,
+      columnEnd: nodeHoldingContent.loc.end.column,
+      nodeType: contentInfo.nodeType,
+      quote: contentInfo.quote,
+      content: contentInfo.content,
+    });
+  }
+};

package/src/js/js_static_analysis/new_blob.js

@@ -0,0 +1,55 @@
+import {
+  isStringLiteralNode,
+  getTypePropertyNode,
+  extractContentInfo,
+} from "./helpers.js";
+
+export const isNewBlobCall = (node) => {
+  return (
+    node.type === "NewExpression" &&
+    node.callee.type === "Identifier" &&
+    node.callee.name === "Blob"
+  );
+};
+export const analyzeNewBlobCall = (node, { onInlineContent }) => {
+  const [firstArg, secondArg] = node.arguments;
+  if (!firstArg) {
+    return;
+  }
+  if (!secondArg) {
+    return;
+  }
+  if (firstArg.type !== "ArrayExpression") {
+    return;
+  }
+  if (firstArg.elements.length !== 1) {
+    return;
+  }
+  const typePropertyNode = getTypePropertyNode(secondArg);
+  if (!typePropertyNode) {
+    return;
+  }
+  const typePropertyValueNode = typePropertyNode.value;
+  if (!isStringLiteralNode(typePropertyValueNode)) {
+    return;
+  }
+  const nodeHoldingContent = firstArg.elements[0];
+  const contentType = typePropertyValueNode.value;
+  const contentInfo = extractContentInfo(nodeHoldingContent);
+  if (contentInfo) {
+    onInlineContent({
+      node: nodeHoldingContent,
+      type: "new_blob_first_arg",
+      contentType,
+      start: nodeHoldingContent.start,
+      end: nodeHoldingContent.end,
+      line: nodeHoldingContent.loc.start.line,
+      column: nodeHoldingContent.loc.start.column,
+      lineEnd: nodeHoldingContent.loc.end.line,
+      columnEnd: nodeHoldingContent.loc.end.column,
+      nodeType: contentInfo.nodeType,
+      quote: contentInfo.quote,
+      content: contentInfo.content,
+    });
+  }
+};

package/src/js/js_static_analysis/new_inline_content.js

@@ -0,0 +1,49 @@
+import {
+  isStringLiteralNode,
+  getTypePropertyNode,
+  extractContentInfo,
+} from "./helpers.js";
+
+export const isNewInlineContentCall = (node) => {
+  return (
+    node.type === "NewExpression" &&
+    node.callee.type === "Identifier" &&
+    node.callee.name === "__InlineContent__"
+  );
+};
+export const analyzeNewInlineContentCall = (node, { onInlineContent }) => {
+  const [firstArg, secondArg] = node.arguments;
+  if (!firstArg) {
+    return;
+  }
+  if (!secondArg) {
+    return;
+  }
+  const typePropertyNode = getTypePropertyNode(secondArg);
+  if (!typePropertyNode) {
+    return;
+  }
+  const typePropertyValueNode = typePropertyNode.value;
+  if (!isStringLiteralNode(typePropertyValueNode)) {
+    return;
+  }
+  const nodeHoldingContent = firstArg;
+  const contentType = typePropertyValueNode.value;
+  const contentInfo = extractContentInfo(nodeHoldingContent);
+  if (contentInfo) {
+    onInlineContent({
+      node: nodeHoldingContent,
+      type: "new_inline_content_first_arg",
+      contentType,
+      start: nodeHoldingContent.start,
+      end: nodeHoldingContent.end,
+      line: nodeHoldingContent.loc.start.line,
+      column: nodeHoldingContent.loc.start.column,
+      lineEnd: nodeHoldingContent.loc.end.line,
+      columnEnd: nodeHoldingContent.loc.end.column,
+      nodeType: contentInfo.nodeType,
+      quote: contentInfo.quote,
+      content: contentInfo.content,
+    });
+  }
+};

package/src/js/parse_js_urls.js

@@ -35,12 +35,25 @@ import {
   isSystemResolveCall,
   analyzeSystemResolveCall,
 } from "./js_static_analysis/system.js";
+import {
+  isNewBlobCall,
+  analyzeNewBlobCall,
+} from "./js_static_analysis/new_blob.js";
+import {
+  isNewInlineContentCall,
+  analyzeNewInlineContentCall,
+} from "./js_static_analysis/new_inline_content.js";
+import {
+  isJSONParseCall,
+  analyzeJSONParseCall,
+} from "./js_static_analysis/json_parse.js";
 
 export const parseJsUrls = async ({
   js,
   url,
   isJsModule = false,
   isWebWorker = false,
+  inlineContent = true,
 } = {}) => {
   const jsUrls = [];
   const jsAst = await parseJsWithAcorn({
@@ -51,6 +64,12 @@ export const parseJsUrls = async ({
   const onUrl = (jsUrl) => {
     jsUrls.push(jsUrl);
   };
+  const onInlineContent = (inlineContentInfo) => {
+    jsUrls.push({
+      isInline: true,
+      ...inlineContentInfo,
+    });
+  };
   ancestor(jsAst, {
     ImportDeclaration: (node) => {
       analyzeImportDeclaration(node, { onUrl });
@@ -100,6 +119,12 @@ export const parseJsUrls = async ({
         });
         return;
       }
+      if (inlineContent && isJSONParseCall(node)) {
+        analyzeJSONParseCall(node, {
+          onInlineContent,
+        });
+        return;
+      }
     },
     NewExpression: (node, ancestors) => {
       if (isNewWorkerCall(node)) {
@@ -132,6 +157,18 @@ export const parseJsUrls = async ({
         });
         return;
       }
+      if (inlineContent && isNewInlineContentCall(node)) {
+        analyzeNewInlineContentCall(node, {
+          onInlineContent,
+        });
+        return;
+      }
+      if (inlineContent && isNewBlobCall(node)) {
+        analyzeNewBlobCall(node, {
+          onInlineContent,
+        });
+        return;
+      }
     },
   });
   return jsUrls;