@unhead/bundler 3.0.0-rc.1

package/dist/shared/bundler.DRWfqG8C.mjs

@@ -0,0 +1,453 @@
+import { pathToFileURL } from 'node:url';
+import MagicString from 'magic-string';
+import { parseSync } from 'oxc-parser';
+import { ScopeTracker, walk, ScopeTrackerImport } from 'oxc-walker';
+import { parseURL, parseQuery } from 'ufo';
+import { createUnplugin } from 'unplugin';
+import { createContext, runInContext } from 'node:vm';
+import { resolveMetaKeyType, resolveMetaKeyValue, resolvePackedMetaObjectValue } from 'unhead/utils';
+
+const NODE_MODULES_RE$2 = /[\\/]node_modules[\\/]/;
+const TRANSFORM_RE$2 = /\.(?:(?:c|m)?j|t)sx?$/;
+const SKIP_JS_TYPES = /* @__PURE__ */ new Set(["application/json", "application/ld+json", "speculationrules", "importmap"]);
+const MinifyTransform = createUnplugin((options = {}) => {
+  const jsMinifier = options.js !== false ? options.js : void 0;
+  const cssMinifier = options.css !== false ? options.css : void 0;
+  const doJS = !!jsMinifier;
+  const doCSS = !!cssMinifier;
+  const HEAD_FN_NAMES = /* @__PURE__ */ new Set(["useHead", "useServerHead"]);
+  const CONTENT_PROPS = /* @__PURE__ */ new Set(["innerHTML", "textContent"]);
+  return {
+    name: "unhead:minify-transform",
+    enforce: "post",
+    transformInclude(id) {
+      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+      const { type } = parseQuery(search);
+      if (NODE_MODULES_RE$2.test(pathname))
+        return false;
+      if (options.filter?.include?.some((pattern) => id.match(pattern)))
+        return true;
+      if (options.filter?.exclude?.some((pattern) => id.match(pattern)))
+        return false;
+      if (pathname.endsWith(".vue") && (type === "script" || !search))
+        return true;
+      if (TRANSFORM_RE$2.test(pathname))
+        return true;
+      return false;
+    },
+    async transform(code, id) {
+      if (!code.includes("useHead") && !code.includes("useServerHead"))
+        return;
+      let ast;
+      try {
+        ast = parseSync(id, code);
+      } catch {
+        return;
+      }
+      const scopeTracker = new ScopeTracker();
+      const s = new MagicString(code);
+      const pendingMinifications = [];
+      walk(ast.program, {
+        scopeTracker,
+        enter(node, _parent) {
+          if (node.type !== "CallExpression" || node.callee.type !== "Identifier")
+            return;
+          const decl = scopeTracker.getDeclaration(node.callee.name);
+          let originalName;
+          if (decl instanceof ScopeTrackerImport) {
+            if (decl.node.type !== "ImportSpecifier" || decl.node.imported.type !== "Identifier")
+              return;
+            originalName = decl.node.imported.name;
+          } else if (!decl && HEAD_FN_NAMES.has(node.callee.name)) {
+            originalName = node.callee.name;
+          } else {
+            return;
+          }
+          if (!HEAD_FN_NAMES.has(originalName))
+            return;
+          const arg = node.arguments[0];
+          if (!arg || arg.type !== "ObjectExpression")
+            return;
+          for (const prop of arg.properties) {
+            if (prop.type !== "Property" || prop.key?.type !== "Identifier")
+              continue;
+            const tagType = prop.key.name;
+            if (tagType !== "script" && tagType !== "style")
+              continue;
+            if (tagType === "script" && !doJS)
+              continue;
+            if (tagType === "style" && !doCSS)
+              continue;
+            const elements = prop.value?.type === "ArrayExpression" ? prop.value.elements : [prop.value];
+            for (const element of elements) {
+              if (!element || element.type !== "ObjectExpression")
+                continue;
+              processScriptOrStyleObject(element, tagType, code, s, pendingMinifications);
+            }
+          }
+        }
+      });
+      await Promise.all(pendingMinifications);
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: s.generateMap({ includeContent: true, source: id })
+        };
+      }
+    }
+  };
+  function processScriptOrStyleObject(objectNode, tagType, code, s, pendingMinifications) {
+    if (tagType === "script") {
+      const typeProp = objectNode.properties.find(
+        (p) => p.type === "Property" && p.key?.type === "Identifier" && p.key.name === "type"
+      );
+      if (typeProp?.value?.type === "Literal" && SKIP_JS_TYPES.has(typeProp.value.value))
+        return;
+    }
+    for (const prop of objectNode.properties) {
+      if (prop.type !== "Property" || prop.key?.type !== "Identifier")
+        continue;
+      if (!CONTENT_PROPS.has(prop.key.name))
+        continue;
+      if (prop.value?.type === "Literal") {
+        const raw = prop.value.value;
+        if (raw.length < 20)
+          continue;
+        pendingMinifications.push(
+          minifyStringContent(raw, tagType).then((minified) => {
+            if (minified && minified.length < raw.length) {
+              s.overwrite(prop.value.start, prop.value.end, JSON.stringify(minified));
+            }
+          })
+        );
+      } else if (prop.value?.type === "TemplateLiteral" && prop.value.expressions.length === 0) {
+        const raw = prop.value.quasis[0]?.value?.cooked;
+        if (!raw || raw.length < 20)
+          continue;
+        pendingMinifications.push(
+          minifyStringContent(raw, tagType).then((minified) => {
+            if (minified && minified.length < raw.length) {
+              s.overwrite(prop.value.start, prop.value.end, JSON.stringify(minified));
+            }
+          })
+        );
+      }
+    }
+  }
+  async function minifyStringContent(content, tagType) {
+    if (tagType === "script" && jsMinifier)
+      return jsMinifier(content);
+    if (tagType === "style" && cssMinifier)
+      return cssMinifier(content);
+    return null;
+  }
+});
+
+const UNHEAD_MODULE_RE = /[\\/]node_modules[\\/](?:@unhead[\\/][^\\/]+|unhead)[\\/]/;
+const HEAD_SSR_RE = /\bhead\.ssr\b/g;
+const JS_RE = /\.(?:c|m)?js$/;
+const SSRStaticReplace = createUnplugin(() => {
+  let ssr = false;
+  return {
+    name: "unhead:ssr-static-replace",
+    enforce: "pre",
+    transformInclude(id) {
+      if (!UNHEAD_MODULE_RE.test(id))
+        return false;
+      return JS_RE.test(id);
+    },
+    transform(code) {
+      if (!code.includes("head.ssr"))
+        return;
+      const s = new MagicString(code);
+      for (const match of code.matchAll(HEAD_SSR_RE)) {
+        s.overwrite(match.index, match.index + match[0].length, String(ssr));
+      }
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: s.generateMap({ includeContent: true })
+        };
+      }
+    },
+    webpack(ctx) {
+      if (ctx.name === "server")
+        ssr = true;
+    },
+    vite: {
+      apply(_config, env) {
+        if (env.isSsrBuild)
+          ssr = true;
+        return true;
+      }
+    }
+  };
+});
+
+const NODE_MODULES_RE$1 = /[\\/]node_modules[\\/]/;
+const TRANSFORM_RE$1 = /\.(?:(?:c|m)?j|t)sx?$/;
+const functionNames = [
+  "useServerHead",
+  "useServerHeadSafe",
+  "useServerSeoMeta",
+  // plugins
+  "useSchemaOrg"
+];
+const TreeshakeServerComposables = createUnplugin((options = {}) => {
+  options.enabled = options.enabled !== void 0 ? options.enabled : true;
+  return {
+    name: "unhead:remove-server-composables",
+    enforce: "post",
+    transformInclude(id) {
+      if (!options.enabled)
+        return false;
+      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+      const { type } = parseQuery(search);
+      if (NODE_MODULES_RE$1.test(pathname))
+        return false;
+      if (options.filter?.include?.some((pattern) => id.match(pattern)))
+        return true;
+      if (options.filter?.exclude?.some((pattern) => id.match(pattern)))
+        return false;
+      if (pathname.endsWith(".vue") && (type === "script" || !search))
+        return true;
+      if (TRANSFORM_RE$1.test(pathname))
+        return true;
+      return false;
+    },
+    transform(code, id) {
+      if (!code.includes("useServerHead") && !code.includes("useServerHeadSafe") && !code.includes("useServerSeoMeta") && !code.includes("useSchemaOrg")) {
+        return;
+      }
+      const ast = parseSync(id, code);
+      const s = new MagicString(code);
+      walk(ast.program, {
+        enter(node) {
+          if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && functionNames.includes(node.expression.callee.name)) {
+            s.remove(node.start, node.end);
+          }
+        }
+      });
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: s.generateMap({ includeContent: true, source: id })
+        };
+      }
+    },
+    webpack(ctx) {
+      if (ctx.name === "server")
+        options.enabled = false;
+    },
+    vite: {
+      apply(config, env) {
+        if (env.isSsrBuild) {
+          options.enabled = false;
+          return true;
+        }
+        return false;
+      }
+    }
+  };
+});
+
+const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+const TRANSFORM_RE = /\.(?:(?:c|m)?j|t)sx?$/;
+const SEO_META_NAMES = /* @__PURE__ */ new Set(["useSeoMeta", "useServerSeoMeta"]);
+const UseSeoMetaTransform = createUnplugin((options = {}) => {
+  options.imports = options.imports || true;
+  function isValidPackage(s) {
+    if (s === "unhead" || s.startsWith("@unhead")) {
+      return true;
+    }
+    return [...options.importPaths || []].includes(s);
+  }
+  return {
+    name: "unhead:use-seo-meta-transform",
+    enforce: "post",
+    transformInclude(id) {
+      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+      const { type } = parseQuery(search);
+      if (NODE_MODULES_RE.test(pathname))
+        return false;
+      if (options.filter?.include?.some((pattern) => id.match(pattern)))
+        return true;
+      if (options.filter?.exclude?.some((pattern) => id.match(pattern)))
+        return false;
+      if (pathname.endsWith(".vue") && (type === "script" || !search))
+        return true;
+      if (TRANSFORM_RE.test(pathname))
+        return true;
+      return false;
+    },
+    async transform(code, id) {
+      if (!code.includes("useSeoMeta") && !code.includes("useServerSeoMeta"))
+        return;
+      const scopeTracker = new ScopeTracker();
+      const ast = parseSync(id, code);
+      const s = new MagicString(code);
+      const importRewrites = /* @__PURE__ */ new Map();
+      const valueReferenced = /* @__PURE__ */ new Set();
+      walk(ast.program, {
+        scopeTracker,
+        enter(node, parent) {
+          if (node.type === "Identifier" && !(parent?.type === "CallExpression" && parent.callee === node) && parent?.type !== "ImportSpecifier") {
+            const decl2 = scopeTracker.getDeclaration(node.name);
+            if (decl2 instanceof ScopeTrackerImport && isValidPackage(decl2.importNode.source.value) && decl2.node.type === "ImportSpecifier" && decl2.node.imported.type === "Identifier" && SEO_META_NAMES.has(decl2.node.imported.name)) {
+              valueReferenced.add(decl2.node.imported.name);
+            }
+          }
+          if (node.type !== "CallExpression" || node.callee.type !== "Identifier")
+            return;
+          const decl = scopeTracker.getDeclaration(node.callee.name);
+          let originalName;
+          let importDecl = null;
+          if (decl instanceof ScopeTrackerImport) {
+            if (!isValidPackage(decl.importNode.source.value) || decl.node.type !== "ImportSpecifier" || decl.node.imported.type !== "Identifier")
+              return;
+            originalName = decl.node.imported.name;
+            importDecl = decl.importNode;
+          } else if (!decl && SEO_META_NAMES.has(node.callee.name)) {
+            originalName = node.callee.name;
+          } else {
+            return;
+          }
+          if (!SEO_META_NAMES.has(originalName))
+            return;
+          const properties = node.arguments[0]?.properties;
+          if (!properties)
+            return;
+          let output = [];
+          const title = properties.find((property) => property.key?.name === "title");
+          const titleTemplate = properties.find((property) => property.key?.name === "titleTemplate");
+          const meta = properties.filter((property) => property.key?.name !== "title" && property.key?.name !== "titleTemplate");
+          if (title || titleTemplate || originalName === "useSeoMeta") {
+            output.push("useHead({");
+            if (title) {
+              output.push(`  title: ${code.substring(title.value.start, title.value.end)},`);
+            }
+            if (titleTemplate) {
+              output.push(`  titleTemplate: ${code.substring(titleTemplate.value.start, titleTemplate.value.end)},`);
+            }
+          }
+          if (originalName === "useServerSeoMeta") {
+            if (output.length) {
+              const secondArg = node.arguments[1];
+              if (secondArg)
+                output.push(`}, ${code.substring(secondArg.start, secondArg.end)});`);
+              else
+                output.push("});");
+            }
+            output.push("useServerHead({");
+          }
+          if (meta.length)
+            output.push("  meta: [");
+          meta.forEach((property) => {
+            if (property.type === "SpreadElement") {
+              output = false;
+              return;
+            }
+            if (property.key.type !== "Identifier" || !property.value) {
+              output = false;
+              return;
+            }
+            if (output === false)
+              return;
+            const propertyKey = property.key;
+            let key = resolveMetaKeyType(propertyKey.name);
+            const keyValue = resolveMetaKeyValue(propertyKey.name);
+            let valueKey = "content";
+            if (keyValue === "charset") {
+              valueKey = "charset";
+              key = "charset";
+            }
+            let value = code.substring(property.value.start, property.value.end);
+            if (property.value.type === "ArrayExpression") {
+              const elements = property.value.elements;
+              if (!elements.length)
+                return;
+              const metaTags = elements.map((element) => {
+                if (element.type !== "ObjectExpression")
+                  return `    { ${key}: '${keyValue}', ${valueKey}: ${code.substring(element.start, element.end)} },`;
+                return element.properties.map((p) => {
+                  const propKey = p.key.name;
+                  const propValue = code.substring(p.value.start, p.value.end);
+                  return `    { ${key}: '${keyValue}:${propKey}', ${valueKey}: ${propValue} },`;
+                }).join("\n");
+              });
+              output.push(metaTags.join("\n"));
+              return;
+            } else if (property.value.type === "ObjectExpression") {
+              const isStatic = property.value.properties.every((p) => p.value.type === "StringLiteral" && typeof p.value.value === "string");
+              if (!isStatic) {
+                output = false;
+                return;
+              }
+              const context = createContext({
+                resolvePackedMetaObjectValue
+              });
+              const start = property.value.start;
+              const end = property.value.end;
+              try {
+                value = JSON.stringify(runInContext(`resolvePackedMetaObjectValue(${code.slice(start, end)})`, context));
+              } catch {
+                output = false;
+                return;
+              }
+            }
+            if (valueKey === "charset")
+              output.push(`    { ${key}: ${value} },`);
+            else
+              output.push(`    { ${key}: '${keyValue}', ${valueKey}: ${value} },`);
+          });
+          if (output) {
+            if (meta.length)
+              output.push("  ]");
+            if (node.arguments.length >= 2) {
+              const optionsArg = code.substring(node.arguments[1].start, node.arguments[1].end);
+              output.push(`}, ${optionsArg})`);
+            } else {
+              output.push("})");
+            }
+            s.overwrite(node.start, node.end, output.join("\n"));
+            if (importDecl) {
+              if (!importRewrites.has(importDecl))
+                importRewrites.set(importDecl, /* @__PURE__ */ new Set());
+              importRewrites.get(importDecl).add(originalName);
+            }
+          }
+        }
+      });
+      if (options.imports && importRewrites.size > 0) {
+        for (const [importNode, transformedNames] of importRewrites) {
+          const newSpecifiers = /* @__PURE__ */ new Set();
+          for (const spec of importNode.specifiers) {
+            if (spec.type !== "ImportSpecifier")
+              continue;
+            const importedName = spec.imported.name;
+            if (transformedNames.has(importedName)) {
+              newSpecifiers.add(importedName.includes("Server") ? "useServerHead" : "useHead");
+              if (valueReferenced.has(importedName))
+                newSpecifiers.add(importedName);
+            } else {
+              newSpecifiers.add(importedName);
+            }
+          }
+          s.overwrite(
+            importNode.specifiers[0].start,
+            importNode.specifiers.at(-1).end,
+            [...newSpecifiers].join(", ")
+          );
+        }
+      }
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: s.generateMap({ includeContent: true, source: id })
+        };
+      }
+    }
+  };
+});
+
+export { MinifyTransform as M, SSRStaticReplace as S, TreeshakeServerComposables as T, UseSeoMetaTransform as U };

package/dist/vite.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+import { V as VitePluginOptions } from './shared/bundler.BwKIGaKX.mjs';
+
+declare function Unhead(options?: VitePluginOptions): Plugin[];
+
+export { Unhead, VitePluginOptions };

package/dist/vite.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+import { V as VitePluginOptions } from './shared/bundler.BwKIGaKX.js';
+
+declare function Unhead(options?: VitePluginOptions): Plugin[];
+
+export { Unhead, VitePluginOptions };