@unhead/vue 1.3.9 → 1.4.1

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const unhead = require('unhead');
-const useHead = require('./shared/vue.3633f8ad.cjs');
+const useHead = require('./shared/vue.b3743d94.cjs');
 const vue = require('vue');
 const shared = require('@unhead/shared');
 

package/dist/index.d.cts

@@ -0,0 +1,48 @@
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import * as _unhead_schema 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, b as UseSeoMetaInput } from './shared/vue.c0307a01.cjs';
+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 './shared/vue.c0307a01.cjs';
+import { Plugin } from 'vue';
+
+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>;
+
+declare function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
+
+declare function resolveUnrefHeadInput(ref: any, lastKey?: string | number): any;
+
+declare const VueHeadMixin: {
+    created(): void;
+};
+
+declare const Vue2ProvideUnheadPlugin: Plugin;
+
+declare const unheadVueComposablesImports: {
+    '@unhead/vue': string[];
+};
+
+declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
+
+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;
+
+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>>> | undefined;
+
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: HeadEntryOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
+
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
+
+export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, ReactiveHead, UseHeadInput, type UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, createHead, createServerHead, injectHead, resolveUnrefHeadInput, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
+import * as _unhead_schema 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, b as UseSeoMetaInput } from './shared/vue.c0307a01.mjs';
+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 './shared/vue.c0307a01.mjs';
+import { Plugin } from 'vue';
+
+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>;
+
+declare function createServerHead<T extends MergeHead>(options?: Omit<CreateHeadOptions, 'domDelayFn' | 'document'>): VueHeadClient<T>;
+declare function createHead<T extends MergeHead>(options?: CreateHeadOptions): VueHeadClient<T>;
+
+declare function resolveUnrefHeadInput(ref: any, lastKey?: string | number): any;
+
+declare const VueHeadMixin: {
+    created(): void;
+};
+
+declare const Vue2ProvideUnheadPlugin: Plugin;
+
+declare const unheadVueComposablesImports: {
+    '@unhead/vue': string[];
+};
+
+declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
+
+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;
+
+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>>> | undefined;
+
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: HeadEntryOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
+
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
+
+export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, ReactiveHead, UseHeadInput, type UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, createHead, createServerHead, injectHead, resolveUnrefHeadInput, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
 import * as _unhead_schema 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, 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 { R as ReactiveHead, M as MaybeComputedRefEntries, a as MaybeComputedRef, V as VueHeadClient, U as UseHeadInput, b as UseSeoMetaInput } from './shared/vue.c0307a01.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 './shared/vue.c0307a01.js';
 import { Plugin } from 'vue';
 
 interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
@@ -45,4 +45,4 @@ declare function useServerHeadSafe(input: UseHeadSafeInput, options?: HeadEntryO
 
 declare function useServerSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any> | void;
 
-export { HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, ReactiveHead, UseHeadInput, UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, createHead, createServerHead, injectHead, resolveUnrefHeadInput, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, ReactiveHead, UseHeadInput, type UseHeadSafeInput, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, createHead, createServerHead, injectHead, resolveUnrefHeadInput, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
-import { V as Vue3, u as useHead, h as headSymbol, r as resolveUnrefHeadInput, i as injectHead } from './shared/vue.cf073917.mjs';
-export { c as createHead, a as createServerHead } from './shared/vue.cf073917.mjs';
+import { V as Vue3, u as useHead, h as headSymbol, r as resolveUnrefHeadInput, i as injectHead } from './shared/vue.e88efe84.mjs';
+export { c as createHead, a as createServerHead } from './shared/vue.e88efe84.mjs';
 import { getCurrentInstance, ref, watchEffect } from 'vue';
 import { composableNames, whitelistSafeInput, unpackMeta } from '@unhead/shared';
 

package/dist/polyfill.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const useHead = require('./shared/vue.3633f8ad.cjs');
+const useHead = require('./shared/vue.b3743d94.cjs');
 require('vue');
 require('unhead');
 require('@unhead/shared');

package/dist/polyfill.d.cts

@@ -0,0 +1,37 @@
+import { MergeHead, HeadEntryOptions } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput } from './shared/vue.c0307a01.cjs';
+import 'vue';
+
+type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
+    /**
+     * @deprecated use `resolveTags`
+     */
+    headTags: VueHeadClient<T>['resolveTags'];
+    /**
+     * @deprecated use `push`
+     */
+    addEntry: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `push`
+     */
+    addHeadObjs: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `useHead`
+     */
+    addReactiveEntry: (input: UseHeadInput<T>, options?: HeadEntryOptions) => (() => void);
+    /**
+     * @deprecated Use useHead API.
+     */
+    removeHeadObjs: () => void;
+    /**
+     * @deprecated Call hook `entries:resolve` or update an entry
+     */
+    updateDOM: () => void;
+    /**
+     * @deprecated Access unhead properties directly.
+     */
+    unhead: VueHeadClient<T>;
+};
+declare function polyfillAsVueUseHead<T extends MergeHead>(head: VueHeadClient<T>): VueHeadClientPollyFill<T>;
+
+export { type VueHeadClientPollyFill, polyfillAsVueUseHead };

package/dist/polyfill.d.mts

@@ -0,0 +1,37 @@
+import { MergeHead, HeadEntryOptions } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput } from './shared/vue.c0307a01.mjs';
+import 'vue';
+
+type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
+    /**
+     * @deprecated use `resolveTags`
+     */
+    headTags: VueHeadClient<T>['resolveTags'];
+    /**
+     * @deprecated use `push`
+     */
+    addEntry: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `push`
+     */
+    addHeadObjs: VueHeadClient<T>['push'];
+    /**
+     * @deprecated use `useHead`
+     */
+    addReactiveEntry: (input: UseHeadInput<T>, options?: HeadEntryOptions) => (() => void);
+    /**
+     * @deprecated Use useHead API.
+     */
+    removeHeadObjs: () => void;
+    /**
+     * @deprecated Call hook `entries:resolve` or update an entry
+     */
+    updateDOM: () => void;
+    /**
+     * @deprecated Access unhead properties directly.
+     */
+    unhead: VueHeadClient<T>;
+};
+declare function polyfillAsVueUseHead<T extends MergeHead>(head: VueHeadClient<T>): VueHeadClientPollyFill<T>;
+
+export { type VueHeadClientPollyFill, polyfillAsVueUseHead };

package/dist/polyfill.d.ts

@@ -1,5 +1,5 @@
 import { MergeHead, HeadEntryOptions } from '@unhead/schema';
-import { V as VueHeadClient, U as UseHeadInput } from './schema-84920ead.js';
+import { V as VueHeadClient, U as UseHeadInput } from './shared/vue.c0307a01.js';
 import 'vue';
 
 type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
@@ -34,4 +34,4 @@ type VueHeadClientPollyFill<T extends MergeHead> = VueHeadClient<T> & {
 };
 declare function polyfillAsVueUseHead<T extends MergeHead>(head: VueHeadClient<T>): VueHeadClientPollyFill<T>;
 
-export { VueHeadClientPollyFill, polyfillAsVueUseHead };
+export { type VueHeadClientPollyFill, polyfillAsVueUseHead };

package/dist/polyfill.mjs

@@ -1,4 +1,4 @@
-import { u as useHead } from './shared/vue.cf073917.mjs';
+import { u as useHead } from './shared/vue.e88efe84.mjs';
 import 'vue';
 import 'unhead';
 import '@unhead/shared';

package/dist/shared/{vue.3633f8ad.cjs → vue.b3743d94.cjs}

@@ -66,7 +66,7 @@ function createHead(options = {}) {
 }
 
 function injectHead() {
-  return vue.getCurrentInstance() && vue.inject(headSymbol) || unhead.getActiveHead();
+  return vue.hasInjectionContext() && vue.inject(headSymbol) || unhead.getActiveHead();
 }
 
 function useHead(input, options = {}) {

package/dist/{schema-84920ead.d.ts → shared/vue.c0307a01.d.cts}

@@ -111,4 +111,4 @@ type UseSeoMetaInput = MaybeComputedRefEntries<MetaFlatInput> & {
 };
 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, 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 };
+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, 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/dist/shared/vue.c0307a01.d.mts

@@ -0,0 +1,114 @@
+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>;
+type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrPromise<T> = T | MaybeReadonlyRef<T> | Ref<T> | Promise<T>;
+type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
+    [key in keyof T]?: MaybeComputedRefOrPromise<T[key]>;
+};
+
+interface HtmlAttr extends Omit<BaseHtmlAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+interface BodyAttr extends Omit<BaseBodyAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+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>>;
+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.
+     * It only contains text; tags within the element are ignored.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+     */
+    title?: Title | Promise<Title>;
+    /**
+     * Generate the title from a template.
+     */
+    titleTemplate?: TitleTemplate;
+    /**
+     * Variables used to substitute in the title and meta content.
+     */
+    templateParams?: MaybeComputedRefEntries<Record<string, null | string | MaybeComputedRefEntries<Record<string, null | string>>>>;
+    /**
+     * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+     * There can be only one <base> element in a document.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+     */
+    base?: Base<E['base']>;
+    /**
+     * The `<link>` HTML element specifies relationships between the current document and an external resource.
+     * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+     * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+     */
+    link?: MaybeComputedRef<Link<E['link']>[]>;
+    /**
+     * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+     */
+    meta?: MaybeComputedRef<Meta<E['meta']>[]>;
+    /**
+     * The `<style>` HTML element contains style information for a document, or part of a document.
+     * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+     */
+    style?: MaybeComputedRef<(Style<E['style']> | string)[]>;
+    /**
+     * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+     */
+    script?: MaybeComputedRef<(Script<E['script']> | string)[]>;
+    /**
+     * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+     * or if scripting is currently turned off in the browser.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+     */
+    noscript?: MaybeComputedRef<(Noscript<E['noscript']> | string)[]>;
+    /**
+     * Attributes for the `<html>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+     */
+    htmlAttrs?: HtmlAttributes<E['htmlAttrs']>;
+    /**
+     * Attributes for the `<body>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+     */
+    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 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, 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/dist/shared/vue.c0307a01.d.ts

@@ -0,0 +1,114 @@
+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>;
+type MaybeComputedRef<T> = T | MaybeReadonlyRef<T> | Ref<T>;
+type MaybeComputedRefOrPromise<T> = T | MaybeReadonlyRef<T> | Ref<T> | Promise<T>;
+type MaybeComputedRefEntries<T> = MaybeComputedRef<T> | {
+    [key in keyof T]?: MaybeComputedRefOrPromise<T[key]>;
+};
+
+interface HtmlAttr extends Omit<BaseHtmlAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+interface BodyAttr extends Omit<BaseBodyAttr, 'class'> {
+    /**
+     * The class global attribute is a space-separated list of the case-sensitive classes of the element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
+     */
+    class?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<boolean>>;
+}
+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>>;
+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.
+     * It only contains text; tags within the element are ignored.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
+     */
+    title?: Title | Promise<Title>;
+    /**
+     * Generate the title from a template.
+     */
+    titleTemplate?: TitleTemplate;
+    /**
+     * Variables used to substitute in the title and meta content.
+     */
+    templateParams?: MaybeComputedRefEntries<Record<string, null | string | MaybeComputedRefEntries<Record<string, null | string>>>>;
+    /**
+     * The `<base>` HTML element specifies the base URL to use for all relative URLs in a document.
+     * There can be only one <base> element in a document.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+     */
+    base?: Base<E['base']>;
+    /**
+     * The `<link>` HTML element specifies relationships between the current document and an external resource.
+     * This element is most commonly used to link to stylesheets, but is also used to establish site icons
+     * (both "favicon" style icons and icons for the home screen and apps on mobile devices) among other things.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link#attr-as
+     */
+    link?: MaybeComputedRef<Link<E['link']>[]>;
+    /**
+     * The `<meta>` element represents metadata that cannot be expressed in other HTML elements, like `<link>` or `<script>`.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta
+     */
+    meta?: MaybeComputedRef<Meta<E['meta']>[]>;
+    /**
+     * The `<style>` HTML element contains style information for a document, or part of a document.
+     * It contains CSS, which is applied to the contents of the document containing the `<style>` element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style
+     */
+    style?: MaybeComputedRef<(Style<E['style']> | string)[]>;
+    /**
+     * The `<script>` HTML element is used to embed executable code or data; this is typically used to embed or refer to JavaScript code.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
+     */
+    script?: MaybeComputedRef<(Script<E['script']> | string)[]>;
+    /**
+     * The `<noscript>` HTML element defines a section of HTML to be inserted if a script type on the page is unsupported
+     * or if scripting is currently turned off in the browser.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
+     */
+    noscript?: MaybeComputedRef<(Noscript<E['noscript']> | string)[]>;
+    /**
+     * Attributes for the `<html>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
+     */
+    htmlAttrs?: HtmlAttributes<E['htmlAttrs']>;
+    /**
+     * Attributes for the `<body>` HTML element.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
+     */
+    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 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, 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/dist/shared/{vue.cf073917.mjs → vue.e88efe84.mjs}

@@ -1,4 +1,4 @@
-import { version, unref, nextTick, getCurrentInstance, inject, ref, watchEffect, watch, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
+import { version, unref, nextTick, hasInjectionContext, inject, ref, watchEffect, watch, getCurrentInstance, onBeforeUnmount, onDeactivated, onActivated } from 'vue';
 import { createServerHead as createServerHead$1, createHead as createHead$1, getActiveHead } from 'unhead';
 import { defineHeadPlugin } from '@unhead/shared';
 
@@ -64,7 +64,7 @@ function createHead(options = {}) {
 }
 
 function injectHead() {
-  return getCurrentInstance() && inject(headSymbol) || getActiveHead();
+  return hasInjectionContext() && inject(headSymbol) || getActiveHead();
 }
 
 function useHead(input, options = {}) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unhead/vue",
   "type": "module",
-  "version": "1.3.9",
+  "version": "1.4.1",
   "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.9",
-    "@unhead/shared": "1.3.9",
-    "unhead": "1.3.9"
+    "@unhead/schema": "1.4.1",
+    "@unhead/shared": "1.4.1",
+    "unhead": "1.4.1"
   },
   "devDependencies": {
     "vue": "^3.3.4"