unhead 0.0.6 → 0.1.0

package/dist/index.d.ts

@@ -1,20 +1,19 @@
 import * as _unhead_schema from '@unhead/schema';
-import { Head, Meta, Link, Script, Style, Base, HtmlAttributes, BodyAttributes, Noscript } from '@unhead/schema';
-import { H as HeadPlugin, C as CreateHeadOptions, a as HeadClient, b as HeadEntryOptions } from './types-b4318c02.js';
-export { A as ActiveHeadEntry, C as CreateHeadOptions, D as DomRenderTagContext, E as EntryResolveCtx, a as HeadClient, c as HeadEntry, b as HeadEntryOptions, f as HeadHooks, H as HeadPlugin, e as HookResult, R as RuntimeMode, S as SideEffectsRecord, d as defineHeadPlugin } from './types-b4318c02.js';
-import 'hookable';
+import { Head, HeadEntryOptions, Meta, Link, Script, Style, Base, HtmlAttributes, BodyAttributes, Noscript, HeadClient, CreateHeadOptions, HeadPlugin, HeadTag, HeadEntry } from '@unhead/schema';
 
-declare const DedupesTagsPlugin: HeadPlugin<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>>;
+interface DedupesTagsPluginOptions {
+    dedupeKeys?: string[];
+}
+declare const DedupesTagsPlugin: (options?: DedupesTagsPluginOptions) => _unhead_schema.HeadPlugin;
 
-declare const SortTagsPlugin: HeadPlugin<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>>;
+declare const SortTagsPlugin: () => _unhead_schema.HeadPlugin;
 
-declare const TitleTemplatePlugin: HeadPlugin<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>>;
+declare const TitleTemplatePlugin: () => _unhead_schema.HeadPlugin;
 
-declare const HydratesStatePlugin: HeadPlugin<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>>;
+declare const HydratesStatePlugin: () => _unhead_schema.HeadPlugin;
 
-declare function createHead<T extends {} = Head>(options?: CreateHeadOptions<T>): HeadClient<T>;
-
-declare function useHead<T>(input: T, options?: HeadEntryOptions): void;
+declare function useHead<T extends Head>(input: T, options?: HeadEntryOptions): void;
+declare function useServerHead<T extends Head>(input: T, options?: HeadEntryOptions): void;
 declare const useTitle: (title: string) => void;
 declare const useMeta: (meta: Meta) => void;
 declare const useLink: (link: Link) => void;
@@ -27,12 +26,18 @@ declare const useTitleTemplate: (titleTemplate: string) => void;
 declare const useNoscript: (noscript: Noscript) => void;
 
 declare let activeHead: HeadClient<any> | undefined;
-declare const setActiveHead: <T>(head: HeadClient<T> | undefined) => HeadClient<T> | undefined;
-declare const getActiveHead: <T>() => HeadClient<T>;
+declare const setActiveHead: <T extends HeadClient<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>>>(head: T | undefined) => T | undefined;
+declare const getActiveHead: <T extends HeadClient<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>>>() => T;
+
+declare function createHead<T extends {} = Head>(options?: CreateHeadOptions): HeadClient<T>;
+
+declare function defineHeadPlugin(plugin: HeadPlugin): HeadPlugin;
+
+declare function normaliseTag<T>(tagName: HeadTag['tag'], input: HeadTag['props'], entry: HeadEntry<T>): HeadTag | HeadTag[];
+declare function normaliseEntryTags<T extends {} = Head>(e: HeadEntry<T>): HeadTag[];
 
 declare type Arrayable<T> = T | Array<T>;
 declare function asArray<T>(value: Arrayable<T>): T[];
 declare const TagConfigKeys: string[];
-declare function hashCode(s: string): string;
 
-export { Arrayable, DedupesTagsPlugin, HydratesStatePlugin, SortTagsPlugin, TagConfigKeys, TitleTemplatePlugin, activeHead, asArray, createHead, getActiveHead, hashCode, setActiveHead, useBase, useBodyAttrs, useHead, useHtmlAttrs, useLink, useMeta, useNoscript, useScript, useStyle, useTitle, useTitleTemplate };
+export { Arrayable, DedupesTagsPlugin, DedupesTagsPluginOptions, HydratesStatePlugin, SortTagsPlugin, TagConfigKeys, TitleTemplatePlugin, activeHead, asArray, createHead, defineHeadPlugin, getActiveHead, normaliseEntryTags, normaliseTag, setActiveHead, useBase, useBodyAttrs, useHead, useHtmlAttrs, useLink, useMeta, useNoscript, useScript, useServerHead, useStyle, useTitle, useTitleTemplate };

package/dist/index.mjs

@@ -1,103 +1,216 @@
 import { createHooks } from 'hookable';
-import { tagDedupeKey, sortCriticalTags, resolveTitleTemplateFromTags, HasElementTags, ValidHeadTags, normaliseTag as normaliseTag$1 } from 'zhead';
 
-let activeHead;
-const setActiveHead = (head) => activeHead = head;
-const getActiveHead = () => activeHead;
+function normaliseTag$1(tagName, input, options = {}) {
+  const tag = { tag: tagName, props: {} };
+  if (tagName === "title")
+    tag.children = String(input);
+  else
+    tag.props = normaliseProps({ ...input });
+  ["children", ...options?.childrenKeys || []].forEach((key) => {
+    if (typeof tag.props[key] !== "undefined") {
+      tag.children = tag.props[key];
+      delete tag.props[key];
+    }
+  });
+  return tag;
+}
+function normaliseProps(props) {
+  for (const k in props) {
+    if (String(props[k]) === "true") {
+      props[k] = "";
+    } else if (String(props[k]) === "false") {
+      delete props[k];
+    }
+  }
+  return props;
+}
+const HasElementTags = [
+  "base",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+];
+const ValidHeadTags = [
+  "title",
+  "titleTemplate",
+  "base",
+  "htmlAttrs",
+  "bodyAttrs",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+];
 
-function defineHeadPlugin(plugin) {
-  return plugin;
+const sortCriticalTags = (aTag, bTag) => {
+  const tagWeight = (tag) => {
+    switch (tag.tag) {
+      case "base":
+        return -1;
+      case "title":
+        return 1;
+      case "meta":
+        if (tag.props.charset)
+          return -2;
+        if (tag.props["http-equiv"] === "content-security-policy")
+          return 0;
+        return 10;
+      default:
+        return 10;
+    }
+  };
+  return tagWeight(aTag) - tagWeight(bTag);
+};
+
+function tagDedupeKey(tag) {
+  const { props, tag: tagName } = tag;
+  if (["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs"].includes(tagName))
+    return tagName;
+  if (tagName === "link" && props.rel === "canonical")
+    return "canonical";
+  if (props.charset)
+    return "charset";
+  const name = ["id"];
+  if (tagName === "meta")
+    name.push(...["name", "property", "http-equiv"]);
+  for (const n of name) {
+    if (typeof props[n] !== "undefined") {
+      return `${tagName}:${n}:${props[n]}`;
+    }
+  }
+  return false;
 }
 
-const DedupesTagsPlugin = defineHeadPlugin({
-  hooks: {
-    "tag:normalise": function({ tag }) {
-      ["hid", "vmid", "key"].forEach((key) => {
-        if (tag.props[key]) {
-          tag.key = tag.props[key];
-          delete tag.props[key];
-        }
-      });
-      const dedupe = tag.key ? `${tag.tag}:${tag.key}` : tagDedupeKey(tag);
-      if (dedupe)
-        tag._d = dedupe;
-    },
-    "tags:resolve": function(ctx) {
-      const deduping = {};
-      ctx.tags.forEach((tag, i) => {
-        let dedupeKey = tag._d || tag._p || i;
-        const dupedTag = deduping[dedupeKey];
-        if (dupedTag) {
-          let strategy = tag?.tagDuplicateStrategy;
-          if (!strategy && (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs"))
-            strategy = "merge";
-          if (strategy === "merge") {
-            const oldProps = dupedTag.props;
-            ["class", "style"].forEach((key) => {
-              if (tag.props[key] && oldProps[key])
-                tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
-            });
-            deduping[dedupeKey].props = {
-              ...oldProps,
-              ...tag.props
-            };
-            return;
-          } else if (tag._e === dupedTag._e) {
-            dedupeKey = `${dedupeKey}:entry(${tag._e}:${tag._p})`;
-            tag._d = dedupeKey;
-          } else {
-            tag._p = dupedTag._p;
+const renderTitleTemplate = (template, title) => {
+  if (template == null)
+    return title || null;
+  if (typeof template === "function")
+    return template(title);
+  return template.replace("%s", title ?? "");
+};
+function resolveTitleTemplateFromTags(tags) {
+  const titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
+  const titleIdx = tags.findIndex((i) => i.tag === "title");
+  if (titleIdx !== -1 && titleTemplateIdx !== -1) {
+    const newTitle = renderTitleTemplate(
+      tags[titleTemplateIdx].children,
+      tags[titleIdx].children
+    );
+    if (newTitle !== null) {
+      tags[titleIdx].children = newTitle || tags[titleIdx].children;
+    } else {
+      tags = tags.filter((_, i) => i !== titleIdx);
+    }
+  } else if (titleTemplateIdx !== -1) {
+    const newTitle = renderTitleTemplate(
+      tags[titleTemplateIdx].children
+    );
+    if (newTitle !== null) {
+      tags[titleTemplateIdx].children = newTitle;
+      tags[titleTemplateIdx].tag = "title";
+    }
+  }
+  if (titleTemplateIdx !== -1)
+    tags = tags.filter((_, i) => i !== titleTemplateIdx);
+  return tags;
+}
+
+const DedupesTagsPlugin = (options) => {
+  options = options || {};
+  const dedupeKeys = options.dedupeKeys || ["hid", "vmid", "key"];
+  return defineHeadPlugin({
+    hooks: {
+      "tag:normalise": function({ tag }) {
+        dedupeKeys.forEach((key) => {
+          if (tag.props[key]) {
+            tag.key = tag.props[key];
+            delete tag.props[key];
           }
-          if (Object.keys(tag.props).length === 0 && !tag.children) {
-            delete deduping[dedupeKey];
-            return;
+        });
+        const dedupe = tag.key ? `${tag.tag}:${tag.key}` : tagDedupeKey(tag);
+        if (dedupe)
+          tag._d = dedupe;
+      },
+      "tags:resolve": function(ctx) {
+        const deduping = {};
+        ctx.tags.forEach((tag, i) => {
+          let dedupeKey = tag._d || tag._p || i;
+          const dupedTag = deduping[dedupeKey];
+          if (dupedTag) {
+            let strategy = tag?.tagDuplicateStrategy;
+            if (!strategy && (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs"))
+              strategy = "merge";
+            if (strategy === "merge") {
+              const oldProps = dupedTag.props;
+              ["class", "style"].forEach((key) => {
+                if (tag.props[key] && oldProps[key])
+                  tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
+              });
+              deduping[dedupeKey].props = {
+                ...oldProps,
+                ...tag.props
+              };
+              return;
+            } else if (tag._e === dupedTag._e) {
+              dedupeKey = `${dedupeKey}:entry(${tag._e}:${tag._p})`;
+              tag._d = dedupeKey;
+            } else {
+              tag._p = dupedTag._p;
+            }
+            if (Object.keys(tag.props).length === 0 && !tag.children) {
+              delete deduping[dedupeKey];
+              return;
+            }
           }
-        }
-        deduping[dedupeKey] = tag;
-      });
-      ctx.tags = Object.values(deduping);
+          deduping[dedupeKey] = tag;
+        });
+        ctx.tags = Object.values(deduping);
+      }
     }
-  }
-});
+  });
+};
 
-const SortTagsPlugin = defineHeadPlugin({
-  hooks: {
-    "tags:resolve": (ctx) => {
-      const tagIndexForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
-      for (const tag of ctx.tags) {
-        if (!tag?.tagPriority)
-          continue;
-        if (typeof tag.tagPriority === "number") {
-          tag._p = tag.tagPriority;
-          continue;
-        }
-        const modifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
-        for (const { prefix, offset } of modifiers) {
-          if (tag.tagPriority.startsWith(prefix)) {
-            const key = tag.tagPriority.replace(prefix, "");
-            const index = tagIndexForKey(key);
-            if (typeof index !== "undefined")
-              tag._p = index + offset;
+const SortTagsPlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        const tagIndexForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
+        for (const tag of ctx.tags) {
+          if (!tag?.tagPriority)
+            continue;
+          if (typeof tag.tagPriority === "number") {
+            tag._p = tag.tagPriority;
+            continue;
+          }
+          const modifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+          for (const { prefix, offset } of modifiers) {
+            if (tag.tagPriority.startsWith(prefix)) {
+              const key = tag.tagPriority.replace(prefix, "");
+              const index = tagIndexForKey(key);
+              if (typeof index !== "undefined")
+                tag._p = index + offset;
+            }
           }
         }
+        ctx.tags.sort((a, b) => a._p - b._p).sort(sortCriticalTags);
       }
-      ctx.tags.sort((a, b) => a._p - b._p).sort(sortCriticalTags);
     }
-  }
-});
+  });
+};
 
-const TitleTemplatePlugin = defineHeadPlugin({
-  hooks: {
-    "tags:resolve": (ctx) => {
-      ctx.tags = resolveTitleTemplateFromTags(ctx.tags);
+const TitleTemplatePlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        ctx.tags = resolveTitleTemplateFromTags(ctx.tags);
+      }
     }
-  }
-});
+  });
+};
 
-function asArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy"];
 function hashCode(s) {
   let h = 9;
   for (let i = 0; i < s.length; )
@@ -105,20 +218,73 @@ function hashCode(s) {
   return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 7).toLowerCase();
 }
 
-const HydratesStatePlugin = defineHeadPlugin({
-  hooks: {
-    "tag:normalise": (ctx) => {
-      const { tag, entry } = ctx;
-      if (!HasElementTags.includes(tag.tag))
-        return;
-      if (typeof tag._d === "undefined" && entry._m === "server")
-        return;
-      const hasChildren = tag.children && tag.children.length > 0;
-      tag._s = `data-h-${hashCode(tag._d || tag.tag + (hasChildren ? tag.children : JSON.stringify(tag.props)))}`;
-      tag.props[tag._s] = "";
+const HydratesStatePlugin = () => {
+  return defineHeadPlugin({
+    hooks: {
+      "tag:normalise": (ctx) => {
+        const { tag, entry } = ctx;
+        if (!HasElementTags.includes(tag.tag))
+          return;
+        if (typeof tag._d === "undefined" && entry._m === "server")
+          return;
+        const hasChildren = tag.children && tag.children.length > 0;
+        tag._s = `data-h-${hashCode(tag._d || tag.tag + (hasChildren ? tag.children : JSON.stringify(tag.props)))}`;
+        tag.props[tag._s] = "";
+      }
     }
-  }
-});
+  });
+};
+
+const IsClient = typeof window !== "undefined";
+
+let activeHead;
+const setActiveHead = (head) => activeHead = head;
+const getActiveHead = () => activeHead;
+
+function useHead(input, options = {}) {
+  if (options.mode === "server" && IsClient || options.mode === "client" && !IsClient)
+    return;
+  const head = getActiveHead();
+  head.push(input, options);
+}
+function useServerHead(input, options = {}) {
+  useHead(input, { ...options, mode: "server" });
+}
+const useTitle = (title) => {
+  useHead({ title });
+};
+const useMeta = (meta) => {
+  useHead({ meta: [meta] });
+};
+const useLink = (link) => {
+  useHead({ link: [link] });
+};
+const useScript = (script) => {
+  useHead({ script: [script] });
+};
+const useStyle = (style) => {
+  useHead({ style: [style] });
+};
+const useBase = (base) => {
+  useHead({ base });
+};
+const useHtmlAttrs = (attrs) => {
+  useHead({ htmlAttrs: attrs });
+};
+const useBodyAttrs = (attrs) => {
+  useHead({ bodyAttrs: attrs });
+};
+const useTitleTemplate = (titleTemplate) => {
+  useHead({ titleTemplate });
+};
+const useNoscript = (noscript) => {
+  useHead({ noscript: [noscript] });
+};
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy"];
 
 function normaliseTag(tagName, input, entry) {
   const tag = normaliseTag$1(tagName, input, { childrenKeys: ["innerHTML", "textContent"] });
@@ -159,9 +325,9 @@ function createHead(options = {}) {
   if (options.hooks)
     hooks.addHooks(options.hooks);
   const plugins = [
-    DedupesTagsPlugin,
-    SortTagsPlugin,
-    TitleTemplatePlugin
+    DedupesTagsPlugin(),
+    SortTagsPlugin(),
+    TitleTemplatePlugin()
   ];
   plugins.push(...options.plugins || []);
   plugins.forEach((plugin) => hooks.addHooks(plugin.hooks || {}));
@@ -227,39 +393,8 @@ function createHead(options = {}) {
   return head;
 }
 
-function useHead(input, options = {}) {
-  const head = getActiveHead();
-  head.push(input, options);
+function defineHeadPlugin(plugin) {
+  return plugin;
 }
-const useTitle = (title) => {
-  useHead({ title });
-};
-const useMeta = (meta) => {
-  useHead({ meta: [meta] });
-};
-const useLink = (link) => {
-  useHead({ link: [link] });
-};
-const useScript = (script) => {
-  useHead({ script: [script] });
-};
-const useStyle = (style) => {
-  useHead({ style: [style] });
-};
-const useBase = (base) => {
-  useHead({ base });
-};
-const useHtmlAttrs = (attrs) => {
-  useHead({ htmlAttrs: attrs });
-};
-const useBodyAttrs = (attrs) => {
-  useHead({ bodyAttrs: attrs });
-};
-const useTitleTemplate = (titleTemplate) => {
-  useHead({ titleTemplate });
-};
-const useNoscript = (noscript) => {
-  useHead({ noscript: [noscript] });
-};
 
-export { DedupesTagsPlugin, HydratesStatePlugin, SortTagsPlugin, TagConfigKeys, TitleTemplatePlugin, activeHead, asArray, createHead, defineHeadPlugin, getActiveHead, hashCode, setActiveHead, useBase, useBodyAttrs, useHead, useHtmlAttrs, useLink, useMeta, useNoscript, useScript, useStyle, useTitle, useTitleTemplate };
+export { DedupesTagsPlugin, HydratesStatePlugin, SortTagsPlugin, TagConfigKeys, TitleTemplatePlugin, activeHead, asArray, createHead, defineHeadPlugin, getActiveHead, normaliseEntryTags, normaliseTag, setActiveHead, useBase, useBodyAttrs, useHead, useHtmlAttrs, useLink, useMeta, useNoscript, useScript, useServerHead, useStyle, useTitle, useTitleTemplate };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unhead",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "packageManager": "pnpm@7.14.0",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
@@ -20,14 +20,6 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
-    },
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.mjs"
-    },
-    "./client": {
-      "types": "./dist/client.d.ts",
-      "import": "./dist/client.mjs"
     }
   },
   "module": "dist/index.mjs",
@@ -36,12 +28,15 @@
     "dist"
   ],
   "dependencies": {
-    "@unhead/schema": "0.0.6",
-    "hookable": "^5.4.1",
+    "@unhead/schema": "0.1.0",
+    "hookable": "^5.4.1"
+  },
+  "devDependencies": {
     "zhead": "1.0.0-beta.4"
   },
   "scripts": {
     "build": "unbuild .",
-    "stub": "unbuild . --stub"
+    "stub": "unbuild . --stub",
+    "export:sizes": "npx export-size . -r"
   }
 }

package/dist/client.d.ts

@@ -1,24 +0,0 @@
-import { a as HeadClient } from './types-b4318c02.js';
-import 'hookable';
-import '@unhead/schema';
-
-interface RenderDomHeadOptions {
-    /**
-     * Document to use for rendering. Allows stubbing for testing.
-     */
-    document?: Document;
-}
-/**
- * Render the head tags to the DOM.
- */
-declare function renderDOMHead<T extends HeadClient<any>>(head: T, options?: RenderDomHeadOptions): Promise<void>;
-/**
- * Global instance of the dom update promise. Used for debounding head updates.
- */
-declare let domUpdatePromise: Promise<void> | null;
-/**
- * Queue a debounced update of the DOM head.
- */
-declare function debouncedRenderDOMHead<T extends HeadClient<any>>(delayedFn: (fn: () => void) => void, head: T, options?: RenderDomHeadOptions): Promise<void>;
-
-export { RenderDomHeadOptions, debouncedRenderDOMHead, domUpdatePromise, renderDOMHead };

package/dist/client.mjs

@@ -1,89 +0,0 @@
-import { createElement, TagsWithInnerContent } from 'zhead';
-
-function setAttributesWithSideEffects(head, $el, entry, tag) {
-  const attrs = tag.props || {};
-  const sdeKey = `${tag._p}:attr`;
-  Object.entries(entry._sde).filter(([key]) => key.startsWith(sdeKey)).forEach(([key, fn]) => {
-    delete entry._sde[key] && fn();
-  });
-  Object.entries(attrs).forEach(([k, value]) => {
-    value = String(value);
-    const attrSdeKey = `${sdeKey}:${k}`;
-    head._removeQueuedSideEffect(attrSdeKey);
-    if (k === "class") {
-      for (const c of value.split(" ")) {
-        if (!$el.classList.contains(c)) {
-          $el.classList.add(c);
-          head._removeQueuedSideEffect(`${attrSdeKey}:${c}`);
-          entry._sde[`${attrSdeKey}:${c}`] = () => $el.classList.remove(c);
-        }
-      }
-      return;
-    }
-    if ($el.getAttribute(k) !== value) {
-      $el.setAttribute(k, value);
-      if (!k.startsWith("data-h-"))
-        entry._sde[attrSdeKey] = () => $el.removeAttribute(k);
-    }
-  });
-}
-
-async function renderDOMHead(head, options = {}) {
-  const dom = options.document || window.document;
-  const tags = await head.resolveTags();
-  await head.hooks.callHook("dom:beforeRender", { head, tags, document: dom });
-  for (const tag of tags) {
-    const entry = head.headEntries().find((e) => e._i === Number(tag._e));
-    const sdeKey = `${tag._s || tag._p}:el`;
-    const $newEl = createElement(tag, dom);
-    const $el = tag._s ? dom.querySelector(`[${tag._s}]`) : null;
-    const renderCtx = { tag, document: dom, head };
-    await head.hooks.callHook("dom:renderTag", renderCtx);
-    if ($el) {
-      head._removeQueuedSideEffect(sdeKey);
-      if ($newEl.isEqualNode($el))
-        continue;
-      if (Object.keys(tag.props).length === 0) {
-        $el.remove();
-        continue;
-      }
-      setAttributesWithSideEffects(head, $el, entry, tag);
-      if (TagsWithInnerContent.includes(tag.tag))
-        $el.innerHTML = tag.children || "";
-      entry._sde[sdeKey] = () => $el?.remove();
-      continue;
-    }
-    if (tag.tag === "title" && tag.children) {
-      dom.title = tag.children;
-      continue;
-    }
-    if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
-      setAttributesWithSideEffects(head, dom[tag.tag === "htmlAttrs" ? "documentElement" : "body"], entry, tag);
-      continue;
-    }
-    switch (tag.tagPosition) {
-      case "bodyClose":
-        dom.body.appendChild($newEl);
-        break;
-      case "bodyOpen":
-        dom.body.insertBefore($newEl, dom.body.firstChild);
-        break;
-      case "head":
-      default:
-        dom.head.appendChild($newEl);
-        break;
-    }
-    entry._sde[sdeKey] = () => $newEl?.remove();
-  }
-  head._flushQueuedSideEffects();
-}
-let domUpdatePromise = null;
-async function debouncedRenderDOMHead(delayedFn, head, options = {}) {
-  function doDomUpdate() {
-    domUpdatePromise = null;
-    return renderDOMHead(head, options);
-  }
-  return domUpdatePromise = domUpdatePromise || new Promise((resolve) => delayedFn(() => resolve(doDomUpdate())));
-}
-
-export { debouncedRenderDOMHead, domUpdatePromise, renderDOMHead };

package/dist/server.d.ts

@@ -1,3 +0,0 @@
-export { g as SSRHeadPayload, r as renderSSRHead } from './types-b4318c02.js';
-import 'hookable';
-import '@unhead/schema';

package/dist/server.mjs

@@ -1,13 +0,0 @@
-import { ssrRenderTags } from 'zhead';
-
-async function renderSSRHead(ctx) {
-  const tags = await ctx.resolveTags();
-  const beforeRenderCtx = { tags };
-  await ctx.hooks.callHook("ssr:beforeRender", beforeRenderCtx);
-  const html = ssrRenderTags(beforeRenderCtx.tags);
-  const renderCXx = { tags, html };
-  await ctx.hooks.callHook("ssr:render", renderCXx);
-  return renderCXx.html;
-}
-
-export { renderSSRHead };

package/dist/types-b4318c02.d.ts

@@ -1,131 +0,0 @@
-import { NestedHooks, Hookable } from 'hookable';
-import { Head, HeadTag } from '@unhead/schema';
-
-declare type HeadPlugin<O> = Omit<CreateHeadOptions<O>, 'plugins'>;
-declare function defineHeadPlugin<O = Head>(plugin: HeadPlugin<O>): HeadPlugin<O>;
-
-interface SSRHeadPayload {
-    headTags: string;
-    bodyTags: string;
-    bodyTagsOpen: string;
-    htmlAttrs: string;
-    bodyAttrs: string;
-}
-declare function renderSSRHead<T extends HeadClient<any>>(ctx: T): Promise<SSRHeadPayload>;
-
-/**
- * An active head entry provides an API to manipulate it.
- */
-interface ActiveHeadEntry<T> {
-    /**
-     * Updates the entry with new input.
-     *
-     * Will first clear any side effects for previous input.
-     */
-    patch: (resolvedInput: T) => void;
-    /**
-     * Dispose the entry, removing it from the active head.
-     *
-     * Will queue side effects for removal.
-     */
-    dispose: () => void;
-}
-/**
- * Side effects are mapped with a key and their cleanup function.
- *
- * For example `meta:data-h-4h46h465`: () => { document.querySelector('meta[data-h-4h46h465]').remove() }
- */
-declare type SideEffectsRecord = Record<string, () => void>;
-declare type RuntimeMode = 'server' | 'client' | 'all';
-interface HeadEntry<T> {
-    /**
-     * User provided input for the entry.
-     */
-    input: T;
-    /**
-     * The mode that the entry should be used in.
-     *
-     * @internal
-     */
-    _m?: RuntimeMode;
-    /**
-     * Head entry index
-     *
-     * @internal
-     */
-    _i: number;
-    /**
-     * Side effects
-     *
-     * @internal
-     */
-    _sde: SideEffectsRecord;
-}
-declare type HookResult = Promise<void> | void;
-interface DomRenderTagContext {
-    head: HeadClient;
-    tag: HeadTag;
-    document: Document;
-}
-interface EntryResolveCtx<T> {
-    tags: HeadTag[];
-    entries: HeadEntry<T>[];
-}
-interface HeadHooks<T> {
-    'entries:resolve': (ctx: EntryResolveCtx<T>) => HookResult;
-    'tag:normalise': (ctx: {
-        tag: HeadTag;
-        entry: HeadEntry<T>;
-    }) => HookResult;
-    'tags:resolve': (ctx: {
-        tags: HeadTag[];
-    }) => HookResult;
-    'dom:beforeRender': (ctx: {
-        head: HeadClient;
-        tags: HeadTag[];
-        document: Document;
-    }) => HookResult;
-    'dom:renderTag': (ctx: DomRenderTagContext) => HookResult;
-    'ssr:beforeRender': (ctx: {
-        tags: HeadTag[];
-    }) => HookResult;
-    'ssr:render': (ctx: {
-        tags: HeadTag[];
-        html: SSRHeadPayload;
-    }) => HookResult;
-}
-interface CreateHeadOptions<T> {
-    plugins?: HeadPlugin<any>[];
-    hooks?: NestedHooks<HeadHooks<T>>;
-}
-interface HeadEntryOptions {
-    mode?: RuntimeMode;
-}
-interface HeadClient<T = Head> {
-    /**
-     * The active head entries.
-     */
-    headEntries: () => HeadEntry<T>[];
-    /**
-     * Create a new head entry.
-     */
-    push: (entry: T, options?: HeadEntryOptions) => ActiveHeadEntry<T>;
-    /**
-     * Resolve tags from head entries.
-     */
-    resolveTags: () => Promise<HeadTag[]>;
-    /**
-     * Exposed hooks for easier extension.
-     */
-    hooks: Hookable<HeadHooks<T>>;
-    /**
-     * @internal
-     */
-    _removeQueuedSideEffect: (key: string) => void;
-    /**
-     * @internal
-     */
-    _flushQueuedSideEffects: () => void;
-}
-
-export { ActiveHeadEntry as A, CreateHeadOptions as C, DomRenderTagContext as D, EntryResolveCtx as E, HeadPlugin as H, RuntimeMode as R, SideEffectsRecord as S, HeadClient as a, HeadEntryOptions as b, HeadEntry as c, defineHeadPlugin as d, HookResult as e, HeadHooks as f, SSRHeadPayload as g, renderSSRHead as r };