vlite3 1.4.16 → 1.4.18

package/components/RichTextEditor/RichTextEditor.vue.js

@@ -1,9 +1,9 @@
 import { defineComponent as te, ref as v, shallowRef as ne, watch as oe, computed as h, onMounted as le, onUnmounted as ae, openBlock as C, createElementBlock as L, normalizeClass as re, toDisplayString as I, createCommentVNode as U, createElementVNode as w, createVNode as q, unref as a, normalizeStyle as ie } from "vue";
 /* empty css                         */
-import se from "./RichTextToolbar.vue.js";
-/* empty css                     */
-import de from "./RichTextLinkPopover.vue.js";
-/* empty css                         */
+import se from "./RichTextToolbar.vue2.js";
+/* empty css                    */
+import de from "./RichTextLinkPopover.vue2.js";
+/* empty css                        */
 import { useRichTextImageUpload as ue } from "./composables/useRichTextImageUpload.js";
 import { useRichTextLinks as ce } from "./composables/useRichTextLinks.js";
 const fe = ["aria-labelledby", "aria-describedby"], me = ["id", "for"], ve = { class: "rte-wrapper" }, ye = { class: "rte-body-wrap" }, ge = ["id", "contenteditable", "aria-label", "aria-readonly", "aria-disabled", "aria-invalid"], be = ["id"], Se = /* @__PURE__ */ te({

package/components/RichTextEditor/RichTextLinkPopover.vue3.js

@@ -1,5 +1,5 @@
-import o from "./RichTextLinkPopover.vue.js";
-/* empty css                         */
+import o from "./RichTextLinkPopover.vue2.js";
+/* empty css                        */
 export {
   o as default
 };

package/components/RichTextEditor/RichTextToolbar.vue3.js

@@ -1,5 +1,5 @@
-import o from "./RichTextToolbar.vue.js";
-/* empty css                     */
+import o from "./RichTextToolbar.vue2.js";
+/* empty css                    */
 export {
   o as default
 };

package/components/ScaleGenerator/ScaleGenerator.vue.d.ts

@@ -25,10 +25,10 @@ declare const __VLS_component: import('vue').DefineComponent<ScaleGeneratorProps
     maxWidth: number;
     contentClass: string;
     enabled: boolean;
+    scale: number | null;
     targetWidth: number;
     minScale: number;
     maxScale: number;
-    scale: number | null;
     isEditMode: boolean;
     horizontalAlign: ScaleHorizontalAlign;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {

package/components/Screen/ScreenFilter.vue.js

@@ -21,8 +21,8 @@ import "iconify-icon-picker/style.css";
 /* empty css                                 */
 /* empty css                 */
 /* empty css                                         */
-/* empty css                                     */
-/* empty css                                         */
+/* empty css                                    */
+/* empty css                                        */
 import "../../core/config.js";
 /* empty css                                    */
 /* empty css                      */

package/components/SeoProvider/SeoProvider.vue.d.ts

@@ -0,0 +1,70 @@
+import { SeoAdapter, SeoData, SeoPayload } from './types';
+type __VLS_Props = {
+    /**
+     * Site-level baseline. Anything here is used as a
+     * last-resort fallback before the normalizer returns
+     * empty strings. Usually mapped from the store's
+     * `pagesSeo.home`, `assets.openGraphImage`, `assets.logo`,
+     * `assets.favicon`, `storeName`, `customDomain`, etc.
+     */
+    defaults?: Partial<SeoData> | null;
+    /**
+     * Domain-level fallback. Typically resolved from
+     * `pagesSeo[pageType]` (the shop does this). Applied
+     * **after** `defaults` and **before** the active page's
+     * `useSeo` context.
+     */
+    fallback?: Partial<SeoData> | null;
+    /**
+     * Current page key. Defaults to whatever the most recent
+     * `useSeo({ pageType })` call supplied.
+     */
+    pageType?: string;
+    /**
+     * Global replacements merged into every `useSeo({…})` call.
+     * The shop uses this to inject `{{storeName}}` once.
+     */
+    globalReplacements?: Record<string, string | number | null | undefined>;
+    /**
+     * The actual emitter. Defaults to the DOM adapter so
+     * non-Nuxt hosts get a working document head out of the
+     * box. Nuxt apps should pass a Nuxt-specific adapter for
+     * SSR-safe meta.
+     */
+    adapter?: SeoAdapter | null;
+    /**
+     * Optional list of page-type → fallback `SeoData` entries
+     * baked in. Mirrors the `pagesSeo[pageType]` map from the
+     * shop. Provided as a convenience for hosts that don't
+     * compute the fallback themselves.
+     */
+    pageFallbacks?: Record<string, Partial<SeoData>> | null;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    update: (payload: SeoPayload) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onUpdate?: (payload: SeoPayload) => any;
+}>, {
+    fallback: Partial<SeoData> | null;
+    defaults: Partial<SeoData> | null;
+    pageType: string;
+    globalReplacements: Record<string, string | number | null | undefined>;
+    adapter: SeoAdapter | null;
+    pageFallbacks: Record<string, Partial<SeoData>> | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/SeoProvider/SeoProvider.vue.js

@@ -0,0 +1,52 @@
+import { defineComponent as m, ref as v, provide as g, computed as l, watch as y, renderSlot as b } from "vue";
+import { normalizeSeo as T } from "./normalizeSeo.js";
+import { createDomSeoAdapter as k } from "./domAdapter.js";
+import { SEO_CONTEXT_KEY as _ } from "../../composables/useSeo.js";
+const x = /* @__PURE__ */ m({
+  __name: "SeoProvider",
+  props: {
+    defaults: { default: null },
+    fallback: { default: null },
+    pageType: { default: void 0 },
+    globalReplacements: { default: void 0 },
+    adapter: { default: null },
+    pageFallbacks: { default: null }
+  },
+  emits: ["update"],
+  setup(p, { emit: s }) {
+    const o = p, i = s, n = v(/* @__PURE__ */ new Map());
+    g(_, n);
+    const d = l(() => o.adapter ?? k()), r = l(() => {
+      const t = Array.from(n.value.values());
+      if (t.length === 0) return null;
+      const a = {};
+      for (const e of t)
+        e.pageType && (a.pageType = e.pageType), e.title !== void 0 && (a.title = e.title), e.description !== void 0 && (a.description = e.description), e.keywords !== void 0 && (a.keywords = e.keywords), e.image !== void 0 && (a.image = e.image), e.canonicalUrl !== void 0 && (a.canonicalUrl = e.canonicalUrl), e.robots !== void 0 && (a.robots = e.robots), e.overrides && (a.overrides = { ...a.overrides ?? {}, ...e.overrides }), e.replacements && (a.replacements = { ...a.replacements ?? {}, ...e.replacements });
+      return a;
+    }), c = l(() => {
+      const t = r.value?.pageType ?? o.pageType ?? "home";
+      return o.pageFallbacks && o.pageFallbacks[t] ? o.pageFallbacks[t] : o.fallback ?? null;
+    }), u = l(
+      () => r.value?.pageType ?? o.pageType ?? "home"
+    ), f = l(() => {
+      const t = {
+        defaults: o.defaults,
+        context: r.value,
+        fallback: c.value,
+        pageType: u.value,
+        globalReplacements: o.globalReplacements
+      };
+      return T(t);
+    });
+    return y(
+      f,
+      (t) => {
+        d.value.apply(t), i("update", t);
+      },
+      { immediate: !0, deep: !0 }
+    ), (t, a) => b(t.$slots, "default");
+  }
+});
+export {
+  x as default
+};

package/components/SeoProvider/SeoProvider.vue2.js

@@ -0,0 +1,4 @@
+import f from "./SeoProvider.vue.js";
+export {
+  f as default
+};

package/components/SeoProvider/domAdapter.d.ts

@@ -0,0 +1,6 @@
+import { SeoAdapter } from './types';
+/**
+ * Build a DOM-mutating `SeoAdapter`. Idempotent — repeated
+ * calls just refresh the same set of tags.
+ */
+export declare const createDomSeoAdapter: () => SeoAdapter;

package/components/SeoProvider/domAdapter.js

@@ -0,0 +1,68 @@
+const m = () => typeof document < "u" && typeof document.head < "u", a = (o, s, e, t) => {
+  let i = o.head.querySelector(
+    `meta[${s}="${e}"]`
+  );
+  return i || (i = o.createElement("meta"), i.setAttribute(s, e), o.head.appendChild(i)), i.setAttribute("content", t), i;
+}, p = (o, s, e) => {
+  const t = o.head.querySelector(`meta[${s}="${e}"]`);
+  t && t.remove();
+}, g = (o, s, e, t = {}) => {
+  let i = o.head.querySelector(
+    `link[rel="${s}"]${t.sizes ? `[sizes="${t.sizes}"]` : ""}`
+  );
+  if (!i) {
+    i = o.createElement("link"), i.setAttribute("rel", s);
+    for (const [n, r] of Object.entries(t))
+      r && i.setAttribute(n, r);
+    o.head.appendChild(i);
+  }
+  return i.setAttribute("href", e), i;
+}, f = (o, s) => {
+  const e = o.head.querySelector(`link[rel="${s}"]`);
+  e && e.remove();
+}, u = () => {
+  const o = [], s = [];
+  return {
+    apply(e) {
+      if (!m()) return;
+      const t = document, i = e.titleTemplate ? e.titleTemplate.includes("%s") ? e.titleTemplate.replace("%s", e.title) : `${e.title} · ${e.titleTemplate}` : e.title;
+      i && (t.title = i);
+      const n = (r, c, l) => {
+        l && l.length > 0 ? (a(t, r, c, l), o.push({ attribute: r, key: c })) : p(t, r, c);
+      };
+      if (n("name", "description", e.description), n("name", "keywords", e.keywords), n("name", "robots", e.robots), n("property", "og:title", e.ogTitle), n("property", "og:description", e.ogDescription), n("property", "og:image", e.ogImage), n("property", "og:image:alt", e.ogImageAlt), n("property", "og:url", e.ogUrl), n("property", "og:type", e.ogType), n("property", "og:site_name", e.ogSiteName), n("property", "og:locale", e.ogLocale), n("name", "twitter:card", e.twitterCard), n("name", "twitter:title", e.twitterTitle), n("name", "twitter:description", e.twitterDescription), n("name", "twitter:image", e.twitterImage), n("name", "twitter:site", e.twitterSite), n("name", "twitter:creator", e.twitterCreator), e.canonicalUrl) {
+        let r = t.head.querySelector('link[rel="canonical"]');
+        r || (r = t.createElement("link"), r.setAttribute("rel", "canonical"), t.head.appendChild(r)), r.setAttribute("href", e.canonicalUrl), s.push({ rel: "canonical" });
+      } else
+        f(t, "canonical");
+      if (e.favicon && (g(t, "icon", e.favicon), s.push({ rel: "icon" })), e.jsonLd) {
+        let r = t.head.querySelector(
+          'script[type="application/ld+json"][data-vlite3-seo]'
+        );
+        r || (r = t.createElement("script"), r.setAttribute("type", "application/ld+json"), r.setAttribute("data-vlite3-seo", ""), t.head.appendChild(r)), r.textContent = JSON.stringify(e.jsonLd);
+      } else {
+        const r = t.head.querySelector(
+          'script[type="application/ld+json"][data-vlite3-seo]'
+        );
+        r && r.remove();
+      }
+    },
+    reset() {
+      if (!m()) return;
+      const e = document;
+      for (const { attribute: i, key: n } of o)
+        p(e, i, n);
+      o.length = 0;
+      for (const { rel: i } of s)
+        f(e, i);
+      s.length = 0;
+      const t = e.head.querySelector(
+        'script[type="application/ld+json"][data-vlite3-seo]'
+      );
+      t && t.remove();
+    }
+  };
+};
+export {
+  u as createDomSeoAdapter
+};

package/components/SeoProvider/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SeoProvider } from './SeoProvider.vue';
+export { normalizeSeo, noopSeoAdapter, replaceSeoTokens, type NormalizeSeoInput, type SeoReplacements, } from './normalizeSeo';
+export { createDomSeoAdapter } from './domAdapter';
+export type { SeoData, SeoPayload, SeoContextInput, SeoAdapter, } from './types';

package/components/SeoProvider/normalizeSeo.d.ts

@@ -0,0 +1,61 @@
+import { SeoAdapter, SeoContextInput, SeoData, SeoPayload } from './types';
+/**
+ * The two token replacement scopes. Global tokens are always
+ * applied (e.g. `{{storeName}}`); per-call tokens are supplied
+ * by the page (`useSeo({ replacements: { productName } })`).
+ */
+export type SeoReplacements = Record<string, string | number | null | undefined>;
+/**
+ * Replace `{{key}}` occurrences in `value` using the supplied
+ * replacements. Unknown / null / undefined keys collapse to an
+ * empty string (matches the existing `shop-data` behaviour so
+ * SEO strings with `{{productName}}` still resolve to a valid
+ * meta tag when the page is missing the data).
+ */
+export declare const replaceSeoTokens: (value: string | null | undefined, replacements?: SeoReplacements) => string;
+/**
+ * Inputs to the normalizer.
+ *
+ * `defaults` is the **store / site-level** baseline (logo,
+ * favicon, OG image, store name, …). `context` is the **page-
+ * level** overlay (`useSeo({ … })`). `resolveFallback` lets the
+ * caller plug in a domain-specific fallback (e.g. resolve
+ * `pagesSeo[pageType]` for the shop). `pageType` is the final
+ * string used in the payload (falls back to `'home'`).
+ */
+export interface NormalizeSeoInput {
+    defaults?: Partial<SeoData> | null;
+    context?: SeoContextInput | null;
+    fallback?: Partial<SeoData> | null;
+    pageType?: string;
+    /**
+     * Extra global replacements applied **before** per-context ones.
+     * Used by the shop layer to inject `{{storeName}}` automatically.
+     */
+    globalReplacements?: SeoReplacements;
+}
+/**
+ * Resolve the final SEO payload.
+ *
+ * Precedence (highest wins):
+ *
+ *   1. `context.overrides`     — raw, unrestricted fields from
+ *                                the page (`useSeo({ overrides })`).
+ *   2. `context.<field>`       — per-page explicit value.
+ *   3. `fallback.<field>`      — store / domain fallback
+ *                                (e.g. `pagesSeo[pageType]`).
+ *   4. `defaults.<field>`      — site-level baseline (logo, OG
+ *                                image, site name, …).
+ *
+ * Empty strings are treated as "use the next layer", matching
+ * the existing `resolveStoreSeo` contract. `null` is treated as
+ * "explicitly clear" and forces `null` in the output. (Useful
+ * for `noindex` overrides etc.)
+ */
+export declare const normalizeSeo: ({ defaults, context, fallback, pageType, globalReplacements, }: NormalizeSeoInput) => SeoPayload;
+/**
+ * No-op adapter. Useful as a fallback in tests / SSR-only
+ * contexts where SEO is already rendered by the host template
+ * and the generic provider should not touch the DOM.
+ */
+export declare const noopSeoAdapter: SeoAdapter;

package/components/SeoProvider/normalizeSeo.js

@@ -0,0 +1,195 @@
+const P = /\{\{(\w+)\}\}/g, q = (o, i = {}) => o ? o.replace(P, (e, n) => {
+  const d = i[n];
+  return d == null ? "" : String(d);
+}) : "", v = (...o) => {
+  for (const i of o)
+    if (typeof i == "string" && i.length > 0) return i;
+  return "";
+}, r = (...o) => {
+  for (const i of o) {
+    if (typeof i == "string")
+      return i.length > 0 ? i : null;
+    if (i === null) return null;
+  }
+  return null;
+}, B = (o, i) => ({
+  ...o ?? {},
+  ...i ?? {}
+}), F = ({
+  defaults: o,
+  context: i,
+  fallback: e,
+  pageType: n = "home",
+  globalReplacements: d
+}) => {
+  const c = B(
+    d,
+    i?.replacements
+  ), t = (O) => q(O, c), g = t(
+    v(
+      i?.title ?? void 0,
+      e?.title ?? void 0,
+      o?.title ?? void 0
+    )
+  ), m = t(
+    v(
+      i?.description ?? void 0,
+      e?.description ?? void 0,
+      o?.description ?? void 0
+    )
+  ), T = t(
+    v(
+      i?.keywords ?? void 0,
+      e?.keywords ?? void 0,
+      o?.keywords ?? void 0
+    )
+  ), p = r(
+    i?.canonicalUrl ?? void 0,
+    e?.canonicalUrl ?? void 0,
+    o?.canonicalUrl ?? void 0
+  ), S = r(
+    i?.robots ?? void 0,
+    e?.robots ?? void 0,
+    o?.robots ?? void 0
+  ), y = r(
+    i?.overrides?.favicon ?? void 0,
+    e?.favicon ?? void 0,
+    o?.favicon ?? void 0
+  ), s = r(
+    i?.image ?? void 0,
+    e?.image ?? void 0,
+    o?.image ?? void 0
+  ), I = t(
+    v(
+      i?.overrides?.ogTitle ?? void 0,
+      i?.title ?? void 0,
+      e?.ogTitle ?? void 0,
+      e?.title ?? void 0,
+      o?.ogTitle ?? void 0,
+      o?.title ?? void 0,
+      g
+    )
+  ), U = t(
+    v(
+      i?.overrides?.ogDescription ?? void 0,
+      i?.description ?? void 0,
+      e?.ogDescription ?? void 0,
+      e?.description ?? void 0,
+      o?.ogDescription ?? void 0,
+      o?.description ?? void 0,
+      m
+    )
+  ), L = r(
+    i?.overrides?.ogImage ?? void 0,
+    i?.image ?? void 0,
+    e?.ogImage ?? void 0,
+    e?.image ?? void 0,
+    o?.ogImage ?? void 0,
+    s
+  ), C = r(
+    i?.overrides?.ogImageAlt ?? void 0,
+    e?.ogImageAlt ?? void 0,
+    o?.ogImageAlt ?? void 0
+  ), D = r(
+    i?.overrides?.ogUrl ?? void 0,
+    i?.canonicalUrl ?? void 0,
+    e?.ogUrl ?? void 0,
+    e?.canonicalUrl ?? void 0,
+    o?.ogUrl ?? void 0,
+    o?.canonicalUrl ?? void 0,
+    p
+  ), N = r(
+    i?.overrides?.ogType ?? void 0,
+    e?.ogType ?? void 0,
+    o?.ogType ?? void 0,
+    n === "home" ? "website" : null
+  ), w = r(
+    i?.overrides?.ogSiteName ?? void 0,
+    e?.ogSiteName ?? void 0,
+    o?.ogSiteName ?? void 0,
+    o?.siteName ?? void 0
+  ), A = r(
+    i?.overrides?.ogLocale ?? void 0,
+    e?.ogLocale ?? void 0,
+    o?.ogLocale ?? void 0
+  ), h = r(
+    i?.overrides?.twitterCard ?? void 0,
+    e?.twitterCard ?? void 0,
+    o?.twitterCard ?? void 0,
+    s ? "summary_large_image" : "summary"
+  ), j = t(
+    v(
+      i?.overrides?.twitterTitle ?? void 0,
+      i?.title ?? void 0,
+      e?.twitterTitle ?? void 0,
+      e?.title ?? void 0,
+      o?.twitterTitle ?? void 0,
+      o?.title ?? void 0,
+      g
+    )
+  ), _ = t(
+    v(
+      i?.overrides?.twitterDescription ?? void 0,
+      i?.description ?? void 0,
+      e?.twitterDescription ?? void 0,
+      e?.description ?? void 0,
+      o?.twitterDescription ?? void 0,
+      o?.description ?? void 0,
+      m
+    )
+  ), E = r(
+    i?.overrides?.twitterImage ?? void 0,
+    i?.image ?? void 0,
+    e?.twitterImage ?? void 0,
+    e?.image ?? void 0,
+    o?.twitterImage ?? void 0,
+    s
+  ), R = r(
+    i?.overrides?.twitterSite ?? void 0,
+    e?.twitterSite ?? void 0,
+    o?.twitterSite ?? void 0
+  ), z = r(
+    i?.overrides?.twitterCreator ?? void 0,
+    e?.twitterCreator ?? void 0,
+    o?.twitterCreator ?? void 0
+  ), H = w ?? o?.siteName ?? null;
+  return {
+    pageType: n,
+    title: g,
+    titleTemplate: r(
+      i?.overrides?.titleTemplate ?? void 0,
+      e?.titleTemplate ?? void 0,
+      o?.titleTemplate ?? void 0
+    ),
+    description: m,
+    keywords: T,
+    canonicalUrl: p,
+    robots: S,
+    favicon: y,
+    image: s,
+    ogTitle: I,
+    ogDescription: U,
+    ogImage: L,
+    ogImageAlt: C,
+    ogUrl: D,
+    ogType: N,
+    ogSiteName: w,
+    ogLocale: A,
+    twitterCard: h,
+    twitterTitle: j,
+    twitterDescription: _,
+    twitterImage: E,
+    twitterSite: R,
+    twitterCreator: z,
+    siteName: H,
+    jsonLd: i?.overrides?.jsonLd ?? e?.jsonLd ?? o?.jsonLd ?? null
+  };
+}, G = {
+  apply: () => {
+  }
+};
+export {
+  G as noopSeoAdapter,
+  F as normalizeSeo,
+  q as replaceSeoTokens
+};

package/components/SeoProvider/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Generic, framework-agnostic SEO contract.
+ *
+ * The goal of this layer is to keep SEO **normalization** (turning
+ * "store config + route context + page-specific overrides" into one
+ * canonical object) reusable, while letting the **application**
+ * (Nuxt, plain Vue + DOM, server-rendered HTML, …) decide **how** the
+ * data is actually emitted to the document head.
+ *
+ * The split is:
+ *
+ *   1. `SeoData`         — the final shape every consumer (Nuxt
+ *                          `useSeoMeta`, Open Graph crawler, plain
+ *                          `<meta>` injection) understands.
+ *   2. `SeoAdapter`      — a tiny interface the host app provides
+ *                          to apply `SeoData` to the document. In
+ *                          Nuxt this wraps `useSeoMeta` / `useHead`;
+ *                          in a Vue admin preview it mutates
+ *                          `document.head` directly. The provider
+ *                          itself never imports Nuxt or DOM APIs.
+ *   3. `useSeo`          — a Vue composable for components that
+ *                          want to declare per-page SEO context
+ *                          (page type, dynamic replacements, image).
+ *   4. `SeoProvider`     — the Vue component that owns the
+ *                          lifecycle: it merges the current page
+ *                          context, runs the normalizer, and calls
+ *                          the adapter on every change.
+ *
+ * Keeping the layer UI-agnostic means `vlite3` can ship SEO support
+ * without forcing every consumer onto Nuxt — and tests can run with
+ * a stub adapter that just records the last call.
+ */
+/**
+ * Final, fully-resolved SEO payload.
+ *
+ * Every field is **already normalized** — null vs empty string,
+ * fallbacks applied, dynamic tokens replaced. Consumers (Nuxt
+ * `useSeoMeta`, DOM mutation, SSR string templating) should be
+ * able to read this object and emit `<meta>` tags without further
+ * computation.
+ */
+export interface SeoData {
+    /** Page title, ready to feed `useSeoMeta({ title })` / `<title>`. */
+    title: string;
+    /**
+     * Optional title template, e.g. `"%s · Acme"`. Falsy → leave the
+     * host app's default behaviour in place.
+     */
+    titleTemplate?: string | null;
+    /** Meta description, 1–2 sentences, crawler-friendly. */
+    description: string;
+    /** Comma- or space-separated keywords. Empty string if unset. */
+    keywords: string;
+    /** Absolute canonical URL. Falsy → host decides (use `useRequestURL` etc.). */
+    canonicalUrl?: string | null;
+    /** Robots directive, e.g. `"index, follow"` or `"noindex, nofollow"`. */
+    robots?: string | null;
+    /** Absolute favicon URL (`.ico` / `.png`). */
+    favicon?: string | null;
+    /** Absolute share-image URL (used for both OG and Twitter by default). */
+    image?: string | null;
+    ogTitle?: string | null;
+    ogDescription?: string | null;
+    ogImage?: string | null;
+    ogImageAlt?: string | null;
+    ogUrl?: string | null;
+    ogType?: string | null;
+    ogSiteName?: string | null;
+    ogLocale?: string | null;
+    twitterCard?: string | null;
+    twitterTitle?: string | null;
+    twitterDescription?: string | null;
+    twitterImage?: string | null;
+    twitterSite?: string | null;
+    twitterCreator?: string | null;
+    /**
+     * Site name used in OG `site_name`. Today the `ogSiteName` field
+     * carries the same value — `siteName` is exposed separately for
+     * adapters that prefer to render it as JSON-LD instead of a meta
+     * tag.
+     */
+    siteName?: string | null;
+    /** Free-form JSON-LD block. Adapter decides whether to render. */
+    jsonLd?: Record<string, unknown> | null;
+}
+/**
+ * The full, normalized context the `SeoProvider` hands to its
+ * adapter. Same as `SeoData` plus the canonical `pageType` key
+ * (used for analytics / structured data) and the unresolved raw
+ * inputs in case the adapter needs them.
+ */
+export interface SeoPayload extends SeoData {
+    /**
+     * Logical page key, e.g. `"home"`, `"product"`, `"collection"`.
+     * Adapter can use it for breadcrumb JSON-LD, custom `<meta>`,
+     * or just logging.
+     */
+    pageType: string;
+}
+/**
+ * Partial SEO data a page (or any component) can push into the
+ * provider via `useSeo({ … })`. Anything not supplied is filled by
+ * the provider's defaults / store-level fallback. Keys with `null`
+ * explicitly clear the inherited value.
+ */
+export interface SeoContextInput {
+    pageType?: string;
+    title?: string | null;
+    description?: string | null;
+    keywords?: string | null;
+    image?: string | null;
+    canonicalUrl?: string | null;
+    robots?: string | null;
+    /**
+     * Token replacements applied to every string field, e.g.
+     * `{ productName: 'Blue Tee' }` for `{{productName}}`.
+     */
+    replacements?: Record<string, string | number | null | undefined>;
+    /**
+     * Free-form extras merged on top of the resolved payload. Use
+     * sparingly — the canonical fields above are preferred.
+     */
+    overrides?: Partial<SeoData>;
+}
+/**
+ * The contract a host application (Nuxt app, Vue admin shell,
+ * SSR template) provides so the generic `SeoProvider` can emit
+ * the resolved SEO without depending on any specific framework.
+ *
+ * The adapter receives the final, normalized payload. The
+ * provider calls it whenever the merged SEO context changes.
+ */
+export interface SeoAdapter {
+    /**
+     * Apply the SEO payload to the document. Called reactively on
+     * every change; may be called multiple times during a session
+     * (e.g. on route change, then on data load).
+     */
+    apply(payload: SeoPayload): void;
+    /**
+     * Optional cleanup hook, e.g. clearing injected meta tags when
+     * the provider unmounts. The default implementation in
+     * `normalizeSeo` no-ops.
+     */
+    reset?(): void;
+}

package/components/ThemeToggle.vue.d.ts

@@ -10,7 +10,7 @@ declare function __VLS_template(): {
     slots: {
         default?(_: {
             toggleTheme: () => void;
-            theme: "light" | "dark";
+            theme: "dark" | "light";
         }): any;
     };
     refs: {};