@unhead/vue 1.11.15 → 2.0.0-alpha.0

package/dist/index.d.ts

@@ -1,78 +1,33 @@
-export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
 import * as _unhead_schema from '@unhead/schema';
-import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr, MergeHead, CreateHeadOptions, ActiveHeadEntry, ScriptInstance, UseScriptStatus, ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, UseScriptOptions as UseScriptOptions$1, AsAsyncFunctionValues, UseFunctionType } from '@unhead/schema';
+import { Unhead, MergeHead, 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 UseHeadOptions, c as MaybeComputedRefEntriesOnly, d as UseSeoMetaInput } from './shared/vue.fwis0K4Q.js';
-export { f as Base, B as BodyAttr, j as BodyAttributes, H as HtmlAttr, i as HtmlAttributes, L as Link, l as MaybeComputedRefOrFalsy, m as MaybeComputedRefOrPromise, k as MaybeReadonlyRef, g as Meta, N as Noscript, h as Script, S as Style, T as Title, e as TitleTemplate } from './shared/vue.fwis0K4Q.js';
-import { Ref, 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): any;
+export { createHeadCore, unheadCtx } from 'unhead';
+import { U as UseHeadInput, a as UseHeadOptions, b as UseHeadSafeInput, c as UseSeoMetaInput } from './shared/vue.B8gXlHM7.js';
+export { f as Base, B as BodyAttr, i as BodyAttributes, H as HeadSafe, d as HtmlAttr, h as HtmlAttributes, L as Link, k as MaybeComputedRef, n as MaybeComputedRefEntries, o as MaybeComputedRefEntriesOnly, l as MaybeComputedRefOrFalsy, m as MaybeComputedRefOrPromise, j as MaybeReadonlyRef, M as Meta, N as Noscript, R as ReactiveHead, g as Script, S as Style, T as Title, e as TitleTemplate, V as VueHeadClient, r as resolveUnrefHeadInput } from './shared/vue.B8gXlHM7.js';
+export { V as VueHeadMixin } from './shared/vue.DnywREVF.js';
+import 'vue';
 
 declare const unheadVueComposablesImports: {
     '@unhead/vue': string[];
 };
 
-declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
-declare function injectHead<T extends MergeHead>(): VueHeadClient<T>;
+declare function injectHead(): Unhead<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>> | Unhead<_unhead_schema.Head<_unhead_schema.MergeHead>>;
 
-declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>>;
 
-declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
 
-interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
-    status: Ref<UseScriptStatus>;
-}
-type UseScriptInput = string | (MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
-    src: string;
-});
-interface UseScriptOptions<T extends Record<symbol | string, any> = {}, U = {}> extends HeadEntryOptions, Pick<UseScriptOptions$1<T, U>, 'use' | 'stub' | 'eventContext' | 'beforeInit'> {
-    /**
-     * The trigger to load the script:
-     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
-     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
-     * - `Promise` - Load the script when the promise resolves, exists only on the client.
-     * - `Function` - Register a callback function to load the script, exists only on the client.
-     * - `server` - Have the script injected on the server.
-     * - `ref` - Load the script when the ref is true.
-     */
-    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
-}
-type UseScriptContext<T extends Record<symbol | string, any>> = (Promise<T> & VueScriptInstance<T>) & AsAsyncFunctionValues<T> & {
-    /**
-     * @deprecated Use top-level functions instead.
-     */
-    $script: Promise<T> & VueScriptInstance<T>;
-};
-declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>, U = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T, U>): UseScriptContext<UseFunctionType<UseScriptOptions<T, U>, T>>;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
 
-declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<any>;
 
-declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): _unhead_schema.ActiveHeadEntry<MaybeComputedRef<ReactiveHead<any>>> | undefined;
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any>;
 
-declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): void | _unhead_schema.ActiveHeadEntry<UseHeadSafeInput>;
-
-declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<UseSeoMetaInput>;
 
 /**
- * @deprecated Import { UnheadPlugin } from `@unhead/vue/vue2` and use Vue.mixin(UnheadPlugin(head)) instead.
+ * @deprecated TODO remove
  */
-declare const Vue2ProvideUnheadPlugin: Plugin;
-
-declare const VueHeadMixin: {
-    created(): void;
-};
+declare const CapoPlugin: () => _unhead_schema.HeadPluginInput;
 
-export { type HeadSafe, MaybeComputedRef, MaybeComputedRefEntries, MaybeComputedRefEntriesOnly, ReactiveHead, UseHeadInput, UseHeadOptions, type UseHeadSafeInput, type UseScriptContext, type UseScriptInput, type UseScriptOptions, UseSeoMetaInput, Vue2ProvideUnheadPlugin, VueHeadClient, VueHeadMixin, type VueScriptInstance, createHead, createServerHead, injectHead, resolveUnrefHeadInput, setHeadInjectionHandler, unheadVueComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, UseHeadInput, UseHeadOptions, UseHeadSafeInput, UseSeoMetaInput, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/index.mjs

@@ -1,10 +1,9 @@
-import { useScript as useScript$1 } from 'unhead';
-export { CapoPlugin, HashHydrationPlugin, createHeadCore } from 'unhead';
-import { i as injectHead, h as headSymbol, V as Vue3 } from './shared/vue.ziyDaVMR.mjs';
-export { c as createHead, a as createServerHead, r as resolveUnrefHeadInput, s as setHeadInjectionHandler } from './shared/vue.ziyDaVMR.mjs';
-import { composableNames, whitelistSafeInput, unpackMeta } from '@unhead/shared';
-import { u as useHead } from './shared/vue.-sixQ7xP.mjs';
-import { getCurrentInstance, onMounted, isRef, watch, onScopeDispose, ref } from 'vue';
+import { composableNames, whitelistSafeInput, unpackMeta, defineHeadPlugin } from '@unhead/shared';
+export { createHeadCore, unheadCtx } from 'unhead';
+import { u as useHead } from './shared/vue.Sg4YunmP.mjs';
+export { i as injectHead, r as resolveUnrefHeadInput } from './shared/vue.Sg4YunmP.mjs';
+export { V as VueHeadMixin } from './shared/vue.O-w7-AFg.mjs';
+import 'vue';
 
 const coreComposableNames = [
   "injectHead"
@@ -17,71 +16,6 @@ function useHeadSafe(input, options = {}) {
   return useHead(input, { ...options, transform: whitelistSafeInput });
 }
 
-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);
-    }
-  });
-}
-
 function useSeoMeta(input, options) {
   const { title, titleTemplate, ...meta } = input;
   return useHead({
@@ -104,10 +38,7 @@ function useSeoMeta(input, options) {
 }
 
 function useServerHead(input, options = {}) {
-  const head = options.head || injectHead();
-  delete options.head;
-  if (head)
-    return head.push(input, { ...options, mode: "server" });
+  return useHead(input, { ...options, mode: "server" });
 }
 
 function useServerHeadSafe(input, options = {}) {
@@ -118,45 +49,6 @@ function useServerSeoMeta(input, options) {
   return useSeoMeta(input, { ...options, mode: "server" });
 }
 
-const Vue2ProvideUnheadPlugin = (_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,
-          [headSymbol]: head
-        };
-      };
-    }
-  });
-};
-
-const VueHeadMixin = {
-  created() {
-    let source = false;
-    if (Vue3) {
-      const instance = 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;
-    } else {
-      const head = this.$options.head;
-      if (head) {
-        source = typeof head === "function" ? () => head.call(this) : head;
-      }
-    }
-    source && useHead(source);
-  }
-};
+const CapoPlugin = () => defineHeadPlugin({});
 
-export { Vue2ProvideUnheadPlugin, VueHeadMixin, injectHead, unheadVueComposablesImports, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };
+export { CapoPlugin, unheadVueComposablesImports, useHead, useHeadSafe, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/legacy.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+const shared = require('@unhead/shared');
+const unhead = require('unhead');
+const vue = require('vue');
+const client = require('./client.cjs');
+const useHead$1 = require('./shared/vue.BwEnMiRq.cjs');
+const server = require('./server.cjs');
+const legacy = require('unhead/legacy');
+require('unhead/client');
+require('./shared/vue.DIPZN3-d.cjs');
+require('./shared/vue.3OjaFlxQ.cjs');
+require('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;
+      }
+    };
+    vue.onScopeDispose(destroy);
+    return destroy;
+  };
+  script.onLoaded = (cb) => _registerCb("loaded", cb);
+  script.onError = (cb) => _registerCb("error", cb);
+  vue.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 = vue.getCurrentInstance();
+  options.eventContext = scope;
+  if (scope && typeof options.trigger === "undefined") {
+    options.trigger = vue.onMounted;
+  } else if (vue.isRef(options.trigger)) {
+    const refTrigger = options.trigger;
+    let off;
+    options.trigger = new Promise((resolve) => {
+      off = vue.watch(refTrigger, (val) => {
+        if (val) {
+          resolve(true);
+        }
+      }, {
+        immediate: true
+      });
+      vue.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 = legacy.useScript(input, options);
+  script._statusRef = script._statusRef || vue.ref(script.status);
+  registerVueScopeHandlers(script, scope);
+  return new Proxy(script, {
+    get(_, key, a) {
+      return Reflect.get(_, key === "status" ? "_statusRef" : key, a);
+    }
+  });
+}
+
+const CapoPlugin = () => shared.defineHeadPlugin({});
+function setHeadInjectionHandler(handler) {
+  unhead.unheadCtx.set(handler(), true);
+}
+function injectHead() {
+  const ctx = unhead.tryUseUnhead();
+  if (ctx) {
+    return ctx;
+  }
+  return vue.inject(useHead$1.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 = vue.ref(false);
+  const resolvedInput = vue.ref({});
+  vue.watchEffect(() => {
+    resolvedInput.value = deactivated.value ? {} : useHead$1.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;
+}
+function useHeadSafe(input, options = {}) {
+  return useHead(input, { ...options, transform: shared.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 = shared.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" });
+}
+
+exports.createHeadCore = unhead.createHeadCore;
+exports.createHead = client.createHead;
+exports.resolveUnrefHeadInput = useHead$1.resolveUnrefHeadInput;
+exports.createServerHead = server.createHead;
+exports.resolveScriptKey = legacy.resolveScriptKey;
+exports.CapoPlugin = CapoPlugin;
+exports.injectHead = injectHead;
+exports.setHeadInjectionHandler = setHeadInjectionHandler;
+exports.useHead = useHead;
+exports.useHeadSafe = useHeadSafe;
+exports.useScript = useScript;
+exports.useSeoMeta = useSeoMeta;
+exports.useServerHead = useServerHead;
+exports.useServerHeadSafe = useServerHeadSafe;
+exports.useServerSeoMeta = useServerSeoMeta;

package/dist/legacy.d.cts

@@ -0,0 +1,51 @@
+import * as _unhead_schema from '@unhead/schema';
+import { ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, Unhead, MergeHead, ActiveHeadEntry } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseHeadSafeInput, c as UseSeoMetaInput } from './shared/vue.B8gXlHM7.cjs';
+export { r as resolveUnrefHeadInput } from './shared/vue.B8gXlHM7.cjs';
+export { createHeadCore } from 'unhead';
+export { createHead } from './client.cjs';
+export { createHead as createServerHead } from './server.cjs';
+import { d as distExports } from './shared/vue.DShwsPiO.cjs';
+import { ScriptInstance, UseScriptStatus, UseScriptOptions as UseScriptOptions$1, UseFunctionType } from 'unhead/legacy';
+export { UseFunctionType, resolveScriptKey } from 'unhead/legacy';
+import { Ref } from 'vue';
+import './shared/vue.DnywREVF.cjs';
+import 'unhead/client';
+import 'unhead/server';
+import '@unhead/shared';
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (distExports.MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = Record<string, any>> extends HeadEntryOptions, Pick<UseScriptOptions$1<T>, 'use' | 'eventContext' | 'beforeInit'> {
+    /**
+     * The trigger to load the script:
+     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+     * - `Promise` - Load the script when the promise resolves, exists only on the client.
+     * - `Function` - Register a callback function to load the script, exists only on the client.
+     * - `server` - Have the script injected on the server.
+     * - `ref` - Load the script when the ref is true.
+     */
+    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = Promise<T> & VueScriptInstance<T>;
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
+
+declare const CapoPlugin: () => _unhead_schema.HeadPluginInput;
+/**
+ * @deprecated Please switch to non-legacy version
+ */
+declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
+declare function injectHead(): Unhead<_unhead_schema.Head<MergeHead>> | Unhead<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>> | undefined;
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+export { CapoPlugin, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type VueScriptInstance, injectHead, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/legacy.d.mts

@@ -0,0 +1,51 @@
+import * as _unhead_schema from '@unhead/schema';
+import { ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, Unhead, MergeHead, ActiveHeadEntry } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseHeadSafeInput, c as UseSeoMetaInput } from './shared/vue.B8gXlHM7.mjs';
+export { r as resolveUnrefHeadInput } from './shared/vue.B8gXlHM7.mjs';
+export { createHeadCore } from 'unhead';
+export { createHead } from './client.mjs';
+export { createHead as createServerHead } from './server.mjs';
+import { d as distExports } from './shared/vue.DShwsPiO.mjs';
+import { ScriptInstance, UseScriptStatus, UseScriptOptions as UseScriptOptions$1, UseFunctionType } from 'unhead/legacy';
+export { UseFunctionType, resolveScriptKey } from 'unhead/legacy';
+import { Ref } from 'vue';
+import './shared/vue.DnywREVF.mjs';
+import 'unhead/client';
+import 'unhead/server';
+import '@unhead/shared';
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (distExports.MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = Record<string, any>> extends HeadEntryOptions, Pick<UseScriptOptions$1<T>, 'use' | 'eventContext' | 'beforeInit'> {
+    /**
+     * The trigger to load the script:
+     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+     * - `Promise` - Load the script when the promise resolves, exists only on the client.
+     * - `Function` - Register a callback function to load the script, exists only on the client.
+     * - `server` - Have the script injected on the server.
+     * - `ref` - Load the script when the ref is true.
+     */
+    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = Promise<T> & VueScriptInstance<T>;
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
+
+declare const CapoPlugin: () => _unhead_schema.HeadPluginInput;
+/**
+ * @deprecated Please switch to non-legacy version
+ */
+declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
+declare function injectHead(): Unhead<_unhead_schema.Head<MergeHead>> | Unhead<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>> | undefined;
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+export { CapoPlugin, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type VueScriptInstance, injectHead, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };

package/dist/legacy.d.ts

@@ -0,0 +1,51 @@
+import * as _unhead_schema from '@unhead/schema';
+import { ScriptBase, DataKeys, SchemaAugmentations, HeadEntryOptions, Unhead, MergeHead, ActiveHeadEntry } from '@unhead/schema';
+import { V as VueHeadClient, U as UseHeadInput, a as UseHeadOptions, b as UseHeadSafeInput, c as UseSeoMetaInput } from './shared/vue.B8gXlHM7.js';
+export { r as resolveUnrefHeadInput } from './shared/vue.B8gXlHM7.js';
+export { createHeadCore } from 'unhead';
+export { createHead } from './client.js';
+export { createHead as createServerHead } from './server.js';
+import { d as distExports } from './shared/vue.DShwsPiO.js';
+import { ScriptInstance, UseScriptStatus, UseScriptOptions as UseScriptOptions$1, UseFunctionType } from 'unhead/legacy';
+export { UseFunctionType, resolveScriptKey } from 'unhead/legacy';
+import { Ref } from 'vue';
+import './shared/vue.DnywREVF.js';
+import 'unhead/client';
+import 'unhead/server';
+import '@unhead/shared';
+
+interface VueScriptInstance<T extends Record<symbol | string, any>> extends Omit<ScriptInstance<T>, 'status'> {
+    status: Ref<UseScriptStatus>;
+}
+type UseScriptInput = string | (distExports.MaybeComputedRefEntriesOnly<Omit<ScriptBase & DataKeys & SchemaAugmentations['script'], 'src'>> & {
+    src: string;
+});
+interface UseScriptOptions<T extends Record<symbol | string, any> = Record<string, any>> extends HeadEntryOptions, Pick<UseScriptOptions$1<T>, 'use' | 'eventContext' | 'beforeInit'> {
+    /**
+     * The trigger to load the script:
+     * - `undefined` | `client` - (Default) Load the script on the client when this js is loaded.
+     * - `manual` - Load the script manually by calling `$script.load()`, exists only on the client.
+     * - `Promise` - Load the script when the promise resolves, exists only on the client.
+     * - `Function` - Register a callback function to load the script, exists only on the client.
+     * - `server` - Have the script injected on the server.
+     * - `ref` - Load the script when the ref is true.
+     */
+    trigger?: UseScriptOptions$1['trigger'] | Ref<boolean>;
+}
+type UseScriptContext<T extends Record<symbol | string, any>> = Promise<T> & VueScriptInstance<T>;
+declare function useScript<T extends Record<symbol | string, any> = Record<symbol | string, any>>(_input: UseScriptInput, _options?: UseScriptOptions<T>): UseScriptContext<UseFunctionType<UseScriptOptions<T>, T>>;
+
+declare const CapoPlugin: () => _unhead_schema.HeadPluginInput;
+/**
+ * @deprecated Please switch to non-legacy version
+ */
+declare function setHeadInjectionHandler(handler: () => VueHeadClient<any> | undefined): void;
+declare function injectHead(): Unhead<_unhead_schema.Head<MergeHead>> | Unhead<_unhead_schema.Head<_unhead_schema.SchemaAugmentations>> | undefined;
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<UseHeadInput<T>> | void;
+declare function useHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<UseHeadSafeInput> | void;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHead<T extends MergeHead>(input: UseHeadInput<T>, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerHeadSafe(input: UseHeadSafeInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+declare function useServerSeoMeta(input: UseSeoMetaInput, options?: UseHeadOptions): ActiveHeadEntry<any> | void;
+
+export { CapoPlugin, type UseScriptContext, type UseScriptInput, type UseScriptOptions, type VueScriptInstance, injectHead, setHeadInjectionHandler, useHead, useHeadSafe, useScript, useSeoMeta, useServerHead, useServerHeadSafe, useServerSeoMeta };