@jsenv/core 35.0.5 → 36.0.1

package/src/plugins/inline_content_analysis/jsenv_plugin_html_inline_content_analysis.js

@@ -1,206 +0,0 @@
-/*
- * This plugin ensure content inlined inside HTML is cooked (inline <script> for instance)
- * For <script hot-accept> the script content will be moved to a virtual file
- * to enable hot reloading
- */
-
-import { generateInlineContentUrl } from "@jsenv/urls";
-import {
-  parseHtmlString,
-  stringifyHtmlAst,
-  visitHtmlNodes,
-  getHtmlNodeText,
-  getHtmlNodePosition,
-  analyzeScriptNode,
-  setHtmlNodeAttributes,
-  setHtmlNodeText,
-  removeHtmlNodeText,
-  getHtmlNodeAttribute,
-} from "@jsenv/ast";
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
-
-export const jsenvPluginHtmlInlineContentAnalysis = ({
-  analyzeConvertedScripts,
-}) => {
-  const cookInlineContent = async ({
-    context,
-    inlineContentUrlInfo,
-    inlineContentReference,
-  }) => {
-    try {
-      await context.cook(inlineContentUrlInfo, {
-        reference: inlineContentReference,
-      });
-    } catch (e) {
-      if (e.code === "PARSE_ERROR") {
-        // When something like <style> or <script> contains syntax error
-        // the HTML in itself it still valid
-        // keep the syntax error and continue with the HTML
-        const messageStart =
-          inlineContentUrlInfo.type === "css"
-            ? `Syntax error on css declared inside <style>`
-            : `Syntax error on js declared inside <script>`;
-
-        context.logger.error(`${messageStart}: ${e.cause.reasonCode}
-${e.traceMessage}`);
-      } else {
-        throw e;
-      }
-    }
-  };
-
-  return {
-    name: "jsenv:html_inline_content_analysis",
-    appliesDuring: "*",
-    transformUrlContent: {
-      html: async (urlInfo, context) => {
-        const htmlAst = parseHtmlString(urlInfo.content);
-        const mutations = [];
-        const actions = [];
-        visitHtmlNodes(htmlAst, {
-          style: (styleNode) => {
-            const styleNodeText = getHtmlNodeText(styleNode);
-            if (!styleNodeText) {
-              return;
-            }
-            const { line, column, lineEnd, columnEnd, isOriginal } =
-              getHtmlNodePosition(styleNode, {
-                preferOriginal: true,
-              });
-            const inlineStyleUrl = generateInlineContentUrl({
-              url: urlInfo.url,
-              extension: ".css",
-              line,
-              column,
-              lineEnd,
-              columnEnd,
-            });
-            const debug =
-              getHtmlNodeAttribute(styleNode, "jsenv-debug") !== undefined;
-            const [inlineStyleReference, inlineStyleUrlInfo] =
-              context.referenceUtils.foundInline({
-                node: styleNode,
-                type: "style",
-                expectedType: "css",
-                isOriginalPosition: isOriginal,
-                // we remove 1 to the line because imagine the following html:
-                // <style>body { color: red; }</style>
-                // -> content starts same line as <style>
-                specifierLine: line - 1,
-                specifierColumn: column,
-                specifier: inlineStyleUrl,
-                contentType: "text/css",
-                content: styleNodeText,
-                debug,
-              });
-            actions.push(async () => {
-              await cookInlineContent({
-                context,
-                inlineContentUrlInfo: inlineStyleUrlInfo,
-                inlineContentReference: inlineStyleReference,
-              });
-            });
-            mutations.push(() => {
-              setHtmlNodeText(styleNode, inlineStyleUrlInfo.content, {
-                indentation: false, // indentation would decrease strack trace precision
-              });
-              setHtmlNodeAttributes(styleNode, {
-                "jsenv-cooked-by": "jsenv:html_inline_content_analysis",
-              });
-            });
-          },
-          script: (scriptNode) => {
-            const scriptNodeText = getHtmlNodeText(scriptNode);
-            if (!scriptNodeText) {
-              return;
-            }
-            // If the inline script was already handled by an other plugin, ignore it
-            // - we want to preserve inline scripts generated by html supervisor during dev
-            // - we want to avoid cooking twice a script during build
-            if (
-              !analyzeConvertedScripts &&
-              getHtmlNodeAttribute(scriptNode, "jsenv-injected-by") ===
-                "jsenv:js_module_fallback"
-            ) {
-              return;
-            }
-
-            const hotAccept =
-              getHtmlNodeAttribute(scriptNode, "hot-accept") !== undefined;
-            const { type, contentType, extension } =
-              analyzeScriptNode(scriptNode);
-            const { line, column, lineEnd, columnEnd, isOriginal } =
-              getHtmlNodePosition(scriptNode, {
-                preferOriginal: true,
-              });
-            let inlineScriptUrl = generateInlineContentUrl({
-              url: urlInfo.url,
-              extension: extension || CONTENT_TYPE.asFileExtension(contentType),
-              line,
-              column,
-              lineEnd,
-              columnEnd,
-            });
-            const debug =
-              getHtmlNodeAttribute(scriptNode, "jsenv-debug") !== undefined;
-            const [inlineScriptReference, inlineScriptUrlInfo] =
-              context.referenceUtils.foundInline({
-                node: scriptNode,
-                type: "script",
-                expectedType: type,
-                // we remove 1 to the line because imagine the following html:
-                // <script>console.log('ok')</script>
-                // -> content starts same line as <script>
-                specifierLine: line - 1,
-                specifierColumn: column,
-                isOriginalPosition: isOriginal,
-                specifier: inlineScriptUrl,
-                contentType,
-                content: scriptNodeText,
-                debug,
-              });
-            actions.push(async () => {
-              await cookInlineContent({
-                context,
-                inlineContentUrlInfo: inlineScriptUrlInfo,
-                inlineContentReference: inlineScriptReference,
-              });
-              mutations.push(() => {
-                const attributes = {
-                  "jsenv-cooked-by": "jsenv:html_inline_content_analysis",
-                  // 1. <script type="jsx"> becomes <script>
-                  // 2. <script type="module/jsx"> becomes <script type="module">
-                  ...(extension
-                    ? { type: type === "js_module" ? "module" : undefined }
-                    : {}),
-                };
-                if (hotAccept) {
-                  removeHtmlNodeText(scriptNode);
-                  setHtmlNodeAttributes(scriptNode, {
-                    ...attributes,
-                  });
-                } else {
-                  setHtmlNodeText(scriptNode, inlineScriptUrlInfo.content, {
-                    indentation: false, // indentation would decrease stack trace precision
-                  });
-                  setHtmlNodeAttributes(scriptNode, {
-                    ...attributes,
-                  });
-                }
-              });
-            });
-          },
-        });
-        if (actions.length > 0) {
-          await Promise.all(actions.map((action) => action()));
-        }
-        if (mutations.length === 0) {
-          return null;
-        }
-        mutations.forEach((mutation) => mutation());
-        const htmlModified = stringifyHtmlAst(htmlAst);
-        return htmlModified;
-      },
-    },
-  };
-};

package/src/plugins/inline_content_analysis/jsenv_plugin_inline_content_analysis.js

@@ -1,34 +0,0 @@
-import { jsenvPluginHtmlInlineContentAnalysis } from "./jsenv_plugin_html_inline_content_analysis.js";
-import { jsenvPluginJsInlineContentAnalysis } from "./jsenv_plugin_js_inline_content_analysis.js";
-import { jsenvPluginDataUrls } from "./jsenv_plugin_data_urls.js";
-
-export const jsenvPluginInlineContentAnalysis = ({
-  fetchInlineUrls = true,
-  analyzeConvertedScripts = false,
-  allowEscapeForVersioning = false,
-} = {}) => {
-  return [
-    ...(fetchInlineUrls ? [jsenvPluginInlineContentFetcher()] : []),
-    jsenvPluginHtmlInlineContentAnalysis({ analyzeConvertedScripts }),
-    jsenvPluginJsInlineContentAnalysis({ allowEscapeForVersioning }),
-    jsenvPluginDataUrls(),
-  ];
-};
-
-const jsenvPluginInlineContentFetcher = () => {
-  return {
-    name: "jsenv:inline_content_fetcher",
-    appliesDuring: "*",
-    fetchUrlContent: (urlInfo) => {
-      if (!urlInfo.isInline) {
-        return null;
-      }
-      return {
-        // we want to fetch the original content otherwise we might re-cook
-        // content already cooked
-        content: urlInfo.originalContent,
-        contentType: urlInfo.contentType,
-      };
-    },
-  };
-};

package/src/plugins/inline_content_analysis/jsenv_plugin_js_inline_content_analysis.js

@@ -1,314 +0,0 @@
-import { generateInlineContentUrl } from "@jsenv/urls";
-import { createMagicSource } from "@jsenv/sourcemap";
-import { applyBabelPlugins } from "@jsenv/ast";
-import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
-import { JS_QUOTES } from "@jsenv/utils/src/string/js_quotes.js";
-
-export const jsenvPluginJsInlineContentAnalysis = ({
-  allowEscapeForVersioning,
-}) => {
-  const parseAndTransformInlineContentCalls = async (urlInfo, context) => {
-    const inlineContentInfos = await parseJsInlineContentInfos({
-      js: urlInfo.content,
-      url: urlInfo.originalUrl,
-      isJsModule: urlInfo.type === "js_module",
-    });
-    if (inlineContentInfos.length === 0) {
-      return null;
-    }
-    const magicSource = createMagicSource(urlInfo.content);
-    await inlineContentInfos.reduce(async (previous, inlineContentInfo) => {
-      await previous;
-      const inlineUrl = generateInlineContentUrl({
-        url: urlInfo.url,
-        extension: CONTENT_TYPE.asFileExtension(inlineContentInfo.contentType),
-        line: inlineContentInfo.line,
-        column: inlineContentInfo.column,
-        lineEnd: inlineContentInfo.lineEnd,
-        columnEnd: inlineContentInfo.columnEnd,
-      });
-      let { quote } = inlineContentInfo;
-      if (
-        quote === "`" &&
-        !context.isSupportedOnCurrentClients("template_literals")
-      ) {
-        // if quote is "`" and template literals are not supported
-        // we'll use a regular string (single or double quote)
-        // when rendering the string
-        quote = JS_QUOTES.pickBest(inlineContentInfo.content);
-      }
-      const [inlineReference, inlineUrlInfo] =
-        context.referenceUtils.foundInline({
-          type: "js_inline_content",
-          subtype: inlineContentInfo.type, // "new_blob_first_arg", "new_inline_content_first_arg", "json_parse_first_arg"
-          isOriginalPosition: urlInfo.content === urlInfo.originalContent,
-          specifierLine: inlineContentInfo.line,
-          specifierColumn: inlineContentInfo.column,
-          specifier: inlineUrl,
-          contentType: inlineContentInfo.contentType,
-          content: inlineContentInfo.content,
-        });
-      inlineUrlInfo.jsQuote = quote;
-      inlineReference.escape = (value) =>
-        JS_QUOTES.escapeSpecialChars(value.slice(1, -1), { quote });
-      await context.cook(inlineUrlInfo, { reference: inlineReference });
-      magicSource.replace({
-        start: inlineContentInfo.start,
-        end: inlineContentInfo.end,
-        replacement: JS_QUOTES.escapeSpecialChars(inlineUrlInfo.content, {
-          quote,
-          allowEscapeForVersioning,
-        }),
-      });
-    }, Promise.resolve());
-    return magicSource.toContentAndSourcemap();
-  };
-
-  return {
-    name: "jsenv:js_inline_content_analysis",
-    appliesDuring: "*",
-    transformUrlContent: {
-      js_classic: parseAndTransformInlineContentCalls,
-      js_module: parseAndTransformInlineContentCalls,
-    },
-  };
-};
-
-const parseJsInlineContentInfos = async ({ js, url, isJsModule }) => {
-  if (
-    !js.includes("InlineContent") &&
-    !js.includes("new Blob(") &&
-    !js.includes("JSON.parse(")
-  ) {
-    return [];
-  }
-  const { metadata } = await applyBabelPlugins({
-    babelPlugins: [babelPluginMetadataInlineContents],
-    urlInfo: {
-      originalUrl: url,
-      type: isJsModule ? "js_module" : "js_classic",
-      content: js,
-    },
-  });
-  return metadata.inlineContentInfos;
-};
-
-const babelPluginMetadataInlineContents = () => {
-  return {
-    name: "metadata-inline-contents",
-    visitor: {
-      Program: (programPath, state) => {
-        const inlineContentInfos = [];
-        const onInlineContentInfo = (inlineContentInfo) => {
-          inlineContentInfos.push(inlineContentInfo);
-        };
-        programPath.traverse({
-          NewExpression: (path) => {
-            if (isNewInlineContentCall(path)) {
-              analyzeNewInlineContentCall(path.node, {
-                onInlineContentInfo,
-              });
-              return;
-            }
-            if (isNewBlobCall(path.node)) {
-              analyzeNewBlobCall(path.node, {
-                onInlineContentInfo,
-              });
-              return;
-            }
-          },
-          CallExpression: (path) => {
-            const node = path.node;
-            if (isJSONParseCall(node)) {
-              analyzeJsonParseCall(node, {
-                onInlineContentInfo,
-              });
-            }
-          },
-        });
-        state.file.metadata.inlineContentInfos = inlineContentInfos;
-      },
-    },
-  };
-};
-
-const isNewInlineContentCall = (path) => {
-  const node = path.node;
-  if (node.callee.type === "Identifier") {
-    // terser rename import to use a shorter name
-    const name = getOriginalName(path, node.callee.name);
-    return name === "InlineContent";
-  }
-  if (node.callee.id && node.callee.id.type === "Identifier") {
-    const name = getOriginalName(path, node.callee.id.name);
-    return name === "InlineContent";
-  }
-  return false;
-};
-const analyzeNewInlineContentCall = (node, { onInlineContentInfo }) => {
-  analyzeArguments({
-    node,
-    onInlineContentInfo,
-    nodeHoldingContent: node.arguments[0],
-    type: "new_inline_content_first_arg",
-  });
-};
-
-const isNewBlobCall = (node) => {
-  return node.callee.type === "Identifier" && node.callee.name === "Blob";
-};
-const analyzeNewBlobCall = (node, { onInlineContentInfo }) => {
-  const firstArg = node.arguments[0];
-  if (!firstArg) {
-    return;
-  }
-  if (firstArg.type !== "ArrayExpression") {
-    return;
-  }
-  if (firstArg.elements.length !== 1) {
-    return;
-  }
-  analyzeArguments({
-    node,
-    onInlineContentInfo,
-    nodeHoldingContent: firstArg.elements[0],
-    type: "new_blob_first_arg",
-  });
-};
-
-const analyzeArguments = ({
-  node,
-  onInlineContentInfo,
-  nodeHoldingContent,
-  type,
-}) => {
-  if (node.arguments.length !== 2) {
-    return;
-  }
-  const [, secondArg] = node.arguments;
-  const typePropertyNode = getTypePropertyNode(secondArg);
-  if (!typePropertyNode) {
-    return;
-  }
-  const typePropertyValueNode = typePropertyNode.value;
-  if (typePropertyValueNode.type !== "StringLiteral") {
-    return;
-  }
-  const contentType = typePropertyValueNode.value;
-  const contentDetails = extractContentDetails(nodeHoldingContent);
-  if (contentDetails) {
-    onInlineContentInfo({
-      node: nodeHoldingContent,
-      ...getNodePosition(nodeHoldingContent),
-      type,
-      contentType,
-      ...contentDetails,
-    });
-  }
-};
-const extractContentDetails = (node) => {
-  if (node.type === "StringLiteral") {
-    return {
-      nodeType: "StringLiteral",
-      quote: node.extra.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;
-};
-
-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"
-  );
-};
-const analyzeJsonParseCall = (node, { onInlineContentInfo }) => {
-  const firstArgNode = node.arguments[0];
-  const contentDetails = extractContentDetails(firstArgNode);
-  if (contentDetails) {
-    onInlineContentInfo({
-      node: firstArgNode,
-      ...getNodePosition(firstArgNode),
-      type: "json_parse_first_arg",
-      contentType: "application/json",
-      ...contentDetails,
-    });
-  }
-};
-
-const getNodePosition = (node) => {
-  return {
-    start: node.start,
-    end: node.end,
-    line: node.loc.start.line,
-    column: node.loc.start.column,
-    lineEnd: node.loc.end.line,
-    columnEnd: node.loc.end.column,
-  };
-};
-const getOriginalName = (path, name) => {
-  const binding = path.scope.getBinding(name);
-  if (!binding) {
-    return name;
-  }
-  if (binding.path.type === "ImportSpecifier") {
-    const importedName = binding.path.node.imported.name;
-    if (name === importedName) {
-      return name;
-    }
-    return getOriginalName(path, importedName);
-  }
-  if (binding.path.type === "VariableDeclarator") {
-    const { node } = binding.path;
-    const { init } = node;
-    if (init && init.type === "Identifier") {
-      const previousName = init.name;
-      return getOriginalName(path, previousName);
-    }
-    if (node.id && node.id.type === "Identifier") {
-      const { constantViolations } = binding;
-      if (constantViolations && constantViolations.length > 0) {
-        const lastViolation = constantViolations[constantViolations.length - 1];
-        if (
-          lastViolation &&
-          lastViolation.node.type === "AssignmentExpression" &&
-          lastViolation.node.right.type === "MemberExpression" &&
-          lastViolation.node.right.property.type === "Identifier"
-        ) {
-          return lastViolation.node.right.property.name;
-        }
-      }
-    }
-  }
-  return name;
-};
-const getTypePropertyNode = (node) => {
-  if (node.type !== "ObjectExpression") {
-    return null;
-  }
-  const { properties } = node;
-  return properties.find((property) => {
-    return (
-      property.type === "ObjectProperty" &&
-      property.key.type === "Identifier" &&
-      property.key.name === "type"
-    );
-  });
-};