@unhead/vue 1.3.0-beta.0 → 1.3.0-beta.2

package/dist/index.d.ts

@@ -1,12 +1,10 @@
-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, CreateHeadOptions, HeadEntryOptions, ActiveHeadEntry, MetaFlatInput } from '@unhead/schema';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, CreateHeadOptions, HeadEntryOptions, ActiveHeadEntry } from '@unhead/schema';
 export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, Unhead } from '@unhead/schema';
-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';
+import { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, V as VueHeadClient, U as UseHeadInput, b as UseSeoMetaInput } from './schema-84920ead.js';
+export { d as Base, B as BodyAttr, h as BodyAttributes, H as HtmlAttr, g as HtmlAttributes, L as Link, j as MaybeComputedRefOrPromise, i as MaybeReadonlyRef, e as Meta, N as Noscript, f as Script, S as Style, T as Title, c as TitleTemplate } from './schema-84920ead.js';
+import { Plugin } from 'vue';
 
 interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
     meta?: MaybeComputedRefEntries<SafeMeta>[];
@@ -18,238 +16,31 @@ interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templ
 }
 type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
 
-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 function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
 
-declare const VueHeadMixin$1: {
+declare const VueHeadMixin: {
     created(): void;
 };
 
-declare const Vue2ProvideUnheadPlugin$1: Plugin;
+declare const Vue2ProvideUnheadPlugin: Plugin;
 
-declare const unheadVueComposablesImports$1: {
+declare const unheadVueComposablesImports: {
     '@unhead/vue': string[];
 };
 
-declare function injectHead$1<T extends MergeHead>(): VueHeadClient<T>;
+declare function injectHead<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;
-
-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 useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
 
 declare function useHeadSafe(input: UseHeadSafeInput, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
 
-type UseSeoMetaInput = MaybeComputedRefEntries<MetaFlatInput> & {
-    title?: ReactiveHead['title'];
-    titleTemplate?: ReactiveHead['titleTemplate'];
-};
 declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
 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: dist.UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-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 };
+export { HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, ReactiveHead, UseHeadInput, UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, createHead, createServerHead, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/polyfill.d.ts

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

package/dist/{schema-f7f2c0b4.d.ts → schema-84920ead.d.ts}

@@ -1,4 +1,4 @@
-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 { 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, MetaFlatInput, Unhead } from '@unhead/schema';
 import { ComputedRef, Ref, Plugin } from 'vue';
 
 type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
@@ -105,6 +105,10 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
     bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
 }
 type UseHeadInput<T extends MergeHead = {}> = MaybeComputedRef<ReactiveHead<T>>;
+type UseSeoMetaInput = MaybeComputedRefEntries<MetaFlatInput> & {
+    title?: ReactiveHead['title'];
+    titleTemplate?: ReactiveHead['titleTemplate'];
+};
 type VueHeadClient<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>> & Plugin;
 
-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 };
+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, UseSeoMetaInput as b, TitleTemplate as c, Base as d, Meta as e, Script as f, HtmlAttributes as g, BodyAttributes as h, MaybeReadonlyRef as i, MaybeComputedRefOrPromise as j };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unhead/vue",
   "type": "module",
-  "version": "1.3.0-beta.0",
+  "version": "1.3.0-beta.2",
   "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.3.0-beta.0",
-    "@unhead/shared": "1.3.0-beta.0",
-    "unhead": "1.3.0-beta.0"
+    "@unhead/schema": "1.3.0-beta.2",
+    "@unhead/shared": "1.3.0-beta.2",
+    "unhead": "1.3.0-beta.2"
   },
   "devDependencies": {
     "vue": "^3.3.4"