@unhead/vue 1.11.15 → 2.0.0-alpha.1

package/dist/legacy.mjs

@@ -0,0 +1,154 @@
+import { defineHeadPlugin, whitelistSafeInput, unpackMeta } from '@unhead/shared';
+import { unheadCtx, tryUseUnhead } from 'unhead';
+export { createHeadCore } from 'unhead';
+import { getCurrentInstance, onMounted, isRef, watch, onScopeDispose, ref, inject, watchEffect, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+export { createHead } from './client.mjs';
+import { h as headSymbol, r as resolveUnrefHeadInput } from './shared/vue.Sg4YunmP.mjs';
+export { createHead as createServerHead } from './server.mjs';
+import { useScript as useScript$1 } from 'unhead/legacy';
+export { resolveScriptKey } from 'unhead/legacy';
+import 'unhead/client';
+import './shared/vue.B6jdKgLD.mjs';
+import './shared/vue.O-w7-AFg.mjs';
+import 'unhead/server';
+
+function registerVueScopeHandlers(script, scope) {
+  if (!scope) {
+    return;
+  }
+  const _registerCb = (key, cb) => {
+    if (!script._cbs[key]) {
+      cb(script.instance);
+      return () => {
+      };
+    }
+    let i = script._cbs[key].push(cb);
+    const destroy = () => {
+      if (i) {
+        script._cbs[key]?.splice(i - 1, 1);
+        i = null;
+      }
+    };
+    onScopeDispose(destroy);
+    return destroy;
+  };
+  script.onLoaded = (cb) => _registerCb("loaded", cb);
+  script.onError = (cb) => _registerCb("error", cb);
+  onScopeDispose(() => {
+    script._triggerAbortController?.abort();
+  });
+}
+function useScript(_input, _options) {
+  const input = typeof _input === "string" ? { src: _input } : _input;
+  const options = _options || {};
+  const head = options?.head || injectHead();
+  options.head = head;
+  const scope = getCurrentInstance();
+  options.eventContext = scope;
+  if (scope && typeof options.trigger === "undefined") {
+    options.trigger = onMounted;
+  } else if (isRef(options.trigger)) {
+    const refTrigger = options.trigger;
+    let off;
+    options.trigger = new Promise((resolve) => {
+      off = watch(refTrigger, (val) => {
+        if (val) {
+          resolve(true);
+        }
+      }, {
+        immediate: true
+      });
+      onScopeDispose(() => resolve(false), true);
+    }).then((val) => {
+      off?.();
+      return val;
+    });
+  }
+  head._scriptStatusWatcher = head._scriptStatusWatcher || head.hooks.hook("script:updated", ({ script: s }) => {
+    s._statusRef.value = s.status;
+  });
+  const script = useScript$1(input, options);
+  script._statusRef = script._statusRef || ref(script.status);
+  registerVueScopeHandlers(script, scope);
+  return new Proxy(script, {
+    get(_, key, a) {
+      return Reflect.get(_, key === "status" ? "_statusRef" : key, a);
+    }
+  });
+}
+
+const CapoPlugin = () => defineHeadPlugin({});
+function setHeadInjectionHandler(handler) {
+  unheadCtx.set(handler(), true);
+}
+function injectHead() {
+  const ctx = tryUseUnhead();
+  if (ctx) {
+    return ctx;
+  }
+  return inject(headSymbol);
+}
+function useHead(input, options = {}) {
+  const head = options.head || injectHead();
+  if (head) {
+    return head.ssr ? head.push(input, options) : clientUseHead(head, input, options);
+  }
+}
+function clientUseHead(head, input, options = {}) {
+  const deactivated = ref(false);
+  const resolvedInput = ref({});
+  watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  const vm = getCurrentInstance();
+  if (vm) {
+    onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    onDeactivated(() => {
+      deactivated.value = true;
+    });
+    onActivated(() => {
+      deactivated.value = false;
+    });
+  }
+  return entry;
+}
+function useHeadSafe(input, options = {}) {
+  return useHead(input, { ...options, transform: whitelistSafeInput });
+}
+function useSeoMeta(input, options) {
+  const { title, titleTemplate, ...meta } = input;
+  return useHead({
+    title,
+    titleTemplate,
+    // @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 { CapoPlugin, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/server.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const server = require('unhead/server');
+const useHead = require('./shared/vue.BwEnMiRq.cjs');
+const VueReactivityPlugin = require('./shared/vue.DIPZN3-d.cjs');
+const VueHeadMixin = require('./shared/vue.3OjaFlxQ.cjs');
+require('vue');
+require('unhead');
+require('@unhead/shared');
+
+function createHead(options = {}) {
+  const head = server.createHead({
+    ...options,
+    plugins: [
+      ...options.plugins || [],
+      VueReactivityPlugin.VueReactivityPlugin
+    ]
+  });
+  head.install = useHead.vueInstall(head);
+  return head;
+}
+
+exports.VueHeadMixin = VueHeadMixin.VueHeadMixin;
+exports.createHead = createHead;
+Object.prototype.hasOwnProperty.call(server, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: server['__proto__']
+  });
+
+Object.keys(server).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = server[k];
+});

package/dist/server.d.cts

@@ -0,0 +1,11 @@
+import { MergeHead, CreateHeadOptions } from '@unhead/schema';
+import { d as distExports } from './shared/vue.DShwsPiO.cjs';
+export { V as VueHeadMixin } from './shared/vue.DnywREVF.cjs';
+export * from 'unhead/server';
+import '@unhead/shared';
+import 'unhead';
+import 'vue';
+
+declare function createHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): distExports.VueHeadClient<T>;
+
+export { createHead };

package/dist/server.d.mts

@@ -0,0 +1,11 @@
+import { MergeHead, CreateHeadOptions } from '@unhead/schema';
+import { d as distExports } from './shared/vue.DShwsPiO.mjs';
+export { V as VueHeadMixin } from './shared/vue.DnywREVF.mjs';
+export * from 'unhead/server';
+import '@unhead/shared';
+import 'unhead';
+import 'vue';
+
+declare function createHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): distExports.VueHeadClient<T>;
+
+export { createHead };

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+import { MergeHead, CreateHeadOptions } from '@unhead/schema';
+import { d as distExports } from './shared/vue.DShwsPiO.js';
+export { V as VueHeadMixin } from './shared/vue.DnywREVF.js';
+export * from 'unhead/server';
+import '@unhead/shared';
+import 'unhead';
+import 'vue';
+
+declare function createHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): distExports.VueHeadClient<T>;
+
+export { createHead };

package/dist/server.mjs

@@ -0,0 +1,22 @@
+import { createHead as createHead$1 } from 'unhead/server';
+export * from 'unhead/server';
+import { v as vueInstall } from './shared/vue.Sg4YunmP.mjs';
+import { V as VueReactivityPlugin } from './shared/vue.B6jdKgLD.mjs';
+export { V as VueHeadMixin } from './shared/vue.O-w7-AFg.mjs';
+import 'vue';
+import 'unhead';
+import '@unhead/shared';
+
+function createHead(options = {}) {
+  const head = createHead$1({
+    ...options,
+    plugins: [
+      ...options.plugins || [],
+      VueReactivityPlugin
+    ]
+  });
+  head.install = vueInstall(head);
+  return head;
+}
+
+export { createHead };

package/dist/shared/vue.3OjaFlxQ.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const vue = require('vue');
+const useHead = require('./vue.BwEnMiRq.cjs');
+
+const VueHeadMixin = {
+  created() {
+    let source = false;
+    const instance = vue.getCurrentInstance();
+    if (!instance)
+      return;
+    const options = instance.type;
+    if (!options || !("head" in options))
+      return;
+    source = typeof options.head === "function" ? () => options.head.call(instance.proxy) : options.head;
+    source && useHead.useHead(source);
+  }
+};
+
+exports.VueHeadMixin = VueHeadMixin;

package/dist/shared/vue.B6jdKgLD.mjs

@@ -0,0 +1,13 @@
+import { defineHeadPlugin } from '@unhead/shared';
+import { r as resolveUnrefHeadInput } from './vue.Sg4YunmP.mjs';
+
+const VueReactivityPlugin = defineHeadPlugin({
+  hooks: {
+    "entries:resolve": (ctx) => {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+export { VueReactivityPlugin as V };

package/dist/shared/{vue.fwis0K4Q.d.cts → vue.B8gXlHM7.d.cts}

@@ -1,9 +1,11 @@
-import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeFunctionEntries, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeEventFnHandlers, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead, SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from '@unhead/schema';
 import { ComputedRef, Ref, Plugin } from 'vue';
 
-type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+declare function resolveUnrefHeadInput(ref: any): any;
+
+type MaybeReadonlyRef<T> = ComputedRef<T>;
 type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
-type MaybeComputedRefOrFalsy<T> = undefined | false | null | T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrFalsy<T> = T | MaybeReadonlyRef<T> | Ref<T>;
 /**
  * @deprecated Use MaybeComputedRefOrFalsy
  */
@@ -39,14 +41,14 @@ interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
 }
 type Title = MaybeComputedRef<Title$1>;
 type TitleTemplate = TitleTemplate$1 | Ref<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
-type Base<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
-type Link<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Link$1<E>>;
-type Meta<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Meta$1<E>>;
-type Style<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Style$1<E>>;
-type Script<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Script$1<E>>;
-type Noscript<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Noscript$1<E>>;
-type HtmlAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
-type BodyAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeFunctionEntries<BodyEvents>>;
+type Base<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
+type Link<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Link$1<E>>;
+type Meta<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Meta$1<E>>;
+type Style<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Style$1<E>>;
+type Script<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Script$1<E>>;
+type Noscript<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Noscript$1<E>>;
+type HtmlAttributes<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
+type BodyAttributes<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeEventFnHandlers<BodyEvents>>;
 interface ReactiveHead<E extends MergeHead = MergeHead> {
     /**
      * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
@@ -122,11 +124,21 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
 type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
     head?: VueHeadClient<any>;
 };
-type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseHeadInput<T extends MergeHead = Record<string, any>> = MaybeComputedRef<ReactiveHead<T>>;
 type UseSeoMetaInput = MaybeComputedRefEntriesOnly<MetaFlatInput> & {
     title?: ReactiveHead['title'];
     titleTemplate?: ReactiveHead['titleTemplate'];
 };
 type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
 
-export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Style as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, UseHeadOptions as b, MaybeComputedRefEntriesOnly as c, UseSeoMetaInput as d, TitleTemplate as e, Base as f, Meta as g, Script as h, HtmlAttributes as i, BodyAttributes as j, MaybeReadonlyRef as k, MaybeComputedRefOrFalsy as l, MaybeComputedRefOrPromise as m };
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: MaybeComputedRefEntries<SafeMeta>[];
+    link?: MaybeComputedRefEntries<SafeLink>[];
+    noscript?: MaybeComputedRefEntries<SafeNoscript>[];
+    script?: MaybeComputedRefEntries<SafeScript>[];
+    htmlAttrs?: MaybeComputedRefEntries<SafeHtmlAttr>;
+    bodyAttrs?: MaybeComputedRefEntries<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+export { type BodyAttr as B, type HeadSafe as H, type Link as L, type Meta as M, type Noscript as N, type ReactiveHead as R, type Style as S, type Title as T, type UseHeadInput as U, type VueHeadClient as V, type UseHeadOptions as a, type UseHeadSafeInput as b, type UseSeoMetaInput as c, type HtmlAttr as d, type TitleTemplate as e, type Base as f, type Script as g, type HtmlAttributes as h, type BodyAttributes as i, type MaybeReadonlyRef as j, type MaybeComputedRef as k, type MaybeComputedRefOrFalsy as l, type MaybeComputedRefOrPromise as m, type MaybeComputedRefEntries as n, type MaybeComputedRefEntriesOnly as o, resolveUnrefHeadInput as r };

package/dist/shared/{vue.fwis0K4Q.d.mts → vue.B8gXlHM7.d.mts}

@@ -1,9 +1,11 @@
-import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeFunctionEntries, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeEventFnHandlers, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead, SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from '@unhead/schema';
 import { ComputedRef, Ref, Plugin } from 'vue';
 
-type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+declare function resolveUnrefHeadInput(ref: any): any;
+
+type MaybeReadonlyRef<T> = ComputedRef<T>;
 type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
-type MaybeComputedRefOrFalsy<T> = undefined | false | null | T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrFalsy<T> = T | MaybeReadonlyRef<T> | Ref<T>;
 /**
  * @deprecated Use MaybeComputedRefOrFalsy
  */
@@ -39,14 +41,14 @@ interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
 }
 type Title = MaybeComputedRef<Title$1>;
 type TitleTemplate = TitleTemplate$1 | Ref<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
-type Base<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
-type Link<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Link$1<E>>;
-type Meta<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Meta$1<E>>;
-type Style<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Style$1<E>>;
-type Script<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Script$1<E>>;
-type Noscript<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Noscript$1<E>>;
-type HtmlAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
-type BodyAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeFunctionEntries<BodyEvents>>;
+type Base<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
+type Link<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Link$1<E>>;
+type Meta<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Meta$1<E>>;
+type Style<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Style$1<E>>;
+type Script<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Script$1<E>>;
+type Noscript<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Noscript$1<E>>;
+type HtmlAttributes<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
+type BodyAttributes<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeEventFnHandlers<BodyEvents>>;
 interface ReactiveHead<E extends MergeHead = MergeHead> {
     /**
      * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
@@ -122,11 +124,21 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
 type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
     head?: VueHeadClient<any>;
 };
-type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseHeadInput<T extends MergeHead = Record<string, any>> = MaybeComputedRef<ReactiveHead<T>>;
 type UseSeoMetaInput = MaybeComputedRefEntriesOnly<MetaFlatInput> & {
     title?: ReactiveHead['title'];
     titleTemplate?: ReactiveHead['titleTemplate'];
 };
 type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
 
-export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Style as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, UseHeadOptions as b, MaybeComputedRefEntriesOnly as c, UseSeoMetaInput as d, TitleTemplate as e, Base as f, Meta as g, Script as h, HtmlAttributes as i, BodyAttributes as j, MaybeReadonlyRef as k, MaybeComputedRefOrFalsy as l, MaybeComputedRefOrPromise as m };
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: MaybeComputedRefEntries<SafeMeta>[];
+    link?: MaybeComputedRefEntries<SafeLink>[];
+    noscript?: MaybeComputedRefEntries<SafeNoscript>[];
+    script?: MaybeComputedRefEntries<SafeScript>[];
+    htmlAttrs?: MaybeComputedRefEntries<SafeHtmlAttr>;
+    bodyAttrs?: MaybeComputedRefEntries<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+export { type BodyAttr as B, type HeadSafe as H, type Link as L, type Meta as M, type Noscript as N, type ReactiveHead as R, type Style as S, type Title as T, type UseHeadInput as U, type VueHeadClient as V, type UseHeadOptions as a, type UseHeadSafeInput as b, type UseSeoMetaInput as c, type HtmlAttr as d, type TitleTemplate as e, type Base as f, type Script as g, type HtmlAttributes as h, type BodyAttributes as i, type MaybeReadonlyRef as j, type MaybeComputedRef as k, type MaybeComputedRefOrFalsy as l, type MaybeComputedRefOrPromise as m, type MaybeComputedRefEntries as n, type MaybeComputedRefEntriesOnly as o, resolveUnrefHeadInput as r };

package/dist/shared/{vue.fwis0K4Q.d.ts → vue.B8gXlHM7.d.ts}

@@ -1,9 +1,11 @@
-import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeFunctionEntries, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { BaseHtmlAttr, MaybeArray, BaseBodyAttr, Title as Title$1, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, Link as Link$1, Meta as Meta$1, Style as Style$1, Script as Script$1, Noscript as Noscript$1, DataKeys, SchemaAugmentations, DefinedValueOrEmptyObject, MaybeEventFnHandlers, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead, SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from '@unhead/schema';
 import { ComputedRef, Ref, Plugin } from 'vue';
 
-type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+declare function resolveUnrefHeadInput(ref: any): any;
+
+type MaybeReadonlyRef<T> = ComputedRef<T>;
 type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
-type MaybeComputedRefOrFalsy<T> = undefined | false | null | T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrFalsy<T> = T | MaybeReadonlyRef<T> | Ref<T>;
 /**
  * @deprecated Use MaybeComputedRefOrFalsy
  */
@@ -39,14 +41,14 @@ interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
 }
 type Title = MaybeComputedRef<Title$1>;
 type TitleTemplate = TitleTemplate$1 | Ref<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
-type Base<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
-type Link<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Link$1<E>>;
-type Meta<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Meta$1<E>>;
-type Style<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Style$1<E>>;
-type Script<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Script$1<E>>;
-type Noscript<E extends EntryAugmentation = {}> = MaybeComputedRefEntries<Noscript$1<E>>;
-type HtmlAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
-type BodyAttributes<E extends EntryAugmentation = {}> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeFunctionEntries<BodyEvents>>;
+type Base<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<Base$1<E>>>;
+type Link<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Link$1<E>>;
+type Meta<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Meta$1<E>>;
+type Style<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Style$1<E>>;
+type Script<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Script$1<E>>;
+type Noscript<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRefEntries<Noscript$1<E>>;
+type HtmlAttributes<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs'] & DefinedValueOrEmptyObject<E>>>;
+type BodyAttributes<E extends EntryAugmentation = Record<string, any>> = MaybeComputedRef<MaybeComputedRefEntries<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs'] & DefinedValueOrEmptyObject<E>> & MaybeEventFnHandlers<BodyEvents>>;
 interface ReactiveHead<E extends MergeHead = MergeHead> {
     /**
      * The `<title>` HTML element defines the document's title that is shown in a browser's title bar or a page's tab.
@@ -122,11 +124,21 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
 type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
     head?: VueHeadClient<any>;
 };
-type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseHeadInput<T extends MergeHead = Record<string, any>> = MaybeComputedRef<ReactiveHead<T>>;
 type UseSeoMetaInput = MaybeComputedRefEntriesOnly<MetaFlatInput> & {
     title?: ReactiveHead['title'];
     titleTemplate?: ReactiveHead['titleTemplate'];
 };
 type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
 
-export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Style as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, UseHeadOptions as b, MaybeComputedRefEntriesOnly as c, UseSeoMetaInput as d, TitleTemplate as e, Base as f, Meta as g, Script as h, HtmlAttributes as i, BodyAttributes as j, MaybeReadonlyRef as k, MaybeComputedRefOrFalsy as l, MaybeComputedRefOrPromise as m };
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: MaybeComputedRefEntries<SafeMeta>[];
+    link?: MaybeComputedRefEntries<SafeLink>[];
+    noscript?: MaybeComputedRefEntries<SafeNoscript>[];
+    script?: MaybeComputedRefEntries<SafeScript>[];
+    htmlAttrs?: MaybeComputedRefEntries<SafeHtmlAttr>;
+    bodyAttrs?: MaybeComputedRefEntries<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+export { type BodyAttr as B, type HeadSafe as H, type Link as L, type Meta as M, type Noscript as N, type ReactiveHead as R, type Style as S, type Title as T, type UseHeadInput as U, type VueHeadClient as V, type UseHeadOptions as a, type UseHeadSafeInput as b, type UseSeoMetaInput as c, type HtmlAttr as d, type TitleTemplate as e, type Base as f, type Script as g, type HtmlAttributes as h, type BodyAttributes as i, type MaybeReadonlyRef as j, type MaybeComputedRef as k, type MaybeComputedRefOrFalsy as l, type MaybeComputedRefOrPromise as m, type MaybeComputedRefEntries as n, type MaybeComputedRefEntriesOnly as o, resolveUnrefHeadInput as r };

package/dist/shared/vue.BwEnMiRq.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+const vue = require('vue');
+const unhead = require('unhead');
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : vue.unref(r);
+}
+function resolveUnrefHeadInput(ref) {
+  if (ref instanceof Promise || ref instanceof Date || ref instanceof RegExp)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r));
+  if (typeof root === "object") {
+    const resolved = {};
+    for (const k in root) {
+      if (!Object.prototype.hasOwnProperty.call(root, k)) {
+        continue;
+      }
+      if (k === "titleTemplate" || k[0] === "o" && k[1] === "n") {
+        resolved[k] = vue.unref(root[k]);
+        continue;
+      }
+      resolved[k] = resolveUnrefHeadInput(root[k]);
+    }
+    return resolved;
+  }
+  return root;
+}
+
+const headSymbol = "usehead";
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      app.config.globalProperties.$unhead = head;
+      app.config.globalProperties.$head = head;
+      app.provide(headSymbol, head);
+    }
+  };
+  return plugin.install;
+}
+
+function injectHead() {
+  const ctx = unhead.tryUseUnhead();
+  if (ctx) {
+    return ctx;
+  }
+  const instance = vue.inject(headSymbol);
+  if (!instance) {
+    throw new Error("useHead() was called without provide context, ensure you call it through the setup() function.");
+  }
+  return instance;
+}
+
+function useHead(input, options = {}) {
+  const head = options.head || injectHead();
+  return head.ssr ? head.push(input, options) : clientUseHead(head, input, options);
+}
+function clientUseHead(head, input, options = {}) {
+  const deactivated = vue.ref(false);
+  const resolvedInput = vue.ref({});
+  vue.watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  vue.watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  const vm = vue.getCurrentInstance();
+  if (vm) {
+    vue.onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    vue.onDeactivated(() => {
+      deactivated.value = true;
+    });
+    vue.onActivated(() => {
+      deactivated.value = false;
+    });
+  }
+  return entry;
+}
+
+exports.headSymbol = headSymbol;
+exports.injectHead = injectHead;
+exports.resolveUnrefHeadInput = resolveUnrefHeadInput;
+exports.useHead = useHead;
+exports.vueInstall = vueInstall;

package/dist/shared/vue.DIPZN3-d.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const shared = require('@unhead/shared');
+const useHead = require('./vue.BwEnMiRq.cjs');
+
+const VueReactivityPlugin = shared.defineHeadPlugin({
+  hooks: {
+    "entries:resolve": (ctx) => {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = useHead.resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+exports.VueReactivityPlugin = VueReactivityPlugin;