@unhead/vue 1.2.2 → 1.3.0-beta.0

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const unhead = require('unhead');
-const useHead = require('./shared/vue.a57702be.cjs');
+const useHead = require('./shared/vue.4471084f.cjs');
 const vue = require('vue');
 const shared = require('@unhead/shared');
 
@@ -38,8 +38,15 @@ const Vue2ProvideUnheadPlugin = function(_Vue, head) {
   });
 };
 
+const coreComposableNames = [
+  "injectHead"
+];
+const unheadVueComposablesImports = {
+  "@unhead/vue": [...coreComposableNames, ...shared.composableNames]
+};
+
 function useHeadSafe(input, options = {}) {
-  return useHead.useHead(input, { ...options, transform: unhead.whitelistSafeInput });
+  return useHead.useHead(input, { ...options, transform: shared.whitelistSafeInput });
 }
 
 function useSeoMeta(input, options) {
@@ -50,14 +57,15 @@ function useSeoMeta(input, options) {
     headInput.value = {
       title,
       titleTemplate,
-      meta: unhead.unpackMeta(meta)
+      meta: shared.unpackMeta(meta)
     };
   });
   return useHead.useHead(headInput, options);
 }
 
 function useServerHead(input, options = {}) {
-  return useHead.serverUseHead(input, { ...options, mode: "server" });
+  const head = useHead.injectHead();
+  return head.push(input, options);
 }
 
 function useServerHeadSafe(input, options = {}) {
@@ -68,124 +76,18 @@ function useServerSeoMeta(input, options) {
   return useSeoMeta(input, { ...options || {}, mode: "server" });
 }
 
-function useTagTitle(title) {
-  return useHead.useHead({ title });
-}
-function useTitleTemplate(titleTemplate) {
-  return useHead.useHead({ titleTemplate });
-}
-function useTagMeta(meta) {
-  return useHead.useHead({ meta: shared.asArray(meta) });
-}
-function useTagMetaFlat(meta) {
-  const input = vue.ref({});
-  vue.watchEffect(() => {
-    input.value = unhead.unpackMeta(useHead.resolveUnrefHeadInput(meta));
-  });
-  return useHead.useHead({ meta: input });
-}
-function useTagLink(link) {
-  return useHead.useHead({ link: shared.asArray(link) });
-}
-function useTagScript(script) {
-  return useHead.useHead({ script: shared.asArray(script) });
-}
-function useTagStyle(style) {
-  return useHead.useHead({ style: shared.asArray(style) });
-}
-function useTagNoscript(noscript) {
-  return useHead.useHead({ noscript: shared.asArray(noscript) });
-}
-function useTagBase(base) {
-  return useHead.useHead({ base });
-}
-function useHtmlAttrs(attrs) {
-  return useHead.useHead({ htmlAttrs: attrs });
-}
-function useBodyAttrs(attrs) {
-  return useHead.useHead({ bodyAttrs: attrs });
-}
-function useServerTagTitle(title) {
-  return useServerHead({ title });
-}
-function useServerTitleTemplate(titleTemplate) {
-  return useServerHead({ titleTemplate });
-}
-function useServerTagMeta(meta) {
-  return useServerHead({ meta: shared.asArray(meta) });
-}
-function useServerTagMetaFlat(meta) {
-  const input = vue.ref({});
-  vue.watchEffect(() => {
-    input.value = unhead.unpackMeta(useHead.resolveUnrefHeadInput(meta));
-  });
-  return useServerHead({ meta: input });
-}
-function useServerTagLink(link) {
-  return useServerHead({ link: shared.asArray(link) });
-}
-function useServerTagScript(script) {
-  return useServerHead({ script: shared.asArray(script) });
-}
-function useServerTagStyle(style) {
-  return useServerHead({ style: shared.asArray(style) });
-}
-function useServerTagNoscript(noscript) {
-  return useServerHead({ noscript: shared.asArray(noscript) });
-}
-function useServerTagBase(base) {
-  return useServerHead({ base });
-}
-function useServerHtmlAttrs(attrs) {
-  return useServerHead({ htmlAttrs: attrs });
-}
-function useServerBodyAttrs(attrs) {
-  return useHead.useHead({ bodyAttrs: attrs });
-}
-
-const coreComposableNames = [
-  "injectHead"
-];
-const unheadVueComposablesImports = {
-  "@unhead/vue": [...coreComposableNames, ...unhead.composableNames]
-};
-
 exports.CapoPlugin = unhead.CapoPlugin;
+exports.HashHydrationPlugin = unhead.HashHydrationPlugin;
 exports.createHeadCore = unhead.createHeadCore;
-exports.VueReactiveUseHeadPlugin = useHead.VueReactiveUseHeadPlugin;
 exports.createHead = useHead.createHead;
 exports.createServerHead = useHead.createServerHead;
-exports.headSymbol = useHead.headSymbol;
 exports.injectHead = useHead.injectHead;
-exports.resolveUnrefHeadInput = useHead.resolveUnrefHeadInput;
 exports.useHead = useHead.useHead;
 exports.Vue2ProvideUnheadPlugin = Vue2ProvideUnheadPlugin;
 exports.VueHeadMixin = VueHeadMixin;
 exports.unheadVueComposablesImports = unheadVueComposablesImports;
-exports.useBodyAttrs = useBodyAttrs;
 exports.useHeadSafe = useHeadSafe;
-exports.useHtmlAttrs = useHtmlAttrs;
 exports.useSeoMeta = useSeoMeta;
-exports.useServerBodyAttrs = useServerBodyAttrs;
 exports.useServerHead = useServerHead;
 exports.useServerHeadSafe = useServerHeadSafe;
-exports.useServerHtmlAttrs = useServerHtmlAttrs;
 exports.useServerSeoMeta = useServerSeoMeta;
-exports.useServerTagBase = useServerTagBase;
-exports.useServerTagLink = useServerTagLink;
-exports.useServerTagMeta = useServerTagMeta;
-exports.useServerTagMetaFlat = useServerTagMetaFlat;
-exports.useServerTagNoscript = useServerTagNoscript;
-exports.useServerTagScript = useServerTagScript;
-exports.useServerTagStyle = useServerTagStyle;
-exports.useServerTagTitle = useServerTagTitle;
-exports.useServerTitleTemplate = useServerTitleTemplate;
-exports.useTagBase = useTagBase;
-exports.useTagLink = useTagLink;
-exports.useTagMeta = useTagMeta;
-exports.useTagMetaFlat = useTagMetaFlat;
-exports.useTagNoscript = useTagNoscript;
-exports.useTagScript = useTagScript;
-exports.useTagStyle = useTagStyle;
-exports.useTagTitle = useTagTitle;
-exports.useTitleTemplate = useTitleTemplate;

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-export { CapoPlugin, createHeadCore } from 'unhead';
-import { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, U as UseHeadInput, A as Arrayable, b as Meta, L as Link, S as Script, c as Style, N as Noscript } from './createHead-197548ae.js';
-export { e as Base, B as BodyAttr, g as BodyAttributes, H as HtmlAttr, f as HtmlAttributes, i as MaybeComputedRefOrPromise, h as MaybeReadonlyRef, T as Title, d as TitleTemplate, V as VueHeadClient, m as createHead, l as createServerHead, j as headSymbol, k as injectHead } from './createHead-197548ae.js';
+import require$$1 from 'unhead';
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
 import * as _unhead_schema from '@unhead/schema';
-import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, HeadEntryOptions, ActiveHeadEntry, MetaFlatInput } from '@unhead/schema';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, CreateHeadOptions, HeadEntryOptions, ActiveHeadEntry, MetaFlatInput } from '@unhead/schema';
 export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, Unhead } from '@unhead/schema';
-import { Plugin } from 'vue';
+import { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, V as VueHeadClient, U as UseHeadInput } from './schema-f7f2c0b4.js';
+export { c as Base, B as BodyAttr, g as BodyAttributes, H as HtmlAttr, f as HtmlAttributes, L as Link, i as MaybeComputedRefOrPromise, h as MaybeReadonlyRef, d as Meta, N as Noscript, e as Script, S as Style, T as Title, b as TitleTemplate } from './schema-f7f2c0b4.js';
+import require$$0, { Plugin } from 'vue';
+import require$$2 from '@unhead/shared';
 
 interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
     meta?: MaybeComputedRefEntries<SafeMeta>[];
@@ -16,17 +18,225 @@ interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templ
 }
 type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
 
-declare function resolveUnrefHeadInput(ref: any, lastKey?: string | number): any;
+declare function createServerHead$1<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead$1<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
 
-declare const VueHeadMixin: {
+declare const VueHeadMixin$1: {
     created(): void;
 };
 
-declare function VueReactiveUseHeadPlugin(): _unhead_schema.HeadPlugin;
+declare const Vue2ProvideUnheadPlugin$1: Plugin;
 
-declare const Vue2ProvideUnheadPlugin: Plugin;
+declare const unheadVueComposablesImports$1: {
+    '@unhead/vue': string[];
+};
+
+declare function injectHead$1<T extends MergeHead>(): VueHeadClient<T>;
+
+var dist = {};
+
+var vue_4471084f = {};
+
+const vue$1 = require$$0;
+const unhead$1 = require$$1;
+const shared$1 = require$$2;
+
+const Vue3 = vue$1.version.startsWith("3");
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : vue$1.unref(r);
+}
+function resolveUnrefHeadInput(ref, lastKey = "") {
+  if (ref instanceof Promise)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r, lastKey));
+  if (typeof root === "object") {
+    return Object.fromEntries(
+      Object.entries(root).map(([k, v]) => {
+        if (k === "titleTemplate" || k.startsWith("on"))
+          return [k, vue$1.unref(v)];
+        return [k, resolveUnrefHeadInput(v, k)];
+      })
+    );
+  }
+  return root;
+}
+
+const VueReactivityPlugin = shared$1.defineHeadPlugin({
+  hooks: {
+    "entries:resolve": function(ctx) {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+const headSymbol = "usehead";
+function vueInstall(head) {
+  const plugin = {
+    install(app) {
+      if (Vue3) {
+        app.config.globalProperties.$unhead = head;
+        app.config.globalProperties.$head = head;
+        app.provide(headSymbol, head);
+      }
+    }
+  };
+  return plugin.install;
+}
+function createServerHead(options = {}) {
+  const head = unhead$1.createServerHead(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+function createHead(options = {}) {
+  options.domDelayFn = options.domDelayFn || ((fn) => vue$1.nextTick(() => fn()));
+  const head = unhead$1.createHead(options);
+  head.use(VueReactivityPlugin);
+  head.install = vueInstall(head);
+  return head;
+}
+
+function injectHead() {
+  return vue$1.getCurrentInstance() && vue$1.inject(headSymbol) || unhead$1.getActiveHead();
+}
+
+function useHead$2(input, options = {}) {
+  const head = injectHead();
+  if (!head.ssr)
+    return clientUseHead(head, input, options);
+  return head.push(input, options);
+}
+function clientUseHead(head, input, options = {}) {
+  const deactivated = vue$1.ref(false);
+  const resolvedInput = vue$1.ref({});
+  vue$1.watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : resolveUnrefHeadInput(input);
+  });
+  const entry = head.push(resolvedInput.value, options);
+  vue$1.watch(resolvedInput, (e) => {
+    entry.patch(e);
+  });
+  const vm = vue$1.getCurrentInstance();
+  if (vm) {
+    vue$1.onBeforeUnmount(() => {
+      entry.dispose();
+    });
+    vue$1.onDeactivated(() => {
+      deactivated.value = true;
+    });
+    vue$1.onActivated(() => {
+      deactivated.value = false;
+    });
+  }
+  return entry;
+}
+
+vue_4471084f.createHead = createHead;
+vue_4471084f.createServerHead = createServerHead;
+vue_4471084f.headSymbol = headSymbol;
+vue_4471084f.injectHead = injectHead;
+vue_4471084f.resolveUnrefHeadInput = resolveUnrefHeadInput;
+vue_4471084f.useHead = useHead$2;
 
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+const unhead = require$$1;
+const useHead$1 = vue_4471084f;
+const vue = require$$0;
+const shared = require$$2;
+
+const VueHeadMixin = {
+  created() {
+    const instance = vue.getCurrentInstance();
+    if (!instance)
+      return;
+    const options = instance.type;
+    if (!options || !("head" in options))
+      return;
+    const source = typeof options.head === "function" ? () => options.head.call(instance.proxy) : options.head;
+    useHead$1.useHead(source);
+  }
+};
+
+const Vue2ProvideUnheadPlugin = function(_Vue, head) {
+  _Vue.mixin({
+    beforeCreate() {
+      const options = this.$options;
+      const origProvide = options.provide;
+      options.provide = function() {
+        let origProvideResult;
+        if (typeof origProvide === "function")
+          origProvideResult = origProvide.call(this);
+        else
+          origProvideResult = origProvide || {};
+        return {
+          ...origProvideResult,
+          [useHead$1.headSymbol]: head
+        };
+      };
+    }
+  });
+};
+
+const coreComposableNames = [
+  "injectHead"
+];
+const unheadVueComposablesImports = {
+  "@unhead/vue": [...coreComposableNames, ...shared.composableNames]
+};
+
+function useHeadSafe$1(input, options = {}) {
+  return useHead$1.useHead(input, { ...options, transform: shared.whitelistSafeInput });
+}
+
+function useSeoMeta$1(input, options) {
+  const headInput = vue.ref({});
+  vue.watchEffect(() => {
+    const resolvedMeta = useHead$1.resolveUnrefHeadInput(input);
+    const { title, titleTemplate, ...meta } = resolvedMeta;
+    headInput.value = {
+      title,
+      titleTemplate,
+      meta: shared.unpackMeta(meta)
+    };
+  });
+  return useHead$1.useHead(headInput, options);
+}
+
+function useServerHead$1(input, options = {}) {
+  const head = useHead$1.injectHead();
+  return head.push(input, options);
+}
+
+function useServerHeadSafe$1(input, options = {}) {
+  return useHeadSafe$1(input, { ...options, mode: "server" });
+}
+
+function useServerSeoMeta$1(input, options) {
+  return useSeoMeta$1(input, { ...options || {}, mode: "server" });
+}
+
+dist.CapoPlugin = unhead.CapoPlugin;
+dist.HashHydrationPlugin = unhead.HashHydrationPlugin;
+dist.createHeadCore = unhead.createHeadCore;
+dist.createHead = useHead$1.createHead;
+dist.createServerHead = useHead$1.createServerHead;
+dist.injectHead = useHead$1.injectHead;
+dist.useHead = useHead$1.useHead;
+dist.Vue2ProvideUnheadPlugin = Vue2ProvideUnheadPlugin;
+dist.VueHeadMixin = VueHeadMixin;
+dist.unheadVueComposablesImports = unheadVueComposablesImports;
+dist.useHeadSafe = useHeadSafe$1;
+dist.useSeoMeta = useSeoMeta$1;
+dist.useServerHead = useServerHead$1;
+dist.useServerHeadSafe = useServerHeadSafe$1;
+dist.useServerSeoMeta = useServerSeoMeta$1;
+
+declare function useHead<T extends MergeHead>(input: dist.UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<dist.UseHeadInput<T>> | void;
 
 declare function useHeadSafe(input: UseHeadSafeInput, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
 
@@ -36,103 +246,10 @@ type UseSeoMetaInput = MaybeComputedRefEntries<MetaFlatInput> & {
 };
 declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): _unhead_schema.ActiveHeadEntry<UseHeadInput<T>>;
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): _unhead_schema.ActiveHeadEntry<MaybeComputedRef<ReactiveHead<MergeHead>>>;
 
 declare function useServerHeadSafe(input: UseHeadSafeInput, options?: HeadEntryOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
 
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
-
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagTitle(title: ReactiveHead['title']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTitleTemplate(titleTemplate: ReactiveHead['titleTemplate']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagMeta(meta: Arrayable<Meta>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagMetaFlat(meta: MaybeComputedRefEntries<MetaFlatInput>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagLink(link: Arrayable<Link>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagScript(script: Arrayable<Script>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagStyle(style: Arrayable<Style>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagNoscript(noscript: Arrayable<Noscript>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useTagBase(base: ReactiveHead['base']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useHtmlAttrs(attrs: ReactiveHead['htmlAttrs']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useBodyAttrs(attrs: ReactiveHead['bodyAttrs']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagTitle(title: ReactiveHead['title']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTitleTemplate(titleTemplate: ReactiveHead['titleTemplate']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagMeta(meta: Arrayable<Meta>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagMetaFlat(meta: MaybeComputedRefEntries<MetaFlatInput>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagLink(link: Arrayable<Link>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagScript(script: Arrayable<Script>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagStyle(style: Arrayable<Style>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagNoscript(noscript: Arrayable<Noscript>): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerTagBase(base: ReactiveHead['base']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerHtmlAttrs(attrs: ReactiveHead['htmlAttrs']): ActiveHeadEntry<any> | void;
-/**
- * @deprecated Use `useHead`
- */
-declare function useServerBodyAttrs(attrs: ReactiveHead['bodyAttrs']): ActiveHeadEntry<any> | void;
-
-declare const unheadVueComposablesImports: {
-    '@unhead/vue': string[];
-};
+declare function useServerSeoMeta(input: dist.UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-export { Arrayable, HeadSafe, Link, MaybeComputedRef, MaybeComputedRefEntries, Meta, Noscript, ReactiveHead, Script, Style, UseHeadInput, UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadMixin, VueReactiveUseHeadPlugin, resolveUnrefHeadInput, unheadVueComposablesImports, useBodyAttrs, useHead, useHeadSafe, useHtmlAttrs, useSeoMeta, useServerBodyAttrs, useServerHead, useServerHeadSafe, useServerHtmlAttrs, useServerSeoMeta, useServerTagBase, useServerTagLink, useServerTagMeta, useServerTagMetaFlat, useServerTagNoscript, useServerTagScript, useServerTagStyle, useServerTagTitle, useServerTitleTemplate, useTagBase, useTagLink, useTagMeta, useTagMetaFlat, useTagNoscript, useTagScript, useTagStyle, useTagTitle, useTitleTemplate };
+export { HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, ReactiveHead, UseHeadInput, UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin$1 as Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin$1 as VueHeadMixin, createHead$1 as createHead, createServerHead$1 as createServerHead, injectHead$1 as injectHead, unheadVueComposablesImports$1 as unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.mjs

@@ -1,9 +1,8 @@
-import { whitelistSafeInput, unpackMeta, composableNames } from 'unhead';
-export { CapoPlugin, createHeadCore } from 'unhead';
-import { u as useHead, h as headSymbol, r as resolveUnrefHeadInput, s as serverUseHead } from './shared/vue.505b826e.mjs';
-export { V as VueReactiveUseHeadPlugin, a as createHead, c as createServerHead, i as injectHead } from './shared/vue.505b826e.mjs';
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import { u as useHead, h as headSymbol, r as resolveUnrefHeadInput, i as injectHead } from './shared/vue.9fbebdf0.mjs';
+export { c as createHead, a as createServerHead } from './shared/vue.9fbebdf0.mjs';
 import { getCurrentInstance, ref, watchEffect } from 'vue';
-import { asArray } from '@unhead/shared';
+import { composableNames, whitelistSafeInput, unpackMeta } from '@unhead/shared';
 
 const VueHeadMixin = {
   created() {
@@ -38,6 +37,13 @@ const Vue2ProvideUnheadPlugin = function(_Vue, head) {
   });
 };
 
+const coreComposableNames = [
+  "injectHead"
+];
+const unheadVueComposablesImports = {
+  "@unhead/vue": [...coreComposableNames, ...composableNames]
+};
+
 function useHeadSafe(input, options = {}) {
   return useHead(input, { ...options, transform: whitelistSafeInput });
 }
@@ -57,7 +63,8 @@ function useSeoMeta(input, options) {
 }
 
 function useServerHead(input, options = {}) {
-  return serverUseHead(input, { ...options, mode: "server" });
+  const head = injectHead();
+  return head.push(input, options);
 }
 
 function useServerHeadSafe(input, options = {}) {
@@ -68,86 +75,4 @@ function useServerSeoMeta(input, options) {
   return useSeoMeta(input, { ...options || {}, mode: "server" });
 }
 
-function useTagTitle(title) {
-  return useHead({ title });
-}
-function useTitleTemplate(titleTemplate) {
-  return useHead({ titleTemplate });
-}
-function useTagMeta(meta) {
-  return useHead({ meta: asArray(meta) });
-}
-function useTagMetaFlat(meta) {
-  const input = ref({});
-  watchEffect(() => {
-    input.value = unpackMeta(resolveUnrefHeadInput(meta));
-  });
-  return useHead({ meta: input });
-}
-function useTagLink(link) {
-  return useHead({ link: asArray(link) });
-}
-function useTagScript(script) {
-  return useHead({ script: asArray(script) });
-}
-function useTagStyle(style) {
-  return useHead({ style: asArray(style) });
-}
-function useTagNoscript(noscript) {
-  return useHead({ noscript: asArray(noscript) });
-}
-function useTagBase(base) {
-  return useHead({ base });
-}
-function useHtmlAttrs(attrs) {
-  return useHead({ htmlAttrs: attrs });
-}
-function useBodyAttrs(attrs) {
-  return useHead({ bodyAttrs: attrs });
-}
-function useServerTagTitle(title) {
-  return useServerHead({ title });
-}
-function useServerTitleTemplate(titleTemplate) {
-  return useServerHead({ titleTemplate });
-}
-function useServerTagMeta(meta) {
-  return useServerHead({ meta: asArray(meta) });
-}
-function useServerTagMetaFlat(meta) {
-  const input = ref({});
-  watchEffect(() => {
-    input.value = unpackMeta(resolveUnrefHeadInput(meta));
-  });
-  return useServerHead({ meta: input });
-}
-function useServerTagLink(link) {
-  return useServerHead({ link: asArray(link) });
-}
-function useServerTagScript(script) {
-  return useServerHead({ script: asArray(script) });
-}
-function useServerTagStyle(style) {
-  return useServerHead({ style: asArray(style) });
-}
-function useServerTagNoscript(noscript) {
-  return useServerHead({ noscript: asArray(noscript) });
-}
-function useServerTagBase(base) {
-  return useServerHead({ base });
-}
-function useServerHtmlAttrs(attrs) {
-  return useServerHead({ htmlAttrs: attrs });
-}
-function useServerBodyAttrs(attrs) {
-  return useHead({ bodyAttrs: attrs });
-}
-
-const coreComposableNames = [
-  "injectHead"
-];
-const unheadVueComposablesImports = {
-  "@unhead/vue": [...coreComposableNames, ...composableNames]
-};
-
-export { Vue2ProvideUnheadPlugin, VueHeadMixin, headSymbol, resolveUnrefHeadInput, unheadVueComposablesImports, useBodyAttrs, useHead, useHeadSafe, useHtmlAttrs, useSeoMeta, useServerBodyAttrs, useServerHead, useServerHeadSafe, useServerHtmlAttrs, useServerSeoMeta, useServerTagBase, useServerTagLink, useServerTagMeta, useServerTagMetaFlat, useServerTagNoscript, useServerTagScript, useServerTagStyle, useServerTagTitle, useServerTitleTemplate, useTagBase, useTagLink, useTagMeta, useTagMetaFlat, useTagNoscript, useTagScript, useTagStyle, useTagTitle, useTitleTemplate };
+export { Vue2ProvideUnheadPlugin, VueHeadMixin, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/polyfill.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const useHead = require('./shared/vue.a57702be.cjs');
+const useHead = require('./shared/vue.4471084f.cjs');
 require('vue');
 require('unhead');
 require('@unhead/shared');

package/dist/polyfill.d.ts

@@ -1,5 +1,5 @@
 import { MergeHead, HeadEntryOptions } from '@unhead/schema';
-import { V as VueHeadClient, U as UseHeadInput } from './createHead-197548ae.js';
+import { V as VueHeadClient, U as UseHeadInput } from './schema-f7f2c0b4.js';
 import 'vue';
 
 type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {

package/dist/polyfill.mjs

@@ -1,4 +1,4 @@
-import { u as useHead } from './shared/vue.505b826e.mjs';
+import { u as useHead } from './shared/vue.9fbebdf0.mjs';
 import 'vue';
 import 'unhead';
 import '@unhead/shared';

package/dist/{createHead-197548ae.d.ts → schema-f7f2c0b4.d.ts}

@@ -1,5 +1,5 @@
+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, Unhead } from '@unhead/schema';
 import { ComputedRef, Ref, Plugin } from 'vue';
-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, Unhead, CreateHeadOptions } from '@unhead/schema';
 
 type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
 type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
@@ -7,7 +7,6 @@ type MaybeComputedRefOrPromise<T> = T | MaybeReadonlyRef<T> | Ref<T> | Promise<T
 type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
     [key in keyof T]?: MaybeComputedRefOrPromise<T[key]>;
 };
-type Arrayable<T> = T | Array<T>;
 
 interface HtmlAttr extends Omit<BaseHtmlAttr, 'class'> {
     /**
@@ -106,11 +105,6 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
     bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
 }
 type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
-
 type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
-declare const headSymbol = "usehead";
-declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
-declare function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
-declare function createHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn'>): VueHeadClient<T>;
 
-export { Arrayable as A, BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRefEntries as M, Noscript as N, ReactiveHead as R, Script as S, Title as T, UseHeadInput as U, VueHeadClient as V, MaybeComputedRef as a, Meta as b, Style as c, TitleTemplate as d, Base as e, HtmlAttributes as f, BodyAttributes as g, MaybeReadonlyRef as h, MaybeComputedRefOrPromise as i, headSymbol as j, injectHead as k, createServerHead as l, createHead as m };
+export { 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, TitleTemplate as b, Base as c, Meta as d, Script as e, HtmlAttributes as f, BodyAttributes as g, MaybeReadonlyRef as h, MaybeComputedRefOrPromise as i };

package/dist/shared/{vue.a57702be.cjs → vue.4471084f.cjs}

@@ -4,6 +4,8 @@ const vue = require('vue');
 const unhead = require('unhead');
 const shared = require('@unhead/shared');
 
+const Vue3 = vue.version.startsWith("3");
+
 function resolveUnref(r) {
   return typeof r === "function" ? r() : vue.unref(r);
 }
@@ -27,13 +29,16 @@ function resolveUnrefHeadInput(ref, lastKey = "") {
   return root;
 }
 
-const Vue3 = vue.version.startsWith("3");
-const IsBrowser = typeof window !== "undefined";
+const VueReactivityPlugin = shared.defineHeadPlugin({
+  hooks: {
+    "entries:resolve": function(ctx) {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
 
 const headSymbol = "usehead";
-function injectHead() {
-  return vue.getCurrentInstance() && vue.inject(headSymbol) || unhead.getActiveHead();
-}
 function vueInstall(head) {
   const plugin = {
     install(app) {
@@ -47,43 +52,30 @@ function vueInstall(head) {
   return plugin.install;
 }
 function createServerHead(options = {}) {
-  const head = unhead.createServerHead({
-    ...options,
-    plugins: [
-      VueReactiveUseHeadPlugin(),
-      ...options?.plugins || []
-    ]
-  });
+  const head = unhead.createServerHead(options);
+  head.use(VueReactivityPlugin);
   head.install = vueInstall(head);
   return head;
 }
 function createHead(options = {}) {
-  const head = unhead.createHead({
-    ...options,
-    // arbitrary delay the dom update for batch updates
-    domDelayFn: (fn) => setTimeout(() => vue.nextTick(() => fn()), 10),
-    plugins: [
-      VueReactiveUseHeadPlugin(),
-      ...options?.plugins || []
-    ]
-  });
+  options.domDelayFn = options.domDelayFn || ((fn) => vue.nextTick(() => fn()));
+  const head = unhead.createHead(options);
+  head.use(VueReactivityPlugin);
   head.install = vueInstall(head);
   return head;
 }
 
-function VueReactiveUseHeadPlugin() {
-  return shared.defineHeadPlugin({
-    hooks: {
-      "entries:resolve": function(ctx) {
-        for (const entry of ctx.entries)
-          entry.resolvedInput = resolveUnrefHeadInput(entry.input);
-      }
-    }
-  });
+function injectHead() {
+  return vue.getCurrentInstance() && vue.inject(headSymbol) || unhead.getActiveHead();
 }
 
-function clientUseHead(input, options = {}) {
+function useHead(input, options = {}) {
   const head = injectHead();
+  if (!head.ssr)
+    return clientUseHead(head, input, options);
+  return head.push(input, options);
+}
+function clientUseHead(head, input, options = {}) {
   const deactivated = vue.ref(false);
   const resolvedInput = vue.ref({});
   vue.watchEffect(() => {
@@ -108,26 +100,9 @@ function clientUseHead(input, options = {}) {
   return entry;
 }
 
-function serverUseHead(input, options = {}) {
-  const head = injectHead();
-  return head.push(input, options);
-}
-
-function useHead(input, options = {}) {
-  const head = injectHead();
-  if (head) {
-    const isBrowser = IsBrowser || !!head.resolvedOptions?.document;
-    if (options.mode === "server" && isBrowser || options.mode === "client" && !isBrowser)
-      return;
-    return isBrowser ? clientUseHead(input, options) : serverUseHead(input, options);
-  }
-}
-
-exports.VueReactiveUseHeadPlugin = VueReactiveUseHeadPlugin;
 exports.createHead = createHead;
 exports.createServerHead = createServerHead;
 exports.headSymbol = headSymbol;
 exports.injectHead = injectHead;
 exports.resolveUnrefHeadInput = resolveUnrefHeadInput;
-exports.serverUseHead = serverUseHead;
 exports.useHead = useHead;

package/dist/shared/{vue.505b826e.mjs → vue.9fbebdf0.mjs}

@@ -1,7 +1,9 @@
-import { unref, version, getCurrentInstance, inject, nextTick, ref, watchEffect, watch, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
-import { getActiveHead, createServerHead as createServerHead$1, createHead as createHead$1 } from 'unhead';
+import { version, unref, nextTick, getCurrentInstance, inject, ref, watchEffect, watch, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+import { createServerHead as createServerHead$1, createHead as createHead$1, getActiveHead } from 'unhead';
 import { defineHeadPlugin } from '@unhead/shared';
 
+const Vue3 = version.startsWith("3");
+
 function resolveUnref(r) {
   return typeof r === "function" ? r() : unref(r);
 }
@@ -25,13 +27,16 @@ function resolveUnrefHeadInput(ref, lastKey = "") {
   return root;
 }
 
-const Vue3 = version.startsWith("3");
-const IsBrowser = typeof window !== "undefined";
+const VueReactivityPlugin = defineHeadPlugin({
+  hooks: {
+    "entries:resolve": function(ctx) {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
 
 const headSymbol = "usehead";
-function injectHead() {
-  return getCurrentInstance() && inject(headSymbol) || getActiveHead();
-}
 function vueInstall(head) {
   const plugin = {
     install(app) {
@@ -45,43 +50,30 @@ function vueInstall(head) {
   return plugin.install;
 }
 function createServerHead(options = {}) {
-  const head = createServerHead$1({
-    ...options,
-    plugins: [
-      VueReactiveUseHeadPlugin(),
-      ...options?.plugins || []
-    ]
-  });
+  const head = createServerHead$1(options);
+  head.use(VueReactivityPlugin);
   head.install = vueInstall(head);
   return head;
 }
 function createHead(options = {}) {
-  const head = createHead$1({
-    ...options,
-    // arbitrary delay the dom update for batch updates
-    domDelayFn: (fn) => setTimeout(() => nextTick(() => fn()), 10),
-    plugins: [
-      VueReactiveUseHeadPlugin(),
-      ...options?.plugins || []
-    ]
-  });
+  options.domDelayFn = options.domDelayFn || ((fn) => nextTick(() => fn()));
+  const head = createHead$1(options);
+  head.use(VueReactivityPlugin);
   head.install = vueInstall(head);
   return head;
 }
 
-function VueReactiveUseHeadPlugin() {
-  return defineHeadPlugin({
-    hooks: {
-      "entries:resolve": function(ctx) {
-        for (const entry of ctx.entries)
-          entry.resolvedInput = resolveUnrefHeadInput(entry.input);
-      }
-    }
-  });
+function injectHead() {
+  return getCurrentInstance() && inject(headSymbol) || getActiveHead();
 }
 
-function clientUseHead(input, options = {}) {
+function useHead(input, options = {}) {
   const head = injectHead();
+  if (!head.ssr)
+    return clientUseHead(head, input, options);
+  return head.push(input, options);
+}
+function clientUseHead(head, input, options = {}) {
   const deactivated = ref(false);
   const resolvedInput = ref({});
   watchEffect(() => {
@@ -106,19 +98,4 @@ function clientUseHead(input, options = {}) {
   return entry;
 }
 
-function serverUseHead(input, options = {}) {
-  const head = injectHead();
-  return head.push(input, options);
-}
-
-function useHead(input, options = {}) {
-  const head = injectHead();
-  if (head) {
-    const isBrowser = IsBrowser || !!head.resolvedOptions?.document;
-    if (options.mode === "server" && isBrowser || options.mode === "client" && !isBrowser)
-      return;
-    return isBrowser ? clientUseHead(input, options) : serverUseHead(input, options);
-  }
-}
-
-export { VueReactiveUseHeadPlugin as V, createHead as a, createServerHead as c, headSymbol as h, injectHead as i, resolveUnrefHeadInput as r, serverUseHead as s, useHead as u };
+export { createServerHead as a, createHead as c, headSymbol as h, injectHead as i, resolveUnrefHeadInput as r, useHead as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unhead/vue",
   "type": "module",
-  "version": "1.2.2",
+  "version": "1.3.0-beta.0",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/harlan-zw",
@@ -38,9 +38,9 @@
   },
   "dependencies": {
     "hookable": "^5.5.3",
-    "@unhead/schema": "1.2.2",
-    "@unhead/shared": "1.2.2",
-    "unhead": "1.2.2"
+    "@unhead/schema": "1.3.0-beta.0",
+    "@unhead/shared": "1.3.0-beta.0",
+    "unhead": "1.3.0-beta.0"
   },
   "devDependencies": {
     "vue": "^3.3.4"