unhead 2.0.0-alpha.0 → 2.0.0-alpha.10

package/README.md

@@ -0,0 +1,13 @@
+# `unhead`
+
+Visit the [documentation site](https://unhead.unjs.io/) for guides and API references.
+
+## Install
+
+```bash
+npm i unhead
+```
+
+## License
+
+MIT License © 2022-PRESENT [Harlan Wilton](https://github.com/harlan-zw)

package/dist/client.d.mts

@@ -1,25 +1,14 @@
-import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateClientHeadOptions, Unhead, DomPluginOptions, RenderDomHeadOptions } from '@unhead/schema';
+import * as unhead_types from 'unhead/types';
+import { a as Head, b as CreateClientHeadOptions, U as Unhead, R as RenderDomHeadOptions } from './shared/unhead.CnmTxLaQ.mjs';
+import 'hookable';
 
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): _unhead_schema.Unhead<T>;
-
-/**
- * Queue a debounced update of the DOM head.
- */
-declare function debouncedRenderDOMHead<T extends Unhead<any>>(head: T, options?: DomPluginOptions): Promise<void>;
-
-declare function DomPlugin(options?: DomPluginOptions): _unhead_schema.HeadPluginInput;
-
-/**
- * Supports DOM event handlers (i.e `onload`) as functions.
- *
- * When SSR we need to strip out these values. On CSR we
- */
-declare const ClientEventHandlerPlugin: _unhead_schema.HeadPluginInput;
+declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): unhead_types.Unhead<T>;
 
 /**
  * Render the head tags to the DOM.
  */
 declare function renderDOMHead<T extends Unhead<any>>(head: T, options?: RenderDomHeadOptions): Promise<void>;
 
-export { ClientEventHandlerPlugin, DomPlugin, createHead, debouncedRenderDOMHead, renderDOMHead };
+declare function createDebouncedFn(callee: () => void, delayer: (fn: () => void) => void): () => void;
+
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/client.d.ts

@@ -1,25 +1,14 @@
-import * as _unhead_schema from '@unhead/schema';
-import { Head, CreateClientHeadOptions, Unhead, DomPluginOptions, RenderDomHeadOptions } from '@unhead/schema';
+import * as unhead_types from 'unhead/types';
+import { a as Head, b as CreateClientHeadOptions, U as Unhead, R as RenderDomHeadOptions } from './shared/unhead.CnmTxLaQ.js';
+import 'hookable';
 
-declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): _unhead_schema.Unhead<T>;
-
-/**
- * Queue a debounced update of the DOM head.
- */
-declare function debouncedRenderDOMHead<T extends Unhead<any>>(head: T, options?: DomPluginOptions): Promise<void>;
-
-declare function DomPlugin(options?: DomPluginOptions): _unhead_schema.HeadPluginInput;
-
-/**
- * Supports DOM event handlers (i.e `onload`) as functions.
- *
- * When SSR we need to strip out these values. On CSR we
- */
-declare const ClientEventHandlerPlugin: _unhead_schema.HeadPluginInput;
+declare function createHead<T extends Record<string, any> = Head>(options?: CreateClientHeadOptions): unhead_types.Unhead<T>;
 
 /**
  * Render the head tags to the DOM.
  */
 declare function renderDOMHead<T extends Unhead<any>>(head: T, options?: RenderDomHeadOptions): Promise<void>;
 
-export { ClientEventHandlerPlugin, DomPlugin, createHead, debouncedRenderDOMHead, renderDOMHead };
+declare function createDebouncedFn(callee: () => void, delayer: (fn: () => void) => void): () => void;
+
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/client.mjs

@@ -1,24 +1,216 @@
-import { IsBrowser } from '@unhead/shared';
-import { a as unheadCtx } from './shared/unhead.BxCMBVrg.mjs';
-import { c as createHeadCore } from './shared/unhead.DJ2B9fZW.mjs';
-import { D as DomPlugin, C as ClientEventHandlerPlugin } from './shared/unhead.ovi5lkPs.mjs';
-export { d as debouncedRenderDOMHead, r as renderDOMHead } from './shared/unhead.ovi5lkPs.mjs';
-import 'unctx';
+import { c as createHeadCore } from './shared/unhead.BfOKU5JT.mjs';
+import { H as HasElementTags } from './shared/unhead.BX2ITVEM.mjs';
+import { h as hashTag, i as isMetaArrayDupeKey, a as normalizeProps, d as dedupeKey } from './shared/unhead.CGUU1vXi.mjs';
 import 'hookable';
-import './shared/unhead.9459P6Us.mjs';
+
+async function renderDOMHead(head, options = {}) {
+  const dom = options.document || head.resolvedOptions.document;
+  if (!dom || !head.dirty)
+    return;
+  const beforeRenderCtx = { shouldRender: true, tags: [] };
+  await head.hooks.callHook("dom:beforeRender", beforeRenderCtx);
+  if (!beforeRenderCtx.shouldRender)
+    return;
+  if (head._domUpdatePromise) {
+    return head._domUpdatePromise;
+  }
+  head._domUpdatePromise = new Promise(async (resolve) => {
+    const dupeKeyCounter = /* @__PURE__ */ new Map();
+    const resolveTagPromise = new Promise((resolve2) => {
+      head.resolveTags().then((tags2) => {
+        resolve2(
+          tags2.map((tag) => {
+            const count = dupeKeyCounter.get(tag._d) || 0;
+            const res = {
+              tag,
+              id: (count ? `${tag._d}:${count}` : tag._d) || hashTag(tag),
+              shouldRender: true
+            };
+            if (tag._d && isMetaArrayDupeKey(tag._d)) {
+              dupeKeyCounter.set(tag._d, count + 1);
+            }
+            return res;
+          })
+        );
+      });
+    });
+    let state = head._dom;
+    if (!state) {
+      state = {
+        elMap: (/* @__PURE__ */ new Map()).set("htmlAttrs", dom.documentElement).set("bodyAttrs", dom.body)
+      };
+      for (const key of ["body", "head"]) {
+        const children = dom[key]?.children;
+        for (const c of children) {
+          const tag = c.tagName.toLowerCase();
+          if (!HasElementTags.has(tag)) {
+            continue;
+          }
+          const next = normalizeProps({ tag, props: {} }, {
+            innerHTML: c.innerHTML,
+            ...c.getAttributeNames().reduce((props, name) => {
+              props[name] = c.getAttribute(name);
+              return props;
+            }, {}) || {}
+          });
+          next.key = c.getAttribute("data-hid") || undefined;
+          next._d = dedupeKey(next) || hashTag(next);
+          if (state.elMap.has(next._d)) {
+            let count = 1;
+            let k = next._d;
+            while (state.elMap.has(k)) {
+              k = `${next._d}:${count++}`;
+            }
+            state.elMap.set(k, c);
+          } else {
+            state.elMap.set(next._d, c);
+          }
+        }
+      }
+    }
+    state.pendingSideEffects = { ...state.sideEffects };
+    state.sideEffects = {};
+    function track(id, scope, fn) {
+      const k = `${id}:${scope}`;
+      state.sideEffects[k] = fn;
+      delete state.pendingSideEffects[k];
+    }
+    function trackCtx({ id, $el, tag }) {
+      const isAttrTag = tag.tag.endsWith("Attrs");
+      state.elMap.set(id, $el);
+      if (!isAttrTag) {
+        if (tag.textContent && tag.textContent !== $el.textContent) {
+          $el.textContent = tag.textContent;
+        }
+        if (tag.innerHTML && tag.innerHTML !== $el.innerHTML) {
+          $el.innerHTML = tag.innerHTML;
+        }
+        track(id, "el", () => {
+          $el?.remove();
+          state.elMap.delete(id);
+        });
+      }
+      for (const k in tag.props) {
+        if (!Object.hasOwn(tag.props, k))
+          continue;
+        const value = tag.props[k];
+        if (k.startsWith("on") && typeof value === "function") {
+          const dataset = $el?.dataset;
+          if (dataset && dataset[`${k}fired`]) {
+            const ek = k.slice(0, -5);
+            value.call($el, new Event(ek.substring(2)));
+          }
+          if ($el.getAttribute(`data-${k}`) !== "") {
+            (tag.tag === "bodyAttrs" ? dom.defaultView : $el).addEventListener(
+              // onload -> load
+              k.substring(2),
+              value.bind($el)
+            );
+            $el.setAttribute(`data-${k}`, "");
+          }
+          continue;
+        }
+        const ck = `attr:${k}`;
+        if (k === "class") {
+          if (!value) {
+            continue;
+          }
+          for (const c of value) {
+            isAttrTag && track(id, `${ck}:${c}`, () => $el.classList.remove(c));
+            !$el.classList.contains(c) && $el.classList.add(c);
+          }
+        } else if (k === "style") {
+          if (!value) {
+            continue;
+          }
+          for (const [k2, v] of value) {
+            track(id, `${ck}:${k2}`, () => {
+              $el.style.removeProperty(k2);
+            });
+            $el.style.setProperty(k2, v);
+          }
+        } else if (value !== false && value !== null) {
+          $el.getAttribute(k) !== value && $el.setAttribute(k, value === true ? "" : String(value));
+          isAttrTag && track(id, ck, () => $el.removeAttribute(k));
+        }
+      }
+    }
+    const pending = [];
+    const frag = {
+      bodyClose: undefined,
+      bodyOpen: undefined,
+      head: undefined
+    };
+    const tags = await resolveTagPromise;
+    for (const ctx of tags) {
+      const { tag, shouldRender, id } = ctx;
+      if (!shouldRender)
+        continue;
+      if (tag.tag === "title") {
+        dom.title = tag.textContent;
+        continue;
+      }
+      ctx.$el = ctx.$el || state.elMap.get(id);
+      if (ctx.$el) {
+        trackCtx(ctx);
+      } else if (HasElementTags.has(tag.tag)) {
+        pending.push(ctx);
+      }
+    }
+    for (const ctx of pending) {
+      const pos = ctx.tag.tagPosition || "head";
+      ctx.$el = dom.createElement(ctx.tag.tag);
+      trackCtx(ctx);
+      frag[pos] = frag[pos] || dom.createDocumentFragment();
+      frag[pos].appendChild(ctx.$el);
+    }
+    for (const ctx of tags)
+      await head.hooks.callHook("dom:renderTag", ctx, dom, track);
+    frag.head && dom.head.appendChild(frag.head);
+    frag.bodyOpen && dom.body.insertBefore(frag.bodyOpen, dom.body.firstChild);
+    frag.bodyClose && dom.body.appendChild(frag.bodyClose);
+    for (const k in state.pendingSideEffects) {
+      state.pendingSideEffects[k]();
+    }
+    head._dom = state;
+    await head.hooks.callHook("dom:rendered", { renders: tags });
+    resolve();
+  }).finally(() => {
+    head._domUpdatePromise = undefined;
+    head.dirty = false;
+  });
+  return head._domUpdatePromise;
+}
 
 function createHead(options = {}) {
   const head = createHeadCore({
-    document: IsBrowser ? document : undefined,
-    ...options,
-    plugins: [
-      ...options.plugins || [],
-      DomPlugin(options.domOptions),
-      ClientEventHandlerPlugin
-    ]
+    document: typeof window !== "undefined" ? document : undefined,
+    ...options
+  });
+  const initialPayload = head.resolvedOptions.document?.head.querySelector('script[id="unhead:payload"]')?.innerHTML || false;
+  if (initialPayload) {
+    head.push(JSON.parse(initialPayload));
+  }
+  const render = options.domOptions?.render || renderDOMHead;
+  head.use({
+    key: "client",
+    hooks: {
+      "entries:updated": render
+    }
   });
-  unheadCtx.set(head, true);
   return head;
 }
 
-export { ClientEventHandlerPlugin, DomPlugin, createHead };
+function createDebouncedFn(callee, delayer) {
+  let ctxId = 0;
+  return () => {
+    const delayFnCtxId = ++ctxId;
+    delayer(() => {
+      if (ctxId === delayFnCtxId) {
+        callee();
+      }
+    });
+  };
+}
+
+export { createDebouncedFn, createHead, renderDOMHead };

package/dist/index.d.mts

@@ -1,24 +1,15 @@
-import { MergeHead, Head, HeadEntryOptions, ActiveHeadEntry, HeadSafe, UseSeoMetaInput } from '@unhead/schema';
-export { c as createHeadCore, t as tryUseUnhead, u as unheadCtx, a as useUnhead } from './shared/unhead.Bkkr-JOb.mjs';
-export { composableNames } from '@unhead/shared';
-import 'unctx/index';
+import { U as Unhead, H as HeadEntryOptions, A as ActiveHeadEntry, h as UseSeoMetaInput, a as Head, C as CreateHeadOptions } from './shared/unhead.CnmTxLaQ.mjs';
+import { HeadSafe } from './types.mjs';
+import 'hookable';
 
-declare const unheadComposablesImports: {
-    from: string;
-    imports: string[];
-}[];
+declare function useHead<T extends Unhead<any>>(unhead: T, input: Parameters<T['push']>[0], options?: HeadEntryOptions): ReturnType<T['push']>;
+declare function useHeadSafe<T extends Unhead<any>>(unhead: T, input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
+declare function useSeoMeta<T extends Unhead<any>>(unhead: T, input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
 
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
+/**
+ * Creates a core instance of unhead. Does not provide a global ctx for composables to work
+ * and does not register DOM plugins.
+ */
+declare function createHeadCore<T extends Record<string, any> = Head>(resolvedOptions?: CreateHeadOptions): Unhead<T>;
 
-declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
-
-declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
-
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
-
-declare function useServerHeadSafe<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T>;
-
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
-
-export { type UseHeadInput, unheadComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { createHeadCore, useHead, useHeadSafe, useSeoMeta };

package/dist/index.d.ts

@@ -1,24 +1,15 @@
-import { MergeHead, Head, HeadEntryOptions, ActiveHeadEntry, HeadSafe, UseSeoMetaInput } from '@unhead/schema';
-export { c as createHeadCore, t as tryUseUnhead, u as unheadCtx, a as useUnhead } from './shared/unhead.Bkkr-JOb.js';
-export { composableNames } from '@unhead/shared';
-import 'unctx/index';
+import { U as Unhead, H as HeadEntryOptions, A as ActiveHeadEntry, h as UseSeoMetaInput, a as Head, C as CreateHeadOptions } from './shared/unhead.CnmTxLaQ.js';
+import { HeadSafe } from './types.js';
+import 'hookable';
 
-declare const unheadComposablesImports: {
-    from: string;
-    imports: string[];
-}[];
+declare function useHead<T extends Unhead<any>>(unhead: T, input: Parameters<T['push']>[0], options?: HeadEntryOptions): ReturnType<T['push']>;
+declare function useHeadSafe<T extends Unhead<any>>(unhead: T, input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
+declare function useSeoMeta<T extends Unhead<any>>(unhead: T, input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
 
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
+/**
+ * Creates a core instance of unhead. Does not provide a global ctx for composables to work
+ * and does not register DOM plugins.
+ */
+declare function createHeadCore<T extends Record<string, any> = Head>(resolvedOptions?: CreateHeadOptions): Unhead<T>;
 
-declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
-
-declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
-
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
-
-declare function useServerHeadSafe<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T>;
-
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
-
-export { type UseHeadInput, unheadComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { createHeadCore, useHead, useHeadSafe, useSeoMeta };

package/dist/index.mjs

@@ -1,66 +1,7 @@
-import { composableNames, whitelistSafeInput, unpackMeta } from '@unhead/shared';
-export { composableNames } from '@unhead/shared';
-import { u as useUnhead } from './shared/unhead.BxCMBVrg.mjs';
-export { t as tryUseUnhead, a as unheadCtx } from './shared/unhead.BxCMBVrg.mjs';
-export { c as createHeadCore } from './shared/unhead.DJ2B9fZW.mjs';
-import 'unctx';
+export { u as useHead, a as useHeadSafe, b as useSeoMeta } from './shared/unhead.DgyS1B7b.mjs';
+export { c as createHeadCore } from './shared/unhead.BfOKU5JT.mjs';
+import './shared/unhead.Cktr7sRK.mjs';
+import './shared/unhead.CnyuWd5e.mjs';
+import './shared/unhead.BX2ITVEM.mjs';
 import 'hookable';
-import './shared/unhead.9459P6Us.mjs';
-
-const unheadComposablesImports = [
-  {
-    from: "unhead",
-    imports: composableNames
-  }
-];
-
-function useHead(input, options = {}) {
-  const head = options.head || useUnhead();
-  return head.push(input, options);
-}
-
-function useHeadSafe(input, options) {
-  return useHead(input, {
-    ...options,
-    transform: whitelistSafeInput
-  });
-}
-
-function useSeoMeta(input, options) {
-  const { title, titleTemplate, ...meta } = input;
-  return useHead({
-    title,
-    titleTemplate,
-    // we need to input the meta so the reactivity will be resolved
-    // @ts-expect-error runtime type
-    _flatMeta: meta
-  }, {
-    ...options,
-    transform(t) {
-      const meta2 = unpackMeta({ ...t._flatMeta });
-      delete t._flatMeta;
-      return {
-        // @ts-expect-error runtime type
-        ...t,
-        meta: meta2
-      };
-    }
-  });
-}
-
-function useServerHead(input, options = {}) {
-  return useHead(input, { ...options, mode: "server" });
-}
-
-function useServerHeadSafe(input, options = {}) {
-  return useHeadSafe(input, { ...options, mode: "server" });
-}
-
-function useServerSeoMeta(input, options) {
-  return useSeoMeta(input, {
-    ...options,
-    mode: "server"
-  });
-}
-
-export { unheadComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta, useUnhead };
+import './shared/unhead.CGUU1vXi.mjs';

package/dist/legacy.d.mts

@@ -1,6 +1,7 @@
-import { Script, ActiveHeadEntry, HeadEntryOptions, Head, CreateHeadOptions, Unhead, MergeHead, HeadSafe, UseSeoMetaInput } from '@unhead/schema';
-export { c as createHeadCore, t as tryUseUnhead, u as unheadCtx, a as useUnhead } from './shared/unhead.Bkkr-JOb.mjs';
-import 'unctx/index';
+export { createHeadCore, useHead, useHeadSafe, useSeoMeta } from './index.mjs';
+import { S as Script, A as ActiveHeadEntry, H as HeadEntryOptions, U as Unhead, a as Head, C as CreateHeadOptions } from './shared/unhead.CnmTxLaQ.mjs';
+import './types.mjs';
+import 'hookable';
 
 type UseScriptInput = string | (Omit<Script, 'src'> & {
     src: string;
@@ -93,15 +94,16 @@ type UseFunctionType<T, U> = T extends {
  */
 declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
 
+declare const activeHead: {
+    value: Unhead<any> | null;
+};
+declare function getActiveHead(): Unhead<any> | null;
+declare const unheadComposablesImports: {
+    from: string;
+    imports: string[];
+}[];
+declare const composableNames: string[];
 declare function createServerHead<T extends Record<string, any> = Head>(options?: CreateHeadOptions): Unhead<T>;
 declare function createHead<T extends Record<string, any> = Head>(options?: CreateHeadOptions): Unhead<T>;
-declare function getActiveHead(): Unhead<Head<MergeHead>> | null;
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe> | void;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useServerHeadSafe<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-export { type AsAsyncFunctionValues, type ScriptInstance, type UseFunctionType, type UseHeadInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptResolvedInput, type UseScriptStatus, createHead, createServerHead, getActiveHead, resolveScriptKey, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { type AsAsyncFunctionValues, type ScriptInstance, type UseFunctionType, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptResolvedInput, type UseScriptStatus, activeHead, composableNames, createHead, createServerHead, getActiveHead, resolveScriptKey, unheadComposablesImports, useScript };

package/dist/legacy.d.ts

@@ -1,6 +1,7 @@
-import { Script, ActiveHeadEntry, HeadEntryOptions, Head, CreateHeadOptions, Unhead, MergeHead, HeadSafe, UseSeoMetaInput } from '@unhead/schema';
-export { c as createHeadCore, t as tryUseUnhead, u as unheadCtx, a as useUnhead } from './shared/unhead.Bkkr-JOb.js';
-import 'unctx/index';
+export { createHeadCore, useHead, useHeadSafe, useSeoMeta } from './index.js';
+import { S as Script, A as ActiveHeadEntry, H as HeadEntryOptions, U as Unhead, a as Head, C as CreateHeadOptions } from './shared/unhead.CnmTxLaQ.js';
+import './types.js';
+import 'hookable';
 
 type UseScriptInput = string | (Omit<Script, 'src'> & {
     src: string;
@@ -93,15 +94,16 @@ type UseFunctionType<T, U> = T extends {
  */
 declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
 
+declare const activeHead: {
+    value: Unhead<any> | null;
+};
+declare function getActiveHead(): Unhead<any> | null;
+declare const unheadComposablesImports: {
+    from: string;
+    imports: string[];
+}[];
+declare const composableNames: string[];
 declare function createServerHead<T extends Record<string, any> = Head>(options?: CreateHeadOptions): Unhead<T>;
 declare function createHead<T extends Record<string, any> = Head>(options?: CreateHeadOptions): Unhead<T>;
-declare function getActiveHead(): Unhead<Head<MergeHead>> | null;
-type UseHeadInput<T extends MergeHead> = Head<T>;
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe> | void;
-declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
-declare function useServerHeadSafe<T extends HeadSafe>(input: T, options?: HeadEntryOptions): ActiveHeadEntry<T> | void;
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-export { type AsAsyncFunctionValues, type ScriptInstance, type UseFunctionType, type UseHeadInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptResolvedInput, type UseScriptStatus, createHead, createServerHead, getActiveHead, resolveScriptKey, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { type AsAsyncFunctionValues, type ScriptInstance, type UseFunctionType, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type UseScriptResolvedInput, type UseScriptStatus, activeHead, composableNames, createHead, createServerHead, getActiveHead, resolveScriptKey, unheadComposablesImports, useScript };