orionplace-nuxt 0.7.2 → 0.7.3

package/README.md

@@ -502,11 +502,12 @@ server from the project root or explicitly point it at the configuration directo
 Every supplied page sets its title, description and keywords through
 `app/composables/useOrionplacePageSeo.ts` and Nuxt's `useSeoMeta()`.
 The homepage prefers `init.seo`, and category pages prefer their localized SEO
-fields. Empty values fall back to page-specific Russian or English copy in
+fields. Empty values fall back to page-specific Russian, Spanish or English copy in
 `app/utils/orionplace/pageSeo.ts`. Metadata updates with the current locale and
 route data. The homepage retains additional backend Open Graph and Twitter tags
 through `useHead()`. Profile and logout pages remain excluded from indexing;
 search results retain their `noindex, follow` policy.
+Pages with a canonical address also link the same page in the other storefront languages (`hreflang`) and set `og:type` and `og:locale`; a journal article adds its publication date (`article:published_time`) and schema.org `BlogPosting` data. The store icon (`logos.ico`) is the page's `<link rel="icon">`. An unknown `?locale` opens the default language.
 
 ## Documentation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-nuxt",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Nuxt 4 storefront for your Orionplace marketplace: setup CLI, server API gateway, typed store and ready-made catalog, cart, checkout and account components in English and Russian, plus an Android app build.",
   "type": "module",
   "license": "MIT",

package/src/favicon-handler.mjs

@@ -0,0 +1,12 @@
+import { defineEventHandler, setResponseStatus } from 'h3';
+
+/**
+ * /favicon.ico without a file in public/: Nitro would answer it with a
+ * placeholder text that is not an image. The storefront's icon is the
+ * <link rel="icon"> from App Load (logos.ico), so this address answers 404,
+ * as in the React and Svelte storefronts. A public/favicon.ico still wins.
+ */
+export default defineEventHandler((event) => {
+  setResponseStatus(event, 404);
+  return '';
+});

package/src/module.mjs

@@ -81,6 +81,7 @@ export default defineNuxtModule({
       addServerHandler({ route: '/robots.txt', method: 'get', handler: resolve(directory, 'seo.mjs') });
       addServerHandler({ route: '/sitemap.xml', method: 'get', handler: resolve(directory, 'seo.mjs') });
     }
+    addServerHandler({ route: '/favicon.ico', method: 'get', handler: resolve(import.meta.dirname, 'favicon-handler.mjs') });
     addServerHandler({ middleware: true, handler: resolve(directory, 'domain.mjs') });
     addServerPlugin(resolve(import.meta.dirname, 'asset-loading-plugin.mjs'));
   },

package/templates/app/app.vue

@@ -6,13 +6,17 @@
   import OrionplaceThemeProvider from '@/components/orionplace/theme/OrionplaceThemeProvider.vue';
   import { useOrionplaceTheme } from '@/composables/useOrionplaceTheme';
   import { storefrontPageError } from '@/composables/useOrionplaceMissingPage';
+  import { storefrontIconLinks } from '@/utils/orionplace/pageSeo';
 
   const store    = useOrionplaceStore();
   const route    = useRoute();
   const { mode } = useOrionplaceTheme();
 
+  // The store's icon from the admin panel (logos.ico) for browser tabs and
+  // search results; a page without it keeps the browser default.
   useHead(() => ({
     htmlAttrs: { lang: store.localeCode },
+    link: storefrontIconLinks(store.init?.logos?.ico),
   }));
 
   // The middleware opens the 503 error page during navigation. A refresh that

package/templates/app/composables/useOrionplaceAppLoad.ts

@@ -7,7 +7,11 @@ import type {
   AppLoadResult,
 } from '@/interfaces/orionplace/transport';
 import { useOrionplaceApi } from '@/composables/useOrionplaceApi';
-import { appLoadResult, inspectAppLoad } from '@/utils/orionplaceAppLoad';
+import {
+  appLoadRejectedLocale,
+  appLoadResult,
+  inspectAppLoad,
+} from '@/utils/orionplaceAppLoad';
 
 /** Transport and explicit actions. Calling this accessor does not start a request. */
 export function useOrionplaceAppLoad() {
@@ -51,6 +55,11 @@ export function useOrionplaceAppLoad() {
     // or CSRF token) is relayed to the browser by the shared API transport,
     // which also sends it with the later requests of the same render.
     const failure = inspectAppLoad(received.body, received.status);
+    // An address with a language the storefront does not have (`?locale=xx`)
+    // opens in the storefront's default language instead of the 503 page.
+    if (failure && locale && appLoadRejectedLocale(failure)) {
+      return request(signal);
+    }
     if (failure) {
       throw createError({
         message: 'Marketplace initialization failed.',

package/templates/app/composables/useOrionplacePageSeo.ts

@@ -1,9 +1,13 @@
 import { computed, toValue } from 'vue';
 import type { MaybeRefOrGetter } from 'vue';
 import { useHead, useRequestHeader, useRoute, useSeoMeta } from '#imports';
+import { useOrionplaceStore } from '@/stores/orionplace';
 import {
   storefrontAbsoluteUrl,
+  storefrontAlternateLinks,
   storefrontCanonicalUrl,
+  storefrontOpenGraphLocale,
+  storefrontOpenGraphType,
   storefrontPageMetadata,
   storefrontPublicOrigin,
 } from '@/utils/orionplace/pageSeo';
@@ -19,6 +23,9 @@ export function useOrionplacePageSeo(
     keywords?: MaybeRefOrGetter<string | undefined>;
     robots?: MaybeRefOrGetter<string | undefined>;
     image?: MaybeRefOrGetter<string | undefined>;
+    /** A journal article's dates (ISO 8601) for article:published_time. */
+    published?: MaybeRefOrGetter<string | undefined>;
+    modified?: MaybeRefOrGetter<string | undefined>;
     /**
      * The page's schema.org data (a record page, e.g. the product), built
      * from its canonical address and the visitor's origin. A page without a
@@ -28,6 +35,7 @@ export function useOrionplacePageSeo(
   } = {},
 ) {
   const route     = useRoute();
+  const store     = useOrionplaceStore();
   // The address the visitor used: the proxy's host during the server render.
   const origin    = import.meta.server
     ? storefrontPublicOrigin(
@@ -63,7 +71,18 @@ export function useOrionplacePageSeo(
     ogDescription: () => metadata.value.description,
     ogImage: () => storefrontAbsoluteUrl(toValue(values.image), origin),
     ogUrl: () => canonical.value,
+    ogType: () => storefrontOpenGraphType(toValue(page)),
+    ogLocale: () => storefrontOpenGraphLocale(toValue(locale)),
+    articlePublishedTime: () => toValue(values.published),
+    articleModifiedTime: () => toValue(values.modified),
   };
+  // The page in the storefront's other languages, beside the canonical one.
+  const alternates = computed(() =>
+    storefrontAlternateLinks(
+      canonical.value,
+      Object.keys(store.init?.locale ?? {}),
+    ),
+  );
   const structured = computed(() =>
     canonical.value && values.structuredData
       ? structuredDataJson(values.structuredData(canonical.value, origin))
@@ -73,7 +92,15 @@ export function useOrionplacePageSeo(
   useHead({
     link: () =>
       canonical.value
-        ? [{ key: 'canonical', rel: 'canonical', href: canonical.value }]
+        ? [
+            { key: 'canonical', rel: 'canonical', href: canonical.value },
+            ...alternates.value.map((alternate) => ({
+              key: `alternate-${alternate.hreflang}`,
+              rel: 'alternate',
+              hreflang: alternate.hreflang,
+              href: alternate.href,
+            })),
+          ]
         : [],
     script: () =>
       structured.value

package/templates/app/pages/journal/[id].vue

@@ -7,6 +7,11 @@
   import { useOrionplaceStorefront } from '@/composables/useOrionplaceStorefront';
   import { useOrionplaceServerData } from '@/composables/useOrionplaceServerData';
   import { requestBlogPost } from '@/utils/orionplace/blogLayout';
+  import {
+    storefrontAbsoluteUrl,
+    storefrontArticleData,
+    storefrontIsoDate,
+  } from '@/utils/orionplace/pageSeo';
   import {
     getAvailableNestedValueFromObject,
     plainText,
@@ -74,6 +79,37 @@
         ),
       ).slice(0, 160),
     image: () => cover.value,
+    published: () => storefrontIsoDate(post.value?.date_created?.date),
+    modified: () =>
+      storefrontIsoDate(post.value?.date_updated?.date) ??
+      storefrontIsoDate(post.value?.date_created?.date),
+    // The article as schema.org BlogPosting, with the store as its author.
+    structuredData: (canonical, origin) =>
+      post.value
+        ? storefrontArticleData({
+            canonical,
+            origin,
+            headline:
+              getAvailableNestedValueFromObject(
+                post.value.locale,
+                store.localeCode,
+                'post_title',
+              ) ?? '',
+            description:
+              plainText(
+                getAvailableNestedValueFromObject(
+                  post.value.locale,
+                  store.localeCode,
+                  'post_preview_text',
+                ),
+              ).slice(0, 160) || undefined,
+            image: storefrontAbsoluteUrl(cover.value, origin),
+            published: storefrontIsoDate(post.value.date_created?.date),
+            modified: storefrontIsoDate(post.value.date_updated?.date),
+            locale: store.localeCode,
+            storeName: store.init?.contact?.company_name,
+          })
+        : undefined,
   });
 
   // An invalid ID, or an article that blog_posts_get does not return,

package/templates/app/utils/orionplace/pageSeo.ts

@@ -263,17 +263,157 @@ const pageCopy = {
       'error, store',
     ],
   },
+  es: {
+    tariffs: [
+      'Planes de suscripción',
+      'Precios por periodo, periodos de prueba y opciones de cada plan.',
+      'planes, suscripciones, prueba',
+    ],
+    tariff: [
+      'Plan de suscripción',
+      'Descripción, funciones, periodos y opciones de un plan de suscripción.',
+      'plan, suscripción, periodo',
+    ],
+    subscriptions: [
+      'Mis suscripciones',
+      'Fechas de las suscripciones y renovación automática.',
+      'suscripciones, cuenta',
+    ],
+    sellers: ['Vendedores', 'Vendedores y sus productos.', 'vendedores, productos'],
+    stores: [
+      'Tiendas',
+      'Direcciones, contactos y horarios de las tiendas.',
+      'tiendas, direcciones',
+    ],
+    catalog: ['Catálogo', 'Categorías de productos de la tienda.', 'catálogo, categorías'],
+    activity: [
+      'Mi actividad',
+      'Códigos promocionales, reseñas e historial de accesos del cliente.',
+      'cuenta, códigos promocionales, reseñas, accesos',
+    ],
+    promo: [
+      'Productos del código promocional',
+      'Productos de la tienda a los que se aplica la oferta del código promocional.',
+      'código promocional, oferta, productos',
+    ],
+    wishlist: [
+      'Favoritos',
+      'Productos guardados y avisos de disponibilidad.',
+      'favoritos, productos',
+    ],
+    contact: [
+      'Contacto',
+      'Datos de contacto de la empresa y formulario de mensajes de la tienda.',
+      'contacto, mensaje',
+    ],
+    privacy: [
+      'Política de privacidad',
+      'Qué datos recibe la tienda, para qué, a quién los transmite y qué cookies usa el sitio.',
+      'datos personales, privacidad, cookies',
+    ],
+    unsubscribe: [
+      'Preferencias de correo',
+      'Darse de baja de los correos de la tienda.',
+      'correos, baja',
+    ],
+    tickets: [
+      'Soporte',
+      'Conversaciones del usuario con el soporte.',
+      'soporte, conversaciones',
+    ],
+    orders: [
+      'Mis pedidos',
+      'Historial de pedidos y artículos comprados.',
+      'pedidos, compras',
+    ],
+    cart: ['Carrito', 'Artículos y pago del pedido.', 'carrito, pago'],
+    addresses: [
+      'Mis direcciones',
+      'Direcciones de entrega guardadas.',
+      'direcciones, entrega',
+    ],
+    wallet: [
+      'Monedero y pagos',
+      'Saldo e historial de pagos.',
+      'monedero, pagos',
+    ],
+    home: [
+      'Tienda',
+      'Categorías y productos de la tienda.',
+      'tienda, catálogo, productos',
+    ],
+    browse: [
+      'Resultados de búsqueda',
+      'Productos que coinciden con la búsqueda y los filtros elegidos.',
+      'búsqueda de productos, filtros, catálogo',
+    ],
+    featured: [
+      'Destacados',
+      'Productos de las categorías que el cliente ha buscado en la tienda.',
+      'recomendaciones, productos, filtros',
+    ],
+    category: [
+      'Categoría de productos',
+      'Productos y filtros disponibles de la categoría elegida.',
+      'categoría, productos, filtros',
+    ],
+    journal: [
+      'Revista',
+      'Publicaciones de la tienda con títulos, resúmenes y tiempo de lectura.',
+      'revista, publicaciones, artículos',
+    ],
+    publication: [
+      'Publicación de la revista',
+      'Un artículo de la revista de la tienda.',
+      'revista, publicación, artículo',
+    ],
+    product: [
+      'Ficha de producto',
+      'Descripción, precio, variantes y disponibilidad del producto.',
+      'producto, precio, disponibilidad',
+    ],
+    manufacturers: [
+      'Fabricantes',
+      'Fabricantes de la tienda con logotipos e índice alfabético.',
+      'fabricantes, marcas, índice alfabético',
+    ],
+    profile: [
+      'Perfil personal',
+      'Datos personales, correo, notificaciones y contraseña de la cuenta.',
+      'perfil, cuenta, ajustes',
+    ],
+    logout: [
+      'Cerrar sesión',
+      'Fin de la sesión y vuelta a la página principal.',
+      'cuenta, cerrar sesión, sesión',
+    ],
+    notFound: [
+      'Página no encontrada',
+      'No hay ninguna página de la tienda en esta dirección.',
+      'página no encontrada, 404',
+    ],
+    error: [
+      'Algo salió mal',
+      'No se pudo mostrar la página de la tienda.',
+      'error, tienda',
+    ],
+  },
 } as const;
 
 export type StorefrontSeoPage = keyof typeof pageCopy.en;
 
+/** The page copy for a storefront language; languages without one use English. */
+function storefrontCopyLanguage(locale: string): keyof typeof pageCopy {
+  const language = locale.toLowerCase().split(/[-_]/)[0];
+  return language === 'ru' || language === 'es' ? language : 'en';
+}
+
 export function storefrontPageMetadata(
   page: StorefrontSeoPage,
   locale: string,
   values: { title?: string; description?: string; keywords?: string } = {},
 ) {
-  const copy  =
-    pageCopy[locale.toLowerCase().startsWith('ru') ? 'ru' : 'en'][page];
+  const copy  = pageCopy[storefrontCopyLanguage(locale)][page];
   const title = plainText(values.title ?? '') || copy[0];
 
   return {
@@ -350,3 +490,122 @@ export function storefrontCanonicalUrl(
   }
   return url.toString();
 }
+
+/** og:type of a page: a product and a journal article have their own kinds. */
+export function storefrontOpenGraphType(
+  page: StorefrontSeoPage,
+): 'product' | 'article' | 'website' {
+  if (page === 'product') {
+    return 'product';
+  }
+  return page === 'publication' ? 'article' : 'website';
+}
+
+const openGraphRegions: Record<string, string> = {
+  de: 'de_DE',
+  en: 'en_US',
+  es: 'es_ES',
+  fr: 'fr_FR',
+  it: 'it_IT',
+  kk: 'kk_KZ',
+  pl: 'pl_PL',
+  pt: 'pt_PT',
+  ru: 'ru_RU',
+  tr: 'tr_TR',
+  uk: 'uk_UA',
+  zh: 'zh_CN',
+};
+
+/** og:locale (`language_TERRITORY`) of a storefront language, when it is known. */
+export function storefrontOpenGraphLocale(locale: string): string | undefined {
+  return openGraphRegions[locale.toLowerCase().split(/[-_]/)[0]!];
+}
+
+/**
+ * The same page in every storefront language (hreflang), for a page with a
+ * canonical address: the canonical address with each language's `?locale=`,
+ * as the sitemap lists them. Search engines that ignore the sitemap's
+ * language links (Yandex) read these. A single language gives none.
+ */
+export function storefrontAlternateLinks(
+  canonical: string | undefined,
+  locales: string[],
+): { hreflang: string; href: string }[] {
+  const codes = [
+    ...new Set(
+      locales
+        .map((code) => code.trim())
+        .filter((code) => /^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/i.test(code)),
+    ),
+  ];
+  if (!canonical || codes.length < 2) {
+    return [];
+  }
+  return codes.map((code) => {
+    const url = new URL(canonical);
+    url.searchParams.set('locale', code);
+    return { hreflang: code, href: url.toString() };
+  });
+}
+
+/**
+ * A backend date (`d.m.Y`, e.g. `22.09.2026`) as an ISO 8601 date
+ * (`2026-09-22`); anything else gives `undefined`. A date without a time
+ * cannot disagree with the visible date in another time zone.
+ */
+export function storefrontIsoDate(
+  value: string | null | undefined,
+): string | undefined {
+  const match = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec((value ?? '').trim());
+  return match ? `${match[3]}-${match[2]}-${match[1]}` : undefined;
+}
+
+/**
+ * schema.org BlogPosting of a journal article (Google "Article" structured
+ * data): headline, cover, dates, and the store as author and publisher.
+ */
+export function storefrontArticleData(input: {
+  canonical: string;
+  origin: string;
+  headline: string;
+  description?: string;
+  image?: string;
+  published?: string;
+  modified?: string;
+  locale: string;
+  storeName?: string;
+}): Record<string, unknown> {
+  const store = {
+    '@type': 'Organization',
+    name: input.storeName || new URL(input.origin).hostname,
+    url: `${input.origin}/`,
+  };
+  const modified = input.modified || input.published;
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'BlogPosting',
+    '@id': `${input.canonical}#article`,
+    mainEntityOfPage: input.canonical,
+    url: input.canonical,
+    headline: input.headline.slice(0, 110),
+    ...(input.description ? { description: input.description } : {}),
+    ...(input.image ? { image: [input.image] } : {}),
+    ...(input.published ? { datePublished: input.published } : {}),
+    ...(modified ? { dateModified: modified } : {}),
+    inLanguage: input.locale,
+    author: store,
+    publisher: store,
+  };
+}
+
+/**
+ * The store's icon (App Load `logos.ico`) as `<link rel="icon">` tags: search
+ * engines read the icon from the home page. Only a complete http(s) address
+ * is used; the type is left out, so it cannot disagree with the file.
+ */
+export function storefrontIconLinks(
+  icon: string | null | undefined,
+): { key: string; rel: string; href: string }[] {
+  const href = storefrontAbsoluteUrl(icon, '');
+  return href ? [{ key: 'icon', rel: 'icon', href }] : [];
+}

package/templates/app/utils/orionplaceAppLoad.ts

@@ -71,3 +71,13 @@ export function appLoadResult(
     loadedAt: new Date().toISOString(),
   };
 }
+
+/**
+ * Whether App Load refused the request's language (`?lang=` of a language the
+ * storefront does not have): the backend answers it with field errors and
+ * HTTP 452. The language is the only client value App Load reads, so the
+ * storefront loads again without it.
+ */
+export function appLoadRejectedLocale(failure: AppLoadFailure): boolean {
+  return failure.kind === 'validation' || failure.httpStatus === 452;
+}