vlite3 1.4.31 → 1.4.32

package/components/SeoProvider/structuredData.d.ts

@@ -0,0 +1,100 @@
+export declare const SEO_STRUCTURED_DATA_CONTEXT: "https://schema.org";
+/** Generic JSON-LD object accepted by `SeoData.jsonLd`. */
+export type SeoStructuredData = Record<string, unknown>;
+export type SeoStructuredDataReference = SeoStructuredData | {
+    '@id': string;
+} | string;
+export interface StructuredDataFactoryOptions {
+    context?: string | null;
+    id?: string | null;
+}
+type StructuredDataProperties = object;
+/** Typed identity helper for consumer-defined schema.org objects. */
+export declare const defineStructuredData: <T extends SeoStructuredData>(value: T) => T;
+/** Generic factory for schema.org types not covered by a dedicated helper. */
+export declare const createStructuredData: <T extends StructuredDataProperties>(type: string, properties: T, options?: StructuredDataFactoryOptions) => SeoStructuredData & T;
+export interface ArticleStructuredDataInput {
+    headline: string;
+    description?: string | null;
+    image?: string | readonly string[] | null;
+    datePublished?: string | null;
+    dateModified?: string | null;
+    url?: string | null;
+    author?: SeoStructuredDataReference | readonly SeoStructuredDataReference[] | null;
+    publisher?: SeoStructuredDataReference | null;
+    mainEntityOfPage?: SeoStructuredDataReference | null;
+}
+export interface ArticleStructuredData extends SeoStructuredData {
+    '@type': 'Article';
+    headline: string;
+}
+export declare const createArticleStructuredData: (input: ArticleStructuredDataInput, options?: StructuredDataFactoryOptions) => ArticleStructuredData;
+export interface PersonStructuredDataInput {
+    name: string;
+    jobTitle?: string | null;
+    description?: string | null;
+    image?: string | null;
+    url?: string | null;
+    sameAs?: readonly string[] | null;
+}
+export interface PersonStructuredData extends SeoStructuredData {
+    '@type': 'Person';
+    name: string;
+}
+export declare const createPersonStructuredData: (input: PersonStructuredDataInput, options?: StructuredDataFactoryOptions) => PersonStructuredData;
+export interface CreativeWorkStructuredDataInput {
+    name: string;
+    description?: string | null;
+    image?: string | readonly string[] | null;
+    url?: string | null;
+    creator?: SeoStructuredDataReference | null;
+    dateCreated?: string | null;
+    dateModified?: string | null;
+}
+export interface CreativeWorkStructuredData extends SeoStructuredData {
+    '@type': 'CreativeWork';
+    name: string;
+}
+export declare const createCreativeWorkStructuredData: (input: CreativeWorkStructuredDataInput, options?: StructuredDataFactoryOptions) => CreativeWorkStructuredData;
+export interface WebPageStructuredDataInput {
+    name: string;
+    description?: string | null;
+    url?: string | null;
+    image?: string | null;
+    isPartOf?: SeoStructuredDataReference | null;
+    breadcrumb?: SeoStructuredDataReference | null;
+}
+export interface WebPageStructuredData extends SeoStructuredData {
+    '@type': 'WebPage';
+    name: string;
+}
+export declare const createWebPageStructuredData: (input: WebPageStructuredDataInput, options?: StructuredDataFactoryOptions) => WebPageStructuredData;
+export interface OrganizationStructuredDataInput {
+    name: string;
+    description?: string | null;
+    url?: string | null;
+    logo?: string | SeoStructuredDataReference | null;
+    image?: string | null;
+    sameAs?: readonly string[] | null;
+}
+export interface OrganizationStructuredData extends SeoStructuredData {
+    '@type': 'Organization';
+    name: string;
+}
+export declare const createOrganizationStructuredData: (input: OrganizationStructuredDataInput, options?: StructuredDataFactoryOptions) => OrganizationStructuredData;
+export interface BreadcrumbStructuredDataItem {
+    name: string;
+    url?: string | null;
+}
+export interface BreadcrumbListItemStructuredData extends SeoStructuredData {
+    '@type': 'ListItem';
+    position: number;
+    name: string;
+    item?: string;
+}
+export interface BreadcrumbListStructuredData extends SeoStructuredData {
+    '@type': 'BreadcrumbList';
+    itemListElement: BreadcrumbListItemStructuredData[];
+}
+export declare const createBreadcrumbListStructuredData: (items: readonly BreadcrumbStructuredDataItem[], options?: StructuredDataFactoryOptions) => BreadcrumbListStructuredData;
+export {};

package/components/SeoProvider/structuredData.js

@@ -0,0 +1,33 @@
+const o = "https://schema.org", n = (t) => {
+  const e = {};
+  for (const [r, c] of Object.entries(t))
+    c != null && (e[r] = c);
+  return e;
+}, u = (t) => t, a = (t, e, r = {}) => ({
+  ...r.context === null ? {} : { "@context": r.context ?? o },
+  "@type": t,
+  ...r.id ? { "@id": r.id } : {},
+  ...n(e)
+}), i = (t, e) => a("Article", t, e), s = (t, e) => a("Person", t, e), d = (t, e) => a("CreativeWork", t, e), m = (t, e) => a("WebPage", t, e), D = (t, e) => a("Organization", t, e), S = (t, e) => a(
+  "BreadcrumbList",
+  {
+    itemListElement: t.map((r, c) => n({
+      "@type": "ListItem",
+      position: c + 1,
+      name: r.name,
+      item: r.url
+    }))
+  },
+  e
+);
+export {
+  o as SEO_STRUCTURED_DATA_CONTEXT,
+  i as createArticleStructuredData,
+  S as createBreadcrumbListStructuredData,
+  d as createCreativeWorkStructuredData,
+  D as createOrganizationStructuredData,
+  s as createPersonStructuredData,
+  a as createStructuredData,
+  m as createWebPageStructuredData,
+  u as defineStructuredData
+};

package/components/SeoProvider/types.d.ts

@@ -1,63 +1,40 @@
+import { SeoStructuredData } from './structuredData';
+/** Keywords accepted by authored SEO inputs. */
+export type SeoKeywordsInput = string | readonly string[];
 /**
- * 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.
+ * Structured robots input. Each defined boolean is normalized to its
+ * positive or negative directive; extra directives are appended once.
  */
+export interface SeoRobotsDirectives {
+    index?: boolean;
+    follow?: boolean;
+    archive?: boolean;
+    imageIndex?: boolean;
+    translate?: boolean;
+    additional?: readonly string[];
+}
 /**
- * Final, fully-resolved SEO payload.
+ * `true` means `index, follow`; `false` means `noindex, nofollow`.
+ * Objects allow the two directives to be controlled independently.
+ */
+export type SeoRobotsInput = string | boolean | SeoRobotsDirectives;
+/** One authored JSON-LD block or an ordered list of blocks. */
+export type SeoJsonLdInput = SeoStructuredData | readonly SeoStructuredData[];
+/**
+ * Generic, framework-agnostic SEO input contract.
  *
- * 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.
+ * This shape is accepted by provider defaults, page fallbacks, and
+ * `useSeo`. The normalizer converts ergonomic inputs such as keyword
+ * arrays, robot flags, and one-or-many JSON-LD into `SeoPayload`.
  */
 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.
-     */
+    title: string | null;
     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.). */
+    description: string | null;
+    keywords: SeoKeywordsInput | null;
     canonicalUrl?: string | null;
-    /** Robots directive, e.g. `"index, follow"` or `"noindex, nofollow"`. */
-    robots?: string | null;
-    /** Absolute favicon URL (`.ico` / `.png`). */
+    robots?: SeoRobotsInput | null;
     favicon?: string | null;
-    /** Absolute share-image URL (used for both OG and Twitter by default). */
     image?: string | null;
     ogTitle?: string | null;
     ogDescription?: string | null;
@@ -71,76 +48,37 @@ export interface SeoData {
     twitterTitle?: string | null;
     twitterDescription?: string | null;
     twitterImage?: string | null;
+    twitterImageAlt?: 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;
+    jsonLd?: SeoJsonLdInput | 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.
-     */
+/** Final normalized payload passed to an adapter. */
+export type SeoPayload = Omit<SeoData, 'title' | 'description' | 'keywords' | 'robots' | 'jsonLd'> & {
     pageType: string;
-}
+    title: string;
+    description: string;
+    keywords: string;
+    robots: string | null;
+    jsonLd: SeoStructuredData[];
+};
 /**
- * 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.
+ * Page-level input registered through `useSeo`.
+ *
+ * Direct fields are preferred. `overrides` remains available for
+ * compatibility and always has the highest precedence. Empty values fall
+ * through; `null` explicitly clears an inherited value.
  */
-export interface SeoContextInput {
+export interface SeoContextInput extends Partial<SeoData> {
     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>;
+    /** Opt in to rich-text/entity sanitization for textual SEO fields. */
+    sanitizeText?: boolean;
 }
-/**
- * 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.
- */
+/** Host-specific output adapter (DOM, Nuxt, SSR template, and so on). */
 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/Tabes/Tabes.vue.js

@@ -1,7 +1,7 @@
 import o from "./Tabes.vue2.js";
 /* empty css           */
 import t from "../../_virtual/_plugin-vue_export-helper.js";
-const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-cdf6b045"]]);
+const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-813948ec"]]);
 export {
   m as default
 };