@unhead/react 2.0.0-alpha.16 → 2.0.0-alpha.9

package/dist/client.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+const React = require('react');
+const client = require('unhead/client');
+const context = require('./shared/react.BtC4o9fJ.cjs');
+const ReactReactivityPlugin = require('./shared/react.CBAhBov_.cjs');
+require('@unhead/shared');
+
+function createHead(options = {}) {
+  const head = client.createHead({
+    domOptions: {
+      render: client.createDebouncedFn(() => client.renderDOMHead(head), (fn) => setTimeout(fn, 0))
+    },
+    ...options,
+    plugins: [
+      ...options.plugins || [],
+      ReactReactivityPlugin.ReactReactivityPlugin
+    ]
+  });
+  return head;
+}
+function UnheadProvider({ children, head }) {
+  return React.createElement(context.UnheadContext.Provider, { value: head || createHead() }, children);
+}
+
+exports.UnheadProvider = UnheadProvider;
+exports.createHead = createHead;
+Object.prototype.hasOwnProperty.call(client, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: client['__proto__']
+  });
+
+Object.keys(client).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = client[k];
+});

package/dist/client.d.cts

@@ -0,0 +1,14 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
+export * from 'unhead/client';
+import { R as ReactUnhead } from './shared/react.rDLQhCrM.cjs';
+
+declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): ReactUnhead<T>;
+declare function UnheadProvider({ children, head }: {
+    children: ReactNode;
+    head?: ReturnType<typeof createHead>;
+}): react.FunctionComponentElement<react.ProviderProps<_unhead_schema.Unhead<any> | null>>;
+
+export { UnheadProvider, createHead };

package/dist/client.d.mts

@@ -1,14 +1,14 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import * as unhead_types from 'unhead/types';
-import { MergeHead, CreateClientHeadOptions } from 'unhead/types';
-export { renderDOMHead } from 'unhead/client';
-import { R as ReactUnhead } from './shared/react.Cz8ob63p.mjs';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
+export * from 'unhead/client';
+import { R as ReactUnhead } from './shared/react.rDLQhCrM.mjs';
 
-declare function createHead<T extends MergeHead>(options?: Omit<CreateClientHeadOptions, 'propResolvers'>): ReactUnhead<T>;
+declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): ReactUnhead<T>;
 declare function UnheadProvider({ children, head }: {
     children: ReactNode;
     head?: ReturnType<typeof createHead>;
-}): react.FunctionComponentElement<react.ProviderProps<unhead_types.Unhead<any> | null>>;
+}): react.FunctionComponentElement<react.ProviderProps<_unhead_schema.Unhead<any> | null>>;
 
 export { UnheadProvider, createHead };

package/dist/client.d.ts

@@ -1,14 +1,14 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import * as unhead_types from 'unhead/types';
-import { MergeHead, CreateClientHeadOptions } from 'unhead/types';
-export { renderDOMHead } from 'unhead/client';
-import { R as ReactUnhead } from './shared/react.Cz8ob63p.js';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
+export * from 'unhead/client';
+import { R as ReactUnhead } from './shared/react.rDLQhCrM.js';
 
-declare function createHead<T extends MergeHead>(options?: Omit<CreateClientHeadOptions, 'propResolvers'>): ReactUnhead<T>;
+declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): ReactUnhead<T>;
 declare function UnheadProvider({ children, head }: {
     children: ReactNode;
     head?: ReturnType<typeof createHead>;
-}): react.FunctionComponentElement<react.ProviderProps<unhead_types.Unhead<any> | null>>;
+}): react.FunctionComponentElement<react.ProviderProps<_unhead_schema.Unhead<any> | null>>;
 
 export { UnheadProvider, createHead };

package/dist/client.mjs

@@ -1,7 +1,9 @@
 import { createElement } from 'react';
 import { createHead as createHead$1, createDebouncedFn, renderDOMHead } from 'unhead/client';
-export { renderDOMHead } from 'unhead/client';
+export * from 'unhead/client';
 import { U as UnheadContext } from './shared/react.DF9T1fqs.mjs';
+import { R as ReactReactivityPlugin } from './shared/react.D-xyXevh.mjs';
+import '@unhead/shared';
 
 function createHead(options = {}) {
   const head = createHead$1({
@@ -9,13 +11,9 @@ function createHead(options = {}) {
       render: createDebouncedFn(() => renderDOMHead(head), (fn) => setTimeout(fn, 0))
     },
     ...options,
-    propResolvers: [
-      (_, r) => {
-        if (typeof r === "object" && "current" in r) {
-          return r.current;
-        }
-        return r;
-      }
+    plugins: [
+      ...options.plugins || [],
+      ReactReactivityPlugin
     ]
   });
   return head;

package/dist/index.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const shared = require('@unhead/shared');
+const React = require('react');
+const context = require('./shared/react.BtC4o9fJ.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const React__default = /*#__PURE__*/_interopDefaultCompat(React);
+
+const hookImports = {
+  "@unhead/vue": ["useUnhead", ...shared.composableNames]
+};
+
+function useUnhead() {
+  const instance = React.useContext(context.UnheadContext);
+  if (!instance) {
+    throw new Error("useHead() was called without provide context.");
+  }
+  return instance;
+}
+function useHead(input, options = {}) {
+  const head = options.head || useUnhead();
+  const entry = head.push(input, options);
+  React.useEffect(() => {
+    entry.patch(input);
+  }, [input]);
+  React.useEffect(() => {
+    return () => {
+      entry?.dispose();
+    };
+  }, []);
+  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,
+    // we need to input the meta so the reactivity will be resolved
+    // @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
+      };
+    }
+  });
+}
+
+const Head = ({ children, titleTemplate }) => {
+  const headRef = React.useRef(null);
+  const head = useUnhead();
+  React.useEffect(() => {
+    return () => {
+      if (headRef.current?.dispose()) {
+        headRef.current.dispose();
+      }
+      headRef.current = null;
+    };
+  }, []);
+  React.useEffect(() => {
+    const input = {
+      titleTemplate
+    };
+    const elements = React__default.Children.toArray(children).filter(React__default.isValidElement);
+    elements.forEach((element) => {
+      const { type, props } = element;
+      if (!shared.ValidHeadTags.has(type)) {
+        return;
+      }
+      const data = { ...typeof props === "object" ? props : {} };
+      if (shared.TagsWithInnerContent.has(type) && data.children) {
+        data[type === "script" ? "innerHTML" : "textContent"] = Array.isArray(data.children) ? data.children.map(String).join("") : data.children;
+      }
+      delete data.children;
+      if (shared.HasElementTags.has(type)) {
+        input[type] = input[type] || [];
+        input[type].push(data);
+      } else {
+        input[type] = data;
+      }
+    });
+    if (!headRef.current) {
+      headRef.current = head.push(input);
+    } else {
+      headRef.current.patch(input);
+    }
+  }, [children, titleTemplate]);
+  return null;
+};
+
+exports.Head = Head;
+exports.hookImports = hookImports;
+exports.useHead = useHead;
+exports.useHeadSafe = useHeadSafe;
+exports.useSeoMeta = useSeoMeta;
+exports.useUnhead = useUnhead;

package/dist/index.d.cts

@@ -0,0 +1,21 @@
+import react__default, { ReactNode } from 'react';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe } from '@unhead/schema';
+import { U as UseHeadInput, a as UseSeoMetaInput } from './shared/react.rDLQhCrM.cjs';
+
+declare const hookImports: {
+    '@unhead/vue': string[];
+};
+
+interface HeadProps {
+    children: ReactNode;
+    titleTemplate?: string;
+}
+declare const Head: react__default.FC<HeadProps>;
+
+declare function useUnhead(): _unhead_schema.Unhead<any>;
+declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
+declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
+declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;
+
+export { Head, hookImports, useHead, useHeadSafe, useSeoMeta, useUnhead };

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import react__default, { ReactNode } from 'react';
-import * as unhead_types from 'unhead/types';
-import { MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe } from 'unhead/types';
-import { U as UseHeadInput, a as UseSeoMetaInput } from './shared/react.Cz8ob63p.mjs';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe } from '@unhead/schema';
+import { U as UseHeadInput, a as UseSeoMetaInput } from './shared/react.rDLQhCrM.mjs';
 
 declare const hookImports: {
     '@unhead/vue': string[];
@@ -13,7 +13,7 @@ interface HeadProps {
 }
 declare const Head: react__default.FC<HeadProps>;
 
-declare function useUnhead(): unhead_types.Unhead<any>;
+declare function useUnhead(): _unhead_schema.Unhead<any>;
 declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
 declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
 declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import react__default, { ReactNode } from 'react';
-import * as unhead_types from 'unhead/types';
-import { MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe } from 'unhead/types';
-import { U as UseHeadInput, a as UseSeoMetaInput } from './shared/react.Cz8ob63p.js';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, HeadEntryOptions, ActiveHeadEntry, HeadSafe } from '@unhead/schema';
+import { U as UseHeadInput, a as UseSeoMetaInput } from './shared/react.rDLQhCrM.js';
 
 declare const hookImports: {
     '@unhead/vue': string[];
@@ -13,7 +13,7 @@ interface HeadProps {
 }
 declare const Head: react__default.FC<HeadProps>;
 
-declare function useUnhead(): unhead_types.Unhead<any>;
+declare function useUnhead(): _unhead_schema.Unhead<any>;
 declare function useHead<T extends MergeHead>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>>;
 declare function useHeadSafe(input: HeadSafe, options?: HeadEntryOptions): ActiveHeadEntry<HeadSafe>;
 declare function useSeoMeta(input: UseSeoMetaInput, options?: HeadEntryOptions): ActiveHeadEntry<any>;

package/dist/index.mjs

@@ -1,18 +1,9 @@
+import { composableNames, whitelistSafeInput, unpackMeta, ValidHeadTags, TagsWithInnerContent, HasElementTags } from '@unhead/shared';
 import React, { useContext, useEffect, useRef } from 'react';
-import { ValidHeadTags, TagsWithInnerContent, HasElementTags } from 'unhead/utils';
-import { SafeInputPlugin, FlatMetaPlugin } from 'unhead/plugins';
 import { U as UnheadContext } from './shared/react.DF9T1fqs.mjs';
 
 const hookImports = {
-  "@unhead/vue": [
-    "useUnhead",
-    "useHead",
-    "useSeoMeta",
-    "useHeadSafe",
-    "useServerHead",
-    "useServerSeoMeta",
-    "useServerHeadSafe"
-  ]
+  "@unhead/vue": ["useUnhead", ...composableNames]
 };
 
 function useUnhead() {
@@ -36,20 +27,28 @@ function useHead(input, options = {}) {
   return entry;
 }
 function useHeadSafe(input, options = {}) {
-  const head = options.head || useUnhead();
-  head.use(SafeInputPlugin);
-  options._safe = true;
-  return useHead(input, options);
+  return useHead(input, { ...options, transform: whitelistSafeInput });
 }
-function useSeoMeta(input, options = {}) {
-  const head = options.head || useUnhead();
-  head.use(FlatMetaPlugin);
+function useSeoMeta(input, options) {
   const { title, titleTemplate, ...meta } = input;
   return useHead({
     title,
     titleTemplate,
+    // we need to input the meta so the reactivity will be resolved
+    // @ts-expect-error runtime type
     _flatMeta: meta
-  }, options);
+  }, {
+    ...options,
+    transform(t) {
+      const meta2 = unpackMeta({ ...t._flatMeta });
+      delete t._flatMeta;
+      return {
+        // @ts-expect-error runtime type
+        ...t,
+        meta: meta2
+      };
+    }
+  });
 }
 
 const Head = ({ children, titleTemplate }) => {

package/dist/server.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const React = require('react');
+const server = require('unhead/server');
+const context = require('./shared/react.BtC4o9fJ.cjs');
+const ReactReactivityPlugin = require('./shared/react.CBAhBov_.cjs');
+require('@unhead/shared');
+
+function createHead(options = {}) {
+  return server.createHead({
+    ...options,
+    plugins: [
+      ...options.plugins || [],
+      ReactReactivityPlugin.ReactReactivityPlugin
+    ]
+  });
+}
+function UnheadProvider({ children, value }) {
+  return React.createElement(context.UnheadContext.Provider, { value }, children);
+}
+
+exports.UnheadProvider = UnheadProvider;
+exports.createHead = createHead;
+Object.prototype.hasOwnProperty.call(server, '__proto__') &&
+  !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+  Object.defineProperty(exports, '__proto__', {
+    enumerable: true,
+    value: server['__proto__']
+  });
+
+Object.keys(server).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = server[k];
+});

package/dist/server.d.cts

@@ -0,0 +1,14 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
+export * from 'unhead/server';
+import { R as ReactUnhead } from './shared/react.rDLQhCrM.cjs';
+
+declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): ReactUnhead<T>;
+declare function UnheadProvider({ children, value }: {
+    children: ReactNode;
+    value: ReturnType<typeof createHead>;
+}): react.FunctionComponentElement<react.ProviderProps<_unhead_schema.Unhead<any> | null>>;
+
+export { UnheadProvider, createHead };

package/dist/server.d.mts

@@ -1,14 +1,14 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import * as unhead_types from 'unhead/types';
-import { MergeHead, CreateServerHeadOptions } from 'unhead/types';
-export { SSRHeadPayload, extractUnheadInputFromHtml, renderSSRHead, transformHtmlTemplate } from 'unhead/server';
-import { R as ReactUnhead } from './shared/react.Cz8ob63p.mjs';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
+export * from 'unhead/server';
+import { R as ReactUnhead } from './shared/react.rDLQhCrM.mjs';
 
-declare function createHead<T extends MergeHead>(options?: Omit<CreateServerHeadOptions, 'propResolvers'>): ReactUnhead<T>;
+declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): ReactUnhead<T>;
 declare function UnheadProvider({ children, value }: {
     children: ReactNode;
     value: ReturnType<typeof createHead>;
-}): react.FunctionComponentElement<react.ProviderProps<unhead_types.Unhead<any> | null>>;
+}): react.FunctionComponentElement<react.ProviderProps<_unhead_schema.Unhead<any> | null>>;
 
 export { UnheadProvider, createHead };

package/dist/server.d.ts

@@ -1,14 +1,14 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import * as unhead_types from 'unhead/types';
-import { MergeHead, CreateServerHeadOptions } from 'unhead/types';
-export { SSRHeadPayload, extractUnheadInputFromHtml, renderSSRHead, transformHtmlTemplate } from 'unhead/server';
-import { R as ReactUnhead } from './shared/react.Cz8ob63p.js';
+import * as _unhead_schema from '@unhead/schema';
+import { MergeHead, CreateClientHeadOptions } from '@unhead/schema';
+export * from 'unhead/server';
+import { R as ReactUnhead } from './shared/react.rDLQhCrM.js';
 
-declare function createHead<T extends MergeHead>(options?: Omit<CreateServerHeadOptions, 'propResolvers'>): ReactUnhead<T>;
+declare function createHead<T extends MergeHead>(options?: CreateClientHeadOptions): ReactUnhead<T>;
 declare function UnheadProvider({ children, value }: {
     children: ReactNode;
     value: ReturnType<typeof createHead>;
-}): react.FunctionComponentElement<react.ProviderProps<unhead_types.Unhead<any> | null>>;
+}): react.FunctionComponentElement<react.ProviderProps<_unhead_schema.Unhead<any> | null>>;
 
 export { UnheadProvider, createHead };

package/dist/server.mjs

@@ -1,18 +1,16 @@
 import { createElement } from 'react';
 import { createHead as createHead$1 } from 'unhead/server';
-export { extractUnheadInputFromHtml, renderSSRHead, transformHtmlTemplate } from 'unhead/server';
+export * from 'unhead/server';
 import { U as UnheadContext } from './shared/react.DF9T1fqs.mjs';
+import { R as ReactReactivityPlugin } from './shared/react.D-xyXevh.mjs';
+import '@unhead/shared';
 
 function createHead(options = {}) {
   return createHead$1({
     ...options,
-    propResolvers: [
-      (_, r) => {
-        if (typeof r === "object" && "current" in r) {
-          return r.current;
-        }
-        return r;
-      }
+    plugins: [
+      ...options.plugins || [],
+      ReactReactivityPlugin
     ]
   });
 }

package/dist/shared/react.BtC4o9fJ.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const React = require('react');
+
+const UnheadContext = React.createContext(null);
+
+exports.UnheadContext = UnheadContext;

package/dist/shared/react.CBAhBov_.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+const shared = require('@unhead/shared');
+const React = require('react');
+
+function resolveUnref(r) {
+  if (typeof r === "function") {
+    return r();
+  }
+  if (typeof r === "object" && "current" in r) {
+    return r.current;
+  }
+  return r;
+}
+function resolveUnrefHeadInput(ref) {
+  if (typeof ref === "string" || ref instanceof Promise || ref instanceof Date || ref instanceof RegExp)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r));
+  if (typeof root === "object" && !React.isValidElement(root)) {
+    const resolved = {};
+    for (const k in root) {
+      if (!Object.prototype.hasOwnProperty.call(root, k)) {
+        continue;
+      }
+      if (k === "titleTemplate" || k[0] === "o" && k[1] === "n") {
+        resolved[k] = resolveUnref(root[k]);
+        continue;
+      }
+      resolved[k] = resolveUnrefHeadInput(root[k]);
+    }
+    return resolved;
+  }
+  return root;
+}
+
+const ReactReactivityPlugin = shared.defineHeadPlugin({
+  hooks: {
+    "entries:resolve": (ctx) => {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+exports.ReactReactivityPlugin = ReactReactivityPlugin;

package/dist/shared/react.D-xyXevh.mjs

@@ -0,0 +1,47 @@
+import { defineHeadPlugin } from '@unhead/shared';
+import { isValidElement } from 'react';
+
+function resolveUnref(r) {
+  if (typeof r === "function") {
+    return r();
+  }
+  if (typeof r === "object" && "current" in r) {
+    return r.current;
+  }
+  return r;
+}
+function resolveUnrefHeadInput(ref) {
+  if (typeof ref === "string" || ref instanceof Promise || ref instanceof Date || ref instanceof RegExp)
+    return ref;
+  const root = resolveUnref(ref);
+  if (!ref || !root)
+    return root;
+  if (Array.isArray(root))
+    return root.map((r) => resolveUnrefHeadInput(r));
+  if (typeof root === "object" && !isValidElement(root)) {
+    const resolved = {};
+    for (const k in root) {
+      if (!Object.prototype.hasOwnProperty.call(root, k)) {
+        continue;
+      }
+      if (k === "titleTemplate" || k[0] === "o" && k[1] === "n") {
+        resolved[k] = resolveUnref(root[k]);
+        continue;
+      }
+      resolved[k] = resolveUnrefHeadInput(root[k]);
+    }
+    return resolved;
+  }
+  return root;
+}
+
+const ReactReactivityPlugin = defineHeadPlugin({
+  hooks: {
+    "entries:resolve": (ctx) => {
+      for (const entry of ctx.entries)
+        entry.resolvedInput = resolveUnrefHeadInput(entry.input);
+    }
+  }
+});
+
+export { ReactReactivityPlugin as R };

package/dist/shared/{react.Cz8ob63p.d.mts → react.rDLQhCrM.d.cts}

@@ -1,5 +1,5 @@
+import { Falsey, BaseHtmlAttr, MaybeArray, BaseBodyAttr, ResolvableValues, SchemaAugmentations, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, DefinedValueOrEmptyObject, LinkBase, DataKeys, MaybeEventFnHandlers, HttpEventAttributes, BaseMeta, Style as Style$1, ScriptBase, Noscript as Noscript$1, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
 import { RefObject } from 'react';
-import { Falsey, BaseHtmlAttr, MaybeArray, BaseBodyAttr, SchemaAugmentations, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, DefinedValueOrEmptyObject, LinkBase, DataKeys, MaybeEventFnHandlers, HttpEventAttributes, BaseMeta, Style as Style$1, ScriptBase, Noscript as Noscript$1, BodyEvents, MergeHead, MetaFlatInput, HeadEntryOptions, Unhead } from 'unhead/types';
 
 type MaybeComputedRef<T> = T | (() => T) | RefObject<T>;
 type ResolvableArray<T> = MaybeComputedRef<MaybeComputedRef<T>[]>;
@@ -29,7 +29,7 @@ interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
      */
     style?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<string | boolean>>;
 }
-type Title = MaybeComputedRef<number | string | Falsey> | ResolvableProperties<({
+type Title = MaybeComputedRef<number | string | Falsey> | ResolvableValues<({
     textContent: string;
 } & SchemaAugmentations['title'])>;
 type TitleTemplate = TitleTemplate$1 | RefObject<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
@@ -112,10 +112,6 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
      */
     bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
-    /**
-     * @internal
-     */
-    _flatMeta?: ResolvableProperties<MetaFlatInput>;
 }
 type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
     head?: ReactUnhead<any>;

package/dist/shared/{react.Cz8ob63p.d.ts → react.rDLQhCrM.d.mts}

@@ -1,5 +1,5 @@
+import { Falsey, BaseHtmlAttr, MaybeArray, BaseBodyAttr, ResolvableValues, SchemaAugmentations, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, DefinedValueOrEmptyObject, LinkBase, DataKeys, MaybeEventFnHandlers, HttpEventAttributes, BaseMeta, Style as Style$1, ScriptBase, Noscript as Noscript$1, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
 import { RefObject } from 'react';
-import { Falsey, BaseHtmlAttr, MaybeArray, BaseBodyAttr, SchemaAugmentations, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, DefinedValueOrEmptyObject, LinkBase, DataKeys, MaybeEventFnHandlers, HttpEventAttributes, BaseMeta, Style as Style$1, ScriptBase, Noscript as Noscript$1, BodyEvents, MergeHead, MetaFlatInput, HeadEntryOptions, Unhead } from 'unhead/types';
 
 type MaybeComputedRef<T> = T | (() => T) | RefObject<T>;
 type ResolvableArray<T> = MaybeComputedRef<MaybeComputedRef<T>[]>;
@@ -29,7 +29,7 @@ interface BodyAttr extends Omit<BaseBodyAttr, 'class' | 'style'> {
      */
     style?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<string | boolean>>;
 }
-type Title = MaybeComputedRef<number | string | Falsey> | ResolvableProperties<({
+type Title = MaybeComputedRef<number | string | Falsey> | ResolvableValues<({
     textContent: string;
 } & SchemaAugmentations['title'])>;
 type TitleTemplate = TitleTemplate$1 | RefObject<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
@@ -112,10 +112,6 @@ interface ReactiveHead<E extends MergeHead = MergeHead> {
      * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
      */
     bodyAttrs?: BodyAttributes<E['bodyAttrs']>;
-    /**
-     * @internal
-     */
-    _flatMeta?: ResolvableProperties<MetaFlatInput>;
 }
 type UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
     head?: ReactUnhead<any>;

package/dist/shared/react.rDLQhCrM.d.ts

@@ -0,0 +1,126 @@
+import { Falsey, BaseHtmlAttr, MaybeArray, BaseBodyAttr, ResolvableValues, SchemaAugmentations, TitleTemplate as TitleTemplate$1, EntryAugmentation, Base as Base$1, DefinedValueOrEmptyObject, LinkBase, DataKeys, MaybeEventFnHandlers, HttpEventAttributes, BaseMeta, Style as Style$1, ScriptBase, Noscript as Noscript$1, BodyEvents, MergeHead, HeadEntryOptions, MetaFlatInput, Unhead } from '@unhead/schema';
+import { RefObject } from 'react';
+
+type MaybeComputedRef<T> = T | (() => T) | RefObject<T>;
+type ResolvableArray<T> = MaybeComputedRef<MaybeComputedRef<T>[]>;
+type ResolvableProperties<T> = {
+    [key in keyof T]?: MaybeComputedRef<T[key] | Falsey>;
+};
+
+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' | 'style'> {
+    /**
+     * 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>>;
+    /**
+     * 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
+     */
+    style?: MaybeArray<MaybeComputedRef<string>> | Record<string, MaybeComputedRef<string | boolean>>;
+}
+type Title = MaybeComputedRef<number | string | Falsey> | ResolvableValues<({
+    textContent: string;
+} & SchemaAugmentations['title'])>;
+type TitleTemplate = TitleTemplate$1 | RefObject<TitleTemplate$1> | ((title?: string) => TitleTemplate$1);
+type Base<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<Base$1 & SchemaAugmentations['base']> & DefinedValueOrEmptyObject<E>;
+type Link<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<LinkBase & DataKeys & SchemaAugmentations['link']> & MaybeEventFnHandlers<HttpEventAttributes> & DefinedValueOrEmptyObject<E>;
+type Meta<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<BaseMeta & DataKeys & SchemaAugmentations['meta']> & DefinedValueOrEmptyObject<E>;
+type Style<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<Style$1 & DataKeys & SchemaAugmentations['style']> & DefinedValueOrEmptyObject<E>;
+type Script<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<ScriptBase & DataKeys & SchemaAugmentations['script']> & MaybeEventFnHandlers<HttpEventAttributes> & DefinedValueOrEmptyObject<E>;
+type Noscript<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<Noscript$1 & DataKeys & SchemaAugmentations['noscript']> & DefinedValueOrEmptyObject<E>;
+type HtmlAttributes<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<HtmlAttr & DataKeys & SchemaAugmentations['htmlAttrs']> & DefinedValueOrEmptyObject<E>;
+type BodyAttributes<E extends EntryAugmentation = Record<string, any>> = ResolvableProperties<BodyAttr & DataKeys & SchemaAugmentations['bodyAttrs']> & MaybeEventFnHandlers<BodyEvents> & DefinedValueOrEmptyObject<E>;
+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;
+    /**
+     * Generate the title from a template.
+     */
+    titleTemplate?: TitleTemplate;
+    /**
+     * Variables used to substitute in the title and meta content.
+     */
+    templateParams?: ResolvableArray<{
+        separator?: '|' | '-' | '·' | string;
+    } & Record<string, null | string | ResolvableArray<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?: ResolvableArray<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?: ResolvableArray<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?: ResolvableArray<(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?: ResolvableArray<(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?: ResolvableArray<(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 UseHeadOptions = Omit<HeadEntryOptions, 'head'> & {
+    head?: ReactUnhead<any>;
+};
+type UseHeadInput<T extends MergeHead = Record<string, any>> = MaybeComputedRef<ReactiveHead<T>>;
+type UseSeoMetaInput = ResolvableProperties<MetaFlatInput> & {
+    title?: ReactiveHead['title'];
+    titleTemplate?: ReactiveHead['titleTemplate'];
+};
+type ReactUnhead<T extends MergeHead> = Unhead<MaybeComputedRef<ReactiveHead<T>>>;
+
+export type { BodyAttr as B, HtmlAttr as H, Link as L, MaybeComputedRef as M, Noscript as N, ReactUnhead as R, Style as S, Title as T, UseHeadInput as U, UseSeoMetaInput as a, ReactiveHead as b, ResolvableArray as c, TitleTemplate as d, Base as e, Meta as f, Script as g, HtmlAttributes as h, BodyAttributes as i, UseHeadOptions as j, ResolvableProperties as k };

package/dist/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.d.cts

@@ -0,0 +1,17 @@
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from '@unhead/schema';
+export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from '@unhead/schema';
+import { b as ReactiveHead, c as ResolvableArray, M as MaybeComputedRef } from './shared/react.rDLQhCrM.cjs';
+export { e as Base, B as BodyAttr, i as BodyAttributes, H as HtmlAttr, h as HtmlAttributes, L as Link, f as Meta, N as Noscript, R as ReactUnhead, k as ResolvableProperties, g as Script, S as Style, T as Title, d as TitleTemplate, U as UseHeadInput, j as UseHeadOptions, a as UseSeoMetaInput } from './shared/react.rDLQhCrM.cjs';
+import 'react';
+
+interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {
+    meta?: ResolvableArray<SafeMeta>[];
+    link?: ResolvableArray<SafeLink>[];
+    noscript?: ResolvableArray<SafeNoscript>[];
+    script?: ResolvableArray<SafeScript>[];
+    htmlAttrs?: ResolvableArray<SafeHtmlAttr>;
+    bodyAttrs?: ResolvableArray<SafeBodyAttr>;
+}
+type UseHeadSafeInput = MaybeComputedRef<HeadSafe>;
+
+export { type HeadSafe, MaybeComputedRef, ReactiveHead, ResolvableArray, type UseHeadSafeInput };

package/dist/types.d.mts

@@ -1,7 +1,7 @@
-import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from 'unhead/types';
-export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from 'unhead/types';
-import { b as ReactiveHead, c as ResolvableArray, M as MaybeComputedRef } from './shared/react.Cz8ob63p.mjs';
-export { e as Base, B as BodyAttr, i as BodyAttributes, H as HtmlAttr, h as HtmlAttributes, L as Link, f as Meta, N as Noscript, R as ReactUnhead, k as ResolvableProperties, g as Script, S as Style, T as Title, d as TitleTemplate, U as UseHeadInput, j as UseHeadOptions, a as UseSeoMetaInput } from './shared/react.Cz8ob63p.mjs';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from '@unhead/schema';
+export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from '@unhead/schema';
+import { b as ReactiveHead, c as ResolvableArray, M as MaybeComputedRef } from './shared/react.rDLQhCrM.mjs';
+export { e as Base, B as BodyAttr, i as BodyAttributes, H as HtmlAttr, h as HtmlAttributes, L as Link, f as Meta, N as Noscript, R as ReactUnhead, k as ResolvableProperties, g as Script, S as Style, T as Title, d as TitleTemplate, U as UseHeadInput, j as UseHeadOptions, a as UseSeoMetaInput } from './shared/react.rDLQhCrM.mjs';
 import 'react';
 
 interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from 'unhead/types';
-export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from 'unhead/types';
-import { b as ReactiveHead, c as ResolvableArray, M as MaybeComputedRef } from './shared/react.Cz8ob63p.js';
-export { e as Base, B as BodyAttr, i as BodyAttributes, H as HtmlAttr, h as HtmlAttributes, L as Link, f as Meta, N as Noscript, R as ReactUnhead, k as ResolvableProperties, g as Script, S as Style, T as Title, d as TitleTemplate, U as UseHeadInput, j as UseHeadOptions, a as UseSeoMetaInput } from './shared/react.Cz8ob63p.js';
+import { SafeMeta, SafeLink, SafeNoscript, SafeScript, SafeHtmlAttr, SafeBodyAttr } from '@unhead/schema';
+export { ActiveHeadEntry, Head, HeadEntryOptions, HeadTag, MergeHead, ResolvedHead, Unhead } from '@unhead/schema';
+import { b as ReactiveHead, c as ResolvableArray, M as MaybeComputedRef } from './shared/react.rDLQhCrM.js';
+export { e as Base, B as BodyAttr, i as BodyAttributes, H as HtmlAttr, h as HtmlAttributes, L as Link, f as Meta, N as Noscript, R as ReactUnhead, k as ResolvableProperties, g as Script, S as Style, T as Title, d as TitleTemplate, U as UseHeadInput, j as UseHeadOptions, a as UseSeoMetaInput } from './shared/react.rDLQhCrM.js';
 import 'react';
 
 interface HeadSafe extends Pick<ReactiveHead, 'title' | 'titleTemplate' | 'templateParams'> {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unhead/react",
   "type": "module",
-  "version": "2.0.0-alpha.16",
+  "version": "2.0.0-alpha.9",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/harlan-zw",
@@ -18,22 +18,26 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     },
     "./server": {
       "types": "./dist/server.d.ts",
-      "import": "./dist/server.mjs"
+      "import": "./dist/server.mjs",
+      "require": "./dist/server.cjs"
     },
     "./client": {
       "types": "./dist/client.d.ts",
-      "import": "./dist/client.mjs"
+      "import": "./dist/client.mjs",
+      "require": "./dist/client.cjs"
     },
     "./types": {
       "types": "./dist/types.d.ts",
-      "import": "./dist/types.mjs"
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.cjs"
     }
   },
-  "main": "dist/index.mjs",
+  "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "typesVersions": {
@@ -64,7 +68,9 @@
     ]
   },
   "dependencies": {
-    "unhead": "2.0.0-alpha.16"
+    "@unhead/schema": "2.0.0-alpha.9",
+    "@unhead/shared": "2.0.0-alpha.9",
+    "unhead": "2.0.0-alpha.9"
   },
   "devDependencies": {
     "@testing-library/react": "^16.2.0",