orionplace-nuxt 0.7.2 → 0.7.4

package/README.md

@@ -502,11 +502,14 @@ 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.
+
+List pages (journal, categories, stores) link their previous and next pages as real links (`?page=2`). Each later page has its own canonical address and a title with its page number; a journal page past the last one answers 404.
 
 ## Documentation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-nuxt",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "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/components/orionplace/blog/StorefrontJournal.vue

@@ -618,6 +618,7 @@
           <StorefrontPagination
             :pagination="pagination"
             :pending="Boolean(task.state.pending)"
+            linked
             @change="changePage"
           />
         </div>

package/templates/app/components/orionplace/search/ProductSearchResults.vue

@@ -1,10 +1,12 @@
 <script setup lang="ts">
   import { computed, ref, watch } from 'vue';
+  import { useRoute } from '#imports';
   import { useOrionplaceStableHeight } from '@/composables/useOrionplaceStableHeight';
   import { useOrionplaceBrowseStore } from '@/stores/orionplaceBrowse';
   import { useOrionplaceSelectionsStore } from '@/stores/orionplaceSelections';
   import { browseLabels } from '@/utils/orionplace/browseLabels';
   import { hasSearchFilters } from '@/utils/orionplace/searchFilters';
+  import { storefrontPageHref } from '@/utils/orionplace/pageSeo';
   import SearchFilters from '@/components/orionplace/search/SearchFilters.vue';
   import ProductGroup from '@/components/orionplace/products/ProductGroup.vue';
   import type { ProductFacetSelection } from '@/interfaces/orionplace/products/IProductSearchFacets';
@@ -95,6 +97,38 @@
     }
   });
   const labels = computed(() => browseLabels(selectionStore.localeCode));
+  // Every list of this component keeps its page in the address (`?page=`),
+  // so previous and next are links search engines follow; a click changes
+  // the page in place.
+  const route        = useRoute();
+  const search       = computed(
+    () => new URL(route.fullPath, 'http://storefront').search,
+  );
+  const previousHref = computed(() =>
+    !props.pending && props.page > 1
+      ? storefrontPageHref(route.path, search.value, props.page - 1)
+      : undefined,
+  );
+  const nextHref     = computed(() =>
+    !props.pending && !props.failed && props.hasNext
+      ? storefrontPageHref(route.path, search.value, props.page + 1)
+      : undefined,
+  );
+
+  // A link opened in a new tab or window keeps its default.
+  function followPage(event: MouseEvent, value: number) {
+    if (
+      event.button !== 0 ||
+      event.metaKey ||
+      event.ctrlKey ||
+      event.shiftKey ||
+      event.altKey
+    ) {
+      return;
+    }
+    event.preventDefault();
+    emit('changePage', value);
+  }
   const filtersOpen = ref(false);
   const hasFilters = computed(() =>
     hasSearchFilters(
@@ -410,22 +444,29 @@
           "
           data-search-pagination
         >
-          <button
-            type="button"
-            :disabled="pending || page === 1"
+          <component
+            :is="previousHref ? 'a' : 'button'"
+            :type="previousHref ? undefined : 'button'"
+            :href="previousHref"
+            :rel="previousHref ? 'prev' : undefined"
+            :disabled="previousHref ? undefined : pending || page === 1"
             class="
               inline-flex h-11 items-center justify-center px-5
               [font-family:inherit] text-xs font-medium uppercase tracking-[0.08em]
-              text-orionplace-text
+              text-orionplace-text no-underline
               border border-solid border-orionplace-border bg-transparent
               cursor-pointer outline-none
               hover:border-orionplace-text focus-visible:border-orionplace-text
               disabled:cursor-not-allowed disabled:opacity-40
             "
-            @click="emit('changePage', page - 1)"
+            @click="
+              previousHref
+                ? followPage($event, page - 1)
+                : emit('changePage', page - 1)
+            "
           >
             ← {{ labels.previous }}
-          </button>
+          </component>
           <span
             class="
               text-xs uppercase tracking-[0.08em] tabular-nums
@@ -435,22 +476,29 @@
             {{ labels.page }} {{ page }}
             <template v-if="pages">{{ labels.of }} {{ pages }}</template>
           </span>
-          <button
-            type="button"
-            :disabled="pending || failed || !hasNext"
+          <component
+            :is="nextHref ? 'a' : 'button'"
+            :type="nextHref ? undefined : 'button'"
+            :href="nextHref"
+            :rel="nextHref ? 'next' : undefined"
+            :disabled="nextHref ? undefined : pending || failed || !hasNext"
             class="
               inline-flex h-11 items-center justify-center px-5
               [font-family:inherit] text-xs font-medium uppercase tracking-[0.08em]
-              text-orionplace-text
+              text-orionplace-text no-underline
               border border-solid border-orionplace-border bg-transparent
               cursor-pointer outline-none
               hover:border-orionplace-text focus-visible:border-orionplace-text
               disabled:cursor-not-allowed disabled:opacity-40
             "
-            @click="emit('changePage', page + 1)"
+            @click="
+              nextHref
+                ? followPage($event, page + 1)
+                : emit('changePage', page + 1)
+            "
           >
             {{ labels.next }} →
-          </button>
+          </component>
         </nav>
       </div>
     </section>

package/templates/app/components/orionplace/shared/StorefrontPagination.README.md

@@ -40,6 +40,11 @@ pages supplied by the full starter.
 between them, for a narrow list such as the support conversations; the buttons
 keep Previous and Next as their accessible names.
 
+`linked` is for lists that keep their page number in the address
+(`?page=2`): Previous and Next are links to those addresses, so search engines
+reach every page of the list, and a click still changes the page in place.
+The journal and the store list use it.
+
 ## Endpoint coverage
 
 No direct API request; the parent supplies the state.

package/templates/app/components/orionplace/shared/StorefrontPagination.vue

@@ -1,8 +1,10 @@
 <script setup lang="ts">
   import { computed, ref } from 'vue';
+  import { useRoute } from '#imports';
   import { useOrionplaceSelectionsStore } from '@/stores/orionplaceSelections';
   import { featureLabels } from '@/utils/orionplace/featureLabels';
   import { scrollToPaginatedList } from '@/utils/orionplace/paginationScroll';
+  import { storefrontPageHref } from '@/utils/orionplace/pageSeo';
   import type { IApiPagination } from '@/interfaces/orionplace/accounts/IProfileData';
   import '@/components/orionplace/shared/features.css';
 
@@ -11,17 +13,58 @@
     pending?: boolean;
     scrollTarget?: HTMLElement | string | null;
     compact?: boolean;
+    linked?: boolean;
   }>();
+  // `linked`: the list keeps its page number in the address (`?page=`), so
+  // previous and next are links to those addresses and search engines reach
+  // every page. A click still changes the page in place.
   const emit           = defineEmits<{ change: [page: number] }>();
   const selectionStore = useOrionplaceSelectionsStore();
   const labels         = computed(() => featureLabels(selectionStore.localeCode));
   const page           = computed(() => props.pagination.page ?? 1);
   const nav            = ref<HTMLElement>();
+  const route          = useRoute();
+  const previousPage   = computed(
+    () => props.pagination.previous_page_number || page.value - 1,
+  );
+  const nextPage       = computed(() =>
+    typeof props.pagination.next_page_number === 'number'
+      ? props.pagination.next_page_number
+      : page.value + 1,
+  );
+  const search         = computed(
+    () => new URL(route.fullPath, 'http://storefront').search,
+  );
+  const previousHref   = computed(() =>
+    props.linked && !props.pending && props.pagination.has_previous
+      ? storefrontPageHref(route.path, search.value, previousPage.value)
+      : undefined,
+  );
+  const nextHref       = computed(() =>
+    props.linked && !props.pending && props.pagination.has_next
+      ? storefrontPageHref(route.path, search.value, nextPage.value)
+      : undefined,
+  );
 
   function change(value: number) {
     emit('change', value);
     scrollToPaginatedList(nav.value, props.scrollTarget);
   }
+
+  // A link opened in a new tab or window keeps its default.
+  function follow(event: MouseEvent, value: number) {
+    if (
+      event.button !== 0 ||
+      event.metaKey ||
+      event.ctrlKey ||
+      event.shiftKey ||
+      event.altKey
+    ) {
+      return;
+    }
+    event.preventDefault();
+    change(value);
+  }
 </script>
 
 <template>
@@ -41,13 +84,20 @@
       The compact form fits a narrow list: arrow buttons named for screen
       readers, with the page count between them.
     -->
-    <button
+    <component
+      :is="previousHref ? 'a' : 'button'"
       class="op-feature-button"
-      type="button"
+      :type="previousHref ? undefined : 'button'"
+      :href="previousHref"
+      :rel="previousHref ? 'prev' : undefined"
       :aria-label="compact ? labels.previous : undefined"
       :title="compact ? labels.previous : undefined"
-      :disabled="pending || !pagination.has_previous"
-      @click="change(pagination.previous_page_number || page - 1)"
+      :disabled="previousHref ? undefined : pending || !pagination.has_previous"
+      @click="
+        previousHref
+          ? follow($event, previousPage)
+          : change(previousPage)
+      "
     >
       <svg
         v-if="compact"
@@ -63,24 +113,21 @@
         <path d="m15 5-7 7 7 7" />
       </svg>
       <template v-else>{{ labels.previous }}</template>
-    </button>
+    </component>
     <span class="tabular-nums">
       {{ labels.page }} {{ page }}
       <template v-if="pagination.pages">/ {{ pagination.pages }}</template>
     </span>
-    <button
+    <component
+      :is="nextHref ? 'a' : 'button'"
       class="op-feature-button"
-      type="button"
+      :type="nextHref ? undefined : 'button'"
+      :href="nextHref"
+      :rel="nextHref ? 'next' : undefined"
       :aria-label="compact ? labels.next : undefined"
       :title="compact ? labels.next : undefined"
-      :disabled="pending || !pagination.has_next"
-      @click="
-        change(
-          typeof pagination.next_page_number === 'number'
-            ? pagination.next_page_number
-            : page + 1,
-        )
-      "
+      :disabled="nextHref ? undefined : pending || !pagination.has_next"
+      @click="nextHref ? follow($event, nextPage) : change(nextPage)"
     >
       <svg
         v-if="compact"
@@ -96,6 +143,6 @@
         <path d="m9 5 7 7-7 7" />
       </svg>
       <template v-else>{{ labels.next }}</template>
-    </button>
+    </component>
   </nav>
 </template>

package/templates/app/components/orionplace/stores/StorefrontStores.vue

@@ -339,6 +339,7 @@
     <StorefrontPagination
       :pagination="pagination"
       :pending="busy"
+      :linked="!storeId"
       @change="storeId ? load($event) : open($event)"
     />
   </section>

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,10 +1,15 @@
 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,
+  storefrontPagedText,
   storefrontPublicOrigin,
 } from '@/utils/orionplace/pageSeo';
 import type { StorefrontSeoPage } from '@/utils/orionplace/pageSeo';
@@ -19,6 +24,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 +36,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(
@@ -51,19 +60,46 @@ export function useOrionplacePageSeo(
     ),
   );
 
+  // A later list page (`?page=2`) names its page number.
+  const paged     = computed(() => ({
+    title:
+      storefrontPagedText(metadata.value.title, canonical.value, toValue(locale)) ??
+      metadata.value.title,
+    description:
+      storefrontPagedText(
+        metadata.value.description,
+        canonical.value,
+        toValue(locale),
+      ) ?? metadata.value.description,
+  }));
+
   // Link previews use the same title and description as the page; the
   // image is the record's first picture when the page has one, as a
   // complete address.
   const seo       = {
-    title: () => metadata.value.title,
-    description: () => metadata.value.description,
+    title: () => paged.value.title,
+    description: () => paged.value.description,
     keywords: () => metadata.value.keywords,
     robots: () => toValue(values.robots),
-    ogTitle: () => metadata.value.title,
-    ogDescription: () => metadata.value.description,
+    ogTitle: () => paged.value.title,
+    ogDescription: () => paged.value.description,
     ogImage: () => storefrontAbsoluteUrl(toValue(values.image), origin),
     ogUrl: () => canonical.value,
+    // Nuxt's head types leave out og:type `product` (Open Graph product
+    // pages); the tag renders as given.
+    ogType: () =>
+      storefrontOpenGraphType(toValue(page)) as 'website' | 'article',
+    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 +109,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' as const,
+              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/pages/journal/index.vue

@@ -4,9 +4,11 @@
   import { useOrionplaceStore } from '@/stores/orionplace';
   import { useOrionplacePageSeo } from '@/composables/useOrionplacePageSeo';
   import { useOrionplaceServerData } from '@/composables/useOrionplaceServerData';
+  import { useOrionplaceMissingPage } from '@/composables/useOrionplaceMissingPage';
   import {
     blogPageNumber,
     blogPageSize,
+    journalPagePastEnd,
     blogPostsRequest,
     blogViewType,
   } from '@/utils/orionplace/blogLayout';
@@ -49,6 +51,11 @@
   );
 
   useOrionplacePageSeo('journal', () => store.localeCode);
+
+  // A page number past the last page has no articles: it answers 404, so
+  // search engines drop it instead of indexing an empty list.
+  const pastLastPage = journalPagePastEnd(page.value, serverPage.value);
+  useOrionplaceMissingPage(() => pastLastPage, 'Page not found');
 </script>
 
 <template>

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

@@ -93,3 +93,16 @@ export function blogCoverInitial(title: string) {
 export function blogCoverPattern(postId: number) {
   return Math.abs(postId) % 3;
 }
+
+/**
+ * Whether a journal page number lies past the last page: the server render
+ * loaded that page (no filters) and it has no articles. Page 1 of an empty
+ * journal is a page of its own.
+ */
+export function journalPagePastEnd(
+  page: number,
+  loaded: IBlogJournalPage | null | undefined,
+): boolean {
+  const posts = loaded?.data?.posts?.data;
+  return page > 1 && loaded?.page === page && Array.isArray(posts) && !posts.length;
+}

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 {
@@ -320,11 +460,15 @@ export function storefrontAbsoluteUrl(
 // The pages the sitemap lists (runtime/marketplace.mjs), plus plan pages.
 const indexedPage = /^\/(?:|catalog|journal|tariffs|manufacturers|sellers|stores|contact|privacy|(?:category|product|journal)\/\d+|tariffs\/[^/]+\/\d+)$/;
 
+// Listed pages that are lists with page numbers (`?page=2`).
+const pagedList   = /^\/(?:journal|stores|category\/\d+)$/;
+
 /**
  * The canonical address of a page: the sitemap's address for it, the page in
- * the language it shows (`?locale=`). Pages that are not listed, pages with
- * other query parameters (filters, page numbers, private keys) and noindex
- * pages get none.
+ * the language it shows (`?locale=`). A later page of a list is a page of its
+ * own (`?locale=en&page=2`, Google's pagination guide), linked from the
+ * list's page links. Pages that are not listed, pages with other query
+ * parameters (filters, private keys) and noindex pages get none.
  */
 export function storefrontCanonicalUrl(
   origin: string,
@@ -333,9 +477,13 @@ export function storefrontCanonicalUrl(
   locale: string,
   robots?: string,
 ): string | undefined {
-  const path  = pathname.replace(/\/+$/, '') || '/';
-  const query = new URLSearchParams(search);
+  const path       = pathname.replace(/\/+$/, '') || '/';
+  const query      = new URLSearchParams(search);
+  const pageNumber = query.get('page');
   query.delete('locale');
+  if (pageNumber !== null && pagedList.test(path) && /^[1-9]\d{0,5}$/.test(pageNumber)) {
+    query.delete('page');
+  }
   if (
     !origin ||
     /noindex/i.test(robots ?? '') ||
@@ -344,9 +492,171 @@ export function storefrontCanonicalUrl(
   ) {
     return undefined;
   }
-  const url   = new URL(path, `${origin}/`);
+  const url        = new URL(path, `${origin}/`);
   if (locale) {
     url.searchParams.set('locale', locale);
   }
+  if (pageNumber && Number(pageNumber) > 1 && pagedList.test(path)) {
+    url.searchParams.set('page', pageNumber);
+  }
   return url.toString();
 }
+
+/**
+ * A later page of a list repeats the list's title and description; the page
+ * number keeps them distinct (search engines report repeated titles as
+ * duplicates). The number comes from the canonical address, so only the
+ * indexed list pages get it.
+ */
+export function storefrontPagedText(
+  text: string | undefined,
+  canonical: string | undefined,
+  locale: string,
+): string | undefined {
+  const page = canonical ? Number(new URL(canonical).searchParams.get('page')) : 0;
+  if (!text || !(page > 1)) {
+    return text;
+  }
+  const words: Record<string, string> = { ru: 'страница', es: 'página' };
+  const word                          = words[storefrontCopyLanguage(locale)] ?? 'page';
+  return `${text} · ${word} ${page}`;
+}
+
+/**
+ * The address of another page of the list on screen: the current address
+ * with `page=` set (left out for page 1), every other parameter kept. Page
+ * links are real links, so search engines reach every page of a list.
+ */
+export function storefrontPageHref(
+  pathname: string,
+  search: string,
+  page: number,
+): string {
+  const query = new URLSearchParams(search);
+  if (page > 1) {
+    query.set('page', String(page));
+  } else {
+    query.delete('page');
+  }
+  const text  = query.toString();
+  return `${pathname}${text ? `?${text}` : ''}`;
+}
+
+/** 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: 'icon'; 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;
+}