@jsenv/core 35.0.5 → 36.0.1

package/src/plugins/url_analysis/html/html_urls.js

@@ -1,313 +0,0 @@
-import {
-  parseHtmlString,
-  visitHtmlNodes,
-  getHtmlNodeAttribute,
-  getHtmlNodePosition,
-  setHtmlNodeAttributes,
-  getHtmlNodeAttributePosition,
-  analyzeScriptNode,
-  parseSrcSet,
-  stringifyHtmlAst,
-} from "@jsenv/ast";
-
-export const parseAndTransformHtmlUrls = async (urlInfo, context) => {
-  const url = urlInfo.originalUrl;
-  const content = urlInfo.content;
-  const htmlAst = parseHtmlString(content, {
-    storeOriginalPositions: context.dev,
-  });
-  const mentions = visitHtmlUrls({
-    url,
-    htmlAst,
-  });
-  const mutations = [];
-  const actions = [];
-  for (const mention of mentions) {
-    const {
-      type,
-      subtype,
-      expectedType,
-      line,
-      column,
-      originalLine,
-      originalColumn,
-      node,
-      attributeName,
-      debug,
-      specifier,
-    } = mention;
-    const { crossorigin, integrity } = readFetchMetas(node);
-    const isResourceHint = [
-      "preconnect",
-      "dns-prefetch",
-      "prefetch",
-      "preload",
-      "modulepreload",
-    ].includes(subtype);
-    const [reference] = context.referenceUtils.found({
-      type,
-      subtype,
-      expectedType,
-      originalLine,
-      originalColumn,
-      specifier,
-      specifierLine: line,
-      specifierColumn: column,
-      isResourceHint,
-      crossorigin,
-      integrity,
-      debug,
-    });
-    actions.push(async () => {
-      await context.referenceUtils.readGeneratedSpecifier(reference);
-      mutations.push(() => {
-        setHtmlNodeAttributes(node, {
-          [attributeName]: reference.generatedSpecifier,
-        });
-      });
-    });
-  }
-  if (actions.length > 0) {
-    await Promise.all(actions.map((action) => action()));
-  }
-  if (mutations.length === 0) {
-    return null;
-  }
-  mutations.forEach((mutation) => mutation());
-  return stringifyHtmlAst(htmlAst);
-};
-
-const crossOriginCompatibleTagNames = ["script", "link", "img", "source"];
-const integrityCompatibleTagNames = ["script", "link", "img", "source"];
-const readFetchMetas = (node) => {
-  const meta = {};
-  if (crossOriginCompatibleTagNames.includes(node.nodeName)) {
-    const crossorigin = getHtmlNodeAttribute(node, "crossorigin") !== undefined;
-    meta.crossorigin = crossorigin;
-  }
-  if (integrityCompatibleTagNames.includes(node.nodeName)) {
-    const integrity = getHtmlNodeAttribute(node, "integrity");
-    meta.integrity = integrity;
-  }
-  return meta;
-};
-
-const visitHtmlUrls = ({ url, htmlAst }) => {
-  const mentions = [];
-  const finalizeCallbacks = [];
-  const addMention = ({
-    type,
-    subtype,
-    expectedType,
-    node,
-    attributeName,
-    specifier,
-  }) => {
-    let position;
-    if (getHtmlNodeAttribute(node, "jsenv-cooked-by")) {
-      // when generated from inline content,
-      // line, column is not "src" nor "inlined-from-src" but "original-position"
-      position = getHtmlNodePosition(node);
-    } else {
-      position = getHtmlNodeAttributePosition(node, attributeName);
-    }
-    const {
-      line,
-      column,
-      // originalLine, originalColumn
-    } = position;
-    const debug = getHtmlNodeAttribute(node, "jsenv-debug") !== undefined;
-    const mention = {
-      type,
-      subtype,
-      expectedType,
-      line,
-      column,
-      // originalLine, originalColumn
-      specifier,
-      node,
-      attributeName,
-      debug,
-    };
-    mentions.push(mention);
-    return mention;
-  };
-  const visitAttributeAsUrlSpecifier = ({ node, attributeName, ...rest }) => {
-    const value = getHtmlNodeAttribute(node, attributeName);
-    if (value) {
-      if (
-        getHtmlNodeAttribute(node, "jsenv-inlined-by") === "jsenv:importmap"
-      ) {
-        // during build the importmap is inlined
-        // and shoud not be considered as a dependency anymore
-        return null;
-      }
-      return addMention({
-        ...rest,
-        node,
-        attributeName,
-        specifier:
-          attributeName === "inlined-from-src" ||
-          attributeName === "inlined-from-href"
-            ? new URL(value, url).href
-            : value,
-      });
-    }
-    if (attributeName === "src") {
-      return visitAttributeAsUrlSpecifier({
-        ...rest,
-        node,
-        attributeName: "inlined-from-src",
-      });
-    }
-    if (attributeName === "href") {
-      return visitAttributeAsUrlSpecifier({
-        ...rest,
-        node,
-        attributeName: "inlined-from-href",
-      });
-    }
-    return null;
-  };
-  const visitSrcset = ({ type, node }) => {
-    const srcset = getHtmlNodeAttribute(node, "srcset");
-    if (srcset) {
-      const srcCandidates = parseSrcSet(srcset);
-      srcCandidates.forEach((srcCandidate) => {
-        addMention({
-          type,
-          node,
-          attributeName: "srcset",
-          specifier: srcCandidate.specifier,
-        });
-      });
-    }
-  };
-  visitHtmlNodes(htmlAst, {
-    link: (node) => {
-      const rel = getHtmlNodeAttribute(node, "rel");
-      const type = getHtmlNodeAttribute(node, "type");
-      const mention = visitAttributeAsUrlSpecifier({
-        type: "link_href",
-        subtype: rel,
-        node,
-        attributeName: "href",
-        // https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#including_a_mime_type
-        expectedContentType: type,
-      });
-
-      if (mention) {
-        finalizeCallbacks.push(() => {
-          mention.expectedType = decideLinkExpectedType(mention, mentions);
-        });
-      }
-    },
-    // style: () => {},
-    script: (node) => {
-      const { type } = analyzeScriptNode(node);
-      if (type === "text") {
-        // ignore <script type="whatever" src="./file.js">
-        // per HTML spec https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-type
-        // this will be handled by jsenv_plugin_html_inline_content_analysis
-        return;
-      }
-      visitAttributeAsUrlSpecifier({
-        type: "script",
-        subtype: type,
-        expectedType: type,
-        node,
-        attributeName: "src",
-      });
-    },
-    a: (node) => {
-      visitAttributeAsUrlSpecifier({
-        type: "a_href",
-        node,
-        attributeName: "href",
-      });
-    },
-    iframe: (node) => {
-      visitAttributeAsUrlSpecifier({
-        type: "iframe_src",
-        node,
-        attributeName: "src",
-      });
-    },
-    img: (node) => {
-      visitAttributeAsUrlSpecifier({
-        type: "img_src",
-        node,
-        attributeName: "src",
-      });
-      visitSrcset({
-        type: "img_srcset",
-        node,
-      });
-    },
-    source: (node) => {
-      visitAttributeAsUrlSpecifier({
-        type: "source_src",
-        node,
-        attributeName: "src",
-      });
-      visitSrcset({
-        type: "source_srcset",
-        node,
-      });
-    },
-    // svg <image> tag
-    image: (node) => {
-      visitAttributeAsUrlSpecifier({
-        type: "image_href",
-        node,
-        attributeName: "href",
-      });
-    },
-    use: (node) => {
-      visitAttributeAsUrlSpecifier({
-        type: "use_href",
-        node,
-        attributeName: "href",
-      });
-    },
-  });
-  finalizeCallbacks.forEach((finalizeCallback) => {
-    finalizeCallback();
-  });
-  return mentions;
-};
-
-const decideLinkExpectedType = (linkMention, mentions) => {
-  const rel = getHtmlNodeAttribute(linkMention.node, "rel");
-  if (rel === "webmanifest") {
-    return "webmanifest";
-  }
-  if (rel === "modulepreload") {
-    return "js_module";
-  }
-  if (rel === "stylesheet") {
-    return "css";
-  }
-  if (rel === "preload") {
-    // https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#what_types_of_content_can_be_preloaded
-    const as = getHtmlNodeAttribute(linkMention.node, "as");
-    if (as === "document") {
-      return "html";
-    }
-    if (as === "style") {
-      return "css";
-    }
-    if (as === "script") {
-      const firstScriptOnThisUrl = mentions.find(
-        (mentionCandidate) =>
-          mentionCandidate.url === linkMention.url &&
-          mentionCandidate.type === "script",
-      );
-      if (firstScriptOnThisUrl) {
-        return firstScriptOnThisUrl.expectedType;
-      }
-      return undefined;
-    }
-  }
-  return undefined;
-};

package/src/plugins/url_analysis/js/js_urls.js

@@ -1,65 +0,0 @@
-import { createMagicSource } from "@jsenv/sourcemap";
-import { parseJsUrls } from "@jsenv/ast";
-
-import { isWebWorkerUrlInfo } from "@jsenv/core/src/kitchen/web_workers.js";
-
-export const parseAndTransformJsUrls = async (urlInfo, context) => {
-  const jsMentions = await parseJsUrls({
-    js: urlInfo.content,
-    url: urlInfo.originalUrl,
-    isJsModule: urlInfo.type === "js_module",
-    isWebWorker: isWebWorkerUrlInfo(urlInfo),
-  });
-  const actions = [];
-  const magicSource = createMagicSource(urlInfo.content);
-  for (const jsMention of jsMentions) {
-    if (
-      jsMention.subtype === "import_static" ||
-      jsMention.subtype === "import_dynamic"
-    ) {
-      urlInfo.data.usesImport = true;
-    }
-    const [reference] = context.referenceUtils.found({
-      node: jsMention.node,
-      type: jsMention.type,
-      subtype: jsMention.subtype,
-      expectedType: jsMention.expectedType,
-      expectedSubtype: jsMention.expectedSubtype || urlInfo.subtype,
-      specifier: jsMention.specifier,
-      specifierStart: jsMention.start,
-      specifierEnd: jsMention.end,
-      specifierLine: jsMention.line,
-      specifierColumn: jsMention.column,
-      data: jsMention.data,
-      baseUrl: {
-        "StringLiteral": jsMention.baseUrl,
-        "window.location": urlInfo.url,
-        "window.origin": context.rootDirectoryUrl,
-        "import.meta.url": urlInfo.url,
-        "context.meta.url": urlInfo.url,
-        "document.currentScript.src": urlInfo.url,
-      }[jsMention.baseUrlType],
-      assert: jsMention.assert,
-      assertNode: jsMention.assertNode,
-      typePropertyNode: jsMention.typePropertyNode,
-    });
-    actions.push(async () => {
-      const replacement = await context.referenceUtils.readGeneratedSpecifier(
-        reference,
-      );
-      magicSource.replace({
-        start: jsMention.start,
-        end: jsMention.end,
-        replacement,
-      });
-      if (reference.mutation) {
-        reference.mutation(magicSource);
-      }
-    });
-  }
-  if (actions.length > 0) {
-    await Promise.all(actions.map((action) => action()));
-  }
-  const { content, sourcemap } = magicSource.toContentAndSourcemap();
-  return { content, sourcemap };
-};

package/src/plugins/url_analysis/jsenv_plugin_url_analysis.js

@@ -1,116 +0,0 @@
-import { URL_META } from "@jsenv/url-meta";
-import { urlToRelativeUrl } from "@jsenv/urls";
-
-import { jsenvPluginReferenceExpectedTypes } from "./jsenv_plugin_reference_expected_types.js";
-import { parseAndTransformHtmlUrls } from "./html/html_urls.js";
-import { parseAndTransformCssUrls } from "./css/css_urls.js";
-import { parseAndTransformJsUrls } from "./js/js_urls.js";
-import { parseAndTransformWebmanifestUrls } from "./webmanifest/webmanifest_urls.js";
-
-export const jsenvPluginUrlAnalysis = ({
-  rootDirectoryUrl,
-  include,
-  supportedProtocols = ["file:", "data:", "virtual:", "http:", "https:"],
-}) => {
-  // eslint-disable-next-line no-unused-vars
-  let getIncludeInfo = (url) => undefined;
-  if (include) {
-    const associations = URL_META.resolveAssociations(
-      { include },
-      rootDirectoryUrl,
-    );
-    getIncludeInfo = (url) => {
-      const { include } = URL_META.applyAssociations({ url, associations });
-      return include;
-    };
-  }
-
-  return [
-    {
-      name: "jsenv:url_analysis",
-      appliesDuring: "*",
-      redirectUrl: (reference) => {
-        if (reference.shouldHandle !== undefined) {
-          return;
-        }
-        if (
-          reference.specifier[0] === "#" &&
-          // For Html, css and in general "#" refer to a resource in the page
-          // so that urls must be kept intact
-          // However for js import specifiers they have a different meaning and we want
-          // to resolve them (https://nodejs.org/api/packages.html#imports for instance)
-          reference.type !== "js_import"
-        ) {
-          reference.shouldHandle = false;
-          return;
-        }
-        const includeInfo = getIncludeInfo(reference.url);
-        if (includeInfo === true) {
-          reference.shouldHandle = true;
-          return;
-        }
-        if (includeInfo === false) {
-          reference.shouldHandle = false;
-          return;
-        }
-        const { protocol } = new URL(reference.url);
-        const protocolIsSupported = supportedProtocols.some(
-          (supportedProtocol) => protocol === supportedProtocol,
-        );
-        if (protocolIsSupported) {
-          reference.shouldHandle = true;
-        }
-      },
-      transformUrlContent: {
-        html: parseAndTransformHtmlUrls,
-        css: parseAndTransformCssUrls,
-        js_classic: parseAndTransformJsUrls,
-        js_module: parseAndTransformJsUrls,
-        webmanifest: parseAndTransformWebmanifestUrls,
-        directory: (urlInfo, context) => {
-          const originalDirectoryReference = findOriginalDirectoryReference(
-            urlInfo,
-            context,
-          );
-          const directoryRelativeUrl = urlToRelativeUrl(
-            urlInfo.url,
-            context.rootDirectoryUrl,
-          );
-          JSON.parse(urlInfo.content).forEach((directoryEntryName) => {
-            context.referenceUtils.found({
-              type: "filesystem",
-              subtype: "directory_entry",
-              specifier: directoryEntryName,
-              trace: {
-                message: `"${directoryRelativeUrl}${directoryEntryName}" entry in directory referenced by ${originalDirectoryReference.trace.message}`,
-              },
-            });
-          });
-        },
-      },
-    },
-    jsenvPluginReferenceExpectedTypes(),
-  ];
-};
-
-const findOriginalDirectoryReference = (urlInfo, context) => {
-  const findNonFileSystemAncestor = (urlInfo) => {
-    for (const dependentUrl of urlInfo.dependents) {
-      const dependentUrlInfo = context.urlGraph.getUrlInfo(dependentUrl);
-      if (dependentUrlInfo.type !== "directory") {
-        return [dependentUrlInfo, urlInfo];
-      }
-      const found = findNonFileSystemAncestor(dependentUrlInfo);
-      if (found) {
-        return found;
-      }
-    }
-    return [];
-  };
-  const [ancestor, child] = findNonFileSystemAncestor(urlInfo);
-  if (!ancestor) {
-    return null;
-  }
-  const ref = ancestor.references.find((ref) => ref.url === child.url);
-  return ref;
-};

package/src/plugins/url_resolution/jsenv_plugin_url_resolution.js

@@ -1,140 +0,0 @@
-/*
- * This plugin is responsible to resolve urls except for a few cases:
- * - A custom plugin implements a resolveUrl hook returning something
- * - The reference.type is "filesystem" -> it is handled by jsenv_plugin_file_urls.js
- *
- * By default node esm resolution applies inside js modules
- * and the rest uses the web standard url resolution (new URL):
- * - "http_request"
- * - "entry_point"
- * - "link_href"
- * - "style"
- * - "script"
- * - "a_href"
- * - "iframe_src
- * - "img_src"
- * - "img_srcset"
- * - "source_src"
- * - "source_srcset"
- * - "image_href"
- * - "use_href"
- * - "css_@import"
- * - "css_url"
- * - "js_import"
- * - "js_import_script"
- * - "js_url"
- * - "js_inline_content"
- * - "sourcemap_comment"
- * - "webmanifest_icon_src"
- * - "package_json"
- */
-
-import { createNodeEsmResolver } from "./node_esm_resolver.js";
-
-export const jsenvPluginUrlResolution = ({
-  runtimeCompat,
-  defaultFileUrl,
-  urlResolution,
-}) => {
-  const resolveUrlUsingWebResolution = (reference) => {
-    return new URL(
-      reference.specifier,
-      // baseUrl happens second argument to new URL() is different from
-      // import.meta.url or document.currentScript.src
-      reference.baseUrl || reference.parentUrl,
-    ).href;
-  };
-
-  const resolvers = {};
-  Object.keys(urlResolution).forEach((urlType) => {
-    const resolver = urlResolution[urlType];
-    if (typeof resolver !== "object") {
-      throw new Error(
-        `urlResolution values must be objects, got ${resolver} on "${urlType}"`,
-      );
-    }
-    let { web, node_esm, ...rest } = resolver;
-    const unexpectedKeys = Object.keys(rest);
-    if (unexpectedKeys.length) {
-      throw new TypeError(
-        `${unexpectedKeys.join(
-          ",",
-        )}: there is no such configuration on "${urlType}"`,
-      );
-    }
-    if (node_esm === undefined) {
-      node_esm = urlType === "js_import";
-    }
-    if (web === undefined) {
-      web = true;
-    }
-    if (node_esm) {
-      if (node_esm === true) node_esm = {};
-      const { packageConditions, preservesSymlink } = node_esm;
-      resolvers[urlType] = createNodeEsmResolver({
-        runtimeCompat,
-        packageConditions,
-        preservesSymlink,
-      });
-    } else if (web) {
-      resolvers[urlType] = resolveUrlUsingWebResolution;
-    }
-  });
-
-  const nodeEsmResolverDefault = createNodeEsmResolver({
-    runtimeCompat,
-    preservesSymlink: true,
-  });
-  if (!resolvers.js_module) {
-    resolvers.js_module = nodeEsmResolverDefault;
-  }
-  if (!resolvers.js_classic) {
-    resolvers.js_classic = (reference, context) => {
-      if (reference.subtype === "self_import_scripts_arg") {
-        return nodeEsmResolverDefault(reference, context);
-      }
-      return resolveUrlUsingWebResolution(reference, context);
-    };
-  }
-  if (!resolvers["*"]) {
-    resolvers["*"] = resolveUrlUsingWebResolution;
-  }
-
-  return {
-    name: "jsenv:url_resolution",
-    appliesDuring: "*",
-    resolveUrl: (reference, context) => {
-      if (reference.specifier === "/") {
-        return String(defaultFileUrl);
-      }
-      if (reference.specifier[0] === "/") {
-        return new URL(reference.specifier.slice(1), context.rootDirectoryUrl)
-          .href;
-      }
-      if (reference.type === "sourcemap_comment") {
-        return resolveUrlUsingWebResolution(reference, context);
-      }
-      let urlType;
-      if (reference.injected) {
-        urlType = reference.expectedType;
-      } else {
-        const parentUrlInfo = context.urlGraph.getUrlInfo(reference.parentUrl);
-        urlType = parentUrlInfo ? parentUrlInfo.type : "entry_point";
-      }
-      const resolver = resolvers[urlType] || resolvers["*"];
-      return resolver(reference, context);
-    },
-    // when specifier is prefixed by "file:///@ignore/"
-    // we return an empty js module (used by node esm)
-    fetchUrlContent: (urlInfo) => {
-      if (urlInfo.url.startsWith("file:///@ignore/")) {
-        return {
-          content: "export default {}",
-          contentType: "text/javascript",
-          type: "js_module",
-        };
-      }
-      return null;
-    },
-  };
-};