orionplace-nuxt 0.6.0 → 0.6.1

package/README.md

@@ -1021,6 +1021,19 @@ replace options, colors, counts or price bounds with narrowed responses. New
 queries, categories and AppLoad refreshes reset that scope; Clear keeps
 its original selectors. Superseded requests are cancelled and ignored.
 
+Category, search, featured and seller lists keep their result page and
+filters in the URL as `?page=2&filters={...}` (JSON of the filter selection).
+The composable replaces the current history entry on each change, so the
+browser's Back button from a product, and a reload, open the same list, while
+Back from the list still leaves it in one step. Page loads read the same
+query through `productListLocationFromQuery()` in
+`app/utils/orionplace/productListLocation.ts`, which accepts only plain filter
+values within fixed limits. A list opened this way on a later page or with
+filters also requests the unfiltered first page once, so the filter panel
+keeps every choice. Pass `rememberInAddress: false` to keep a list out of the
+URL. The React and Svelte packages do the same in `useProductSearch()` and
+`useOrionplaceProductSearch()`.
+
 `SearchFilters` supplies cumulative ID arrays and scalar price, discount and
 rating fields. Currency-keyed `selects.measures.min_price` and `max_price` supply
 the price range; Apply or a committed slider change emits `price_from`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-nuxt",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "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/runtime/domain.mjs

@@ -1,11 +1,15 @@
 // Other server code can read event.context.marketplaceDomain for canonical URLs.
-import { defineEventHandler, toWebRequest } from 'h3';
+// Pages under ORIONPLACE_NOINDEX_PATHS answer with `X-Robots-Tag: noindex, follow`.
+import { defineEventHandler, getRequestURL, setResponseHeader, toWebRequest } from 'h3';
 import { useRuntimeConfig } from '#imports';
-import { resolveFrontDomain } from './marketplace.mjs';
+import { marketplaceNoindexPath, resolveFrontDomain } from './marketplace.mjs';
 
 export default defineEventHandler((event) => {
   event.context.marketplaceDomain = resolveFrontDomain(
     toWebRequest(event),
     process.env.MIMIC_FRONT_DOMAIN ?? useRuntimeConfig(event).mimicFrontDomain,
   );
+  if (marketplaceNoindexPath(getRequestURL(event).pathname)) {
+    setResponseHeader(event, 'X-Robots-Tag', 'noindex, follow');
+  }
 });

package/runtime/marketplace.mjs

@@ -329,6 +329,7 @@ export async function forwardMarketplace(request, configuration = {}) {
 // node_modules/.cache/orionplace/sitemaps/<domain>.json (ORIONPLACE_CACHE_DIR
 // moves it). "orionplace-<framework> sitemap rebuild" rebuilds that file at
 // once; the running storefront serves the new file without a restart.
+// Paths in ORIONPLACE_NOINDEX_PATHS are left out when the sitemap is served.
 
 export const SITEMAP_LIFETIME = 60 * 60 * 1000;
 const sitemapPageSize = 100;
@@ -353,6 +354,34 @@ export function marketplacePublicOrigin(request, tenantDomain = '') {
   return local || !tenantDomain ? url.origin : `https://${tenantDomain}`;
 }
 
+/**
+ * Pages kept out of search engines: ORIONPLACE_NOINDEX_PATHS lists path
+ * prefixes separated by spaces or commas, for example "/catalog /category
+ * /product" on a demo or staging storefront. Those pages answer with
+ * `X-Robots-Tag: noindex, follow` and the sitemap leaves them out. Empty
+ * (the default) keeps every public page indexable.
+ */
+export function noindexPathPrefixes(value = environment.ORIONPLACE_NOINDEX_PATHS) {
+  return String(value ?? '')
+    .split(/[\s,]+/)
+    .map((item) => item.trim().replace(/\/+$/, ''))
+    .filter((item) => /^\/[A-Za-z0-9._~\/-]+$/.test(item));
+}
+
+/** Whether a page path is kept out of search engines (see noindexPathPrefixes). */
+export function marketplaceNoindexPath(pathname, value = environment.ORIONPLACE_NOINDEX_PATHS) {
+  const path = String(pathname ?? '');
+  return noindexPathPrefixes(value)
+    .some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+}
+
+/** The sitemap pages search engines may index. */
+export function sitemapIndexedPages(pages, value = environment.ORIONPLACE_NOINDEX_PATHS) {
+  return noindexPathPrefixes(value).length
+    ? pages.filter((page) => !marketplaceNoindexPath(page.path, value))
+    : pages;
+}
+
 /** @param {string} origin */
 export function marketplaceRobots(origin) {
   return `User-agent: *\nDisallow: /api/\nAllow: /\n\nSitemap: ${origin}/sitemap.xml\n`;
@@ -618,7 +647,7 @@ async function buildMarketplaceSitemap(tenant) {
 /** How many <url> entries a built sitemap has. */
 export function sitemapUrlCount(sitemap) {
   let count = 0;
-  for (const page of sitemap.pages) {
+  for (const page of sitemapIndexedPages(sitemap.pages)) {
     const own = page.locales
       ? sitemap.locales.filter((code) => page.locales.includes(code))
       : sitemap.locales;
@@ -776,7 +805,7 @@ export async function marketplaceSitemapResponse(request, configuration = {}) {
     }
   }
   const origin  = marketplacePublicOrigin(request, tenant.domain);
-  return new Response(marketplaceSitemapXml(origin, sitemap.pages, sitemap.locales), {
+  return new Response(marketplaceSitemapXml(origin, sitemapIndexedPages(sitemap.pages), sitemap.locales), {
     headers: {
       'Content-Type': 'application/xml; charset=utf-8',
       'Cache-Control': 'public, max-age=3600',

package/src/project-readme.mjs

@@ -571,6 +571,12 @@ npx orionplace-nuxt sitemap rebuild shop.example.com  # one domain
 npx orionplace-nuxt sitemap status                  # when each was built
 \`\`\`
 
+To keep a demo or staging storefront's shop pages out of search engines, set
+\`ORIONPLACE_NOINDEX_PATHS\` in \`.env\` to path prefixes separated by spaces,
+for example \`ORIONPLACE_NOINDEX_PATHS="/catalog /category /product"\`. Those
+pages answer with \`X-Robots-Tag: noindex, follow\` and the sitemap leaves them
+out; the journal and other pages stay indexable. Leave it empty on a live shop.
+
 This setup does not add analytics.
 
 ## Android app

package/templates/app/components/orionplace/catalog/StorefrontCatalog.vue

@@ -157,7 +157,7 @@
           :disabled="isPending"
           @click="openBranch(item.id)"
         >
-          {{ labels.categories }} →
+          {{ labels.categories }} <span aria-hidden="true">→</span>
         </button>
         <NuxtLink
           class="op-feature-link op-feature-button op-feature-primary px-3!"
@@ -166,7 +166,7 @@
             query: { locale: selectionStore.localeCode },
           }"
         >
-          {{ labels.products }} →
+          {{ labels.products }} <span aria-hidden="true">→</span>
         </NuxtLink>
       </li>
     </ul>

package/templates/app/composables/useOrionplacePageSeo.ts

@@ -1,7 +1,12 @@
 import { computed, toValue } from 'vue';
 import type { MaybeRefOrGetter } from 'vue';
-import { useSeoMeta } from '#imports';
-import { storefrontPageMetadata } from '@/utils/orionplace/pageSeo';
+import { useHead, useRequestHeader, useRoute, useSeoMeta } from '#imports';
+import {
+  storefrontAbsoluteUrl,
+  storefrontCanonicalUrl,
+  storefrontPageMetadata,
+  storefrontPublicOrigin,
+} from '@/utils/orionplace/pageSeo';
 import type { StorefrontSeoPage } from '@/utils/orionplace/pageSeo';
 
 export function useOrionplacePageSeo(
@@ -15,24 +20,48 @@ export function useOrionplacePageSeo(
     image?: MaybeRefOrGetter<string | undefined>;
   } = {},
 ) {
-  const metadata = computed(() =>
+  const route     = useRoute();
+  // The address the visitor used: the proxy's host during the server render.
+  const origin    = import.meta.server
+    ? storefrontPublicOrigin(
+      useRequestHeader('x-forwarded-host') ?? useRequestHeader('host'),
+    )
+    : window.location.origin;
+  const metadata  = computed(() =>
     storefrontPageMetadata(toValue(page), toValue(locale), {
       title: toValue(values.title),
       description: toValue(values.description),
       keywords: toValue(values.keywords),
     }),
   );
+  const canonical = computed(() =>
+    storefrontCanonicalUrl(
+      origin,
+      route.path,
+      new URL(route.fullPath, 'http://storefront').search,
+      toValue(locale),
+      toValue(values.robots),
+    ),
+  );
 
   // Link previews use the same title and description as the page; the
-  // image is the record's first picture when the page has one.
-  const seo      = {
+  // 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,
     keywords: () => metadata.value.keywords,
     robots: () => toValue(values.robots),
     ogTitle: () => metadata.value.title,
     ogDescription: () => metadata.value.description,
-    ogImage: () => toValue(values.image) || undefined,
+    ogImage: () => storefrontAbsoluteUrl(toValue(values.image), origin),
+    ogUrl: () => canonical.value,
   };
   useSeoMeta(seo);
+  useHead({
+    link: () =>
+      canonical.value
+        ? [{ key: 'canonical', rel: 'canonical', href: canonical.value }]
+        : [],
+  });
 }

package/templates/app/composables/useOrionplaceProductSearch.ts

@@ -1,5 +1,6 @@
 import { onMounted, onScopeDispose, ref, toValue, watch } from 'vue';
 import type { MaybeRefOrGetter } from 'vue';
+import { navigateTo, useRoute } from '#imports';
 import { useOrionplaceStore } from '@/stores/orionplace';
 import { useOrionplaceApi } from '@/composables/useOrionplaceApi';
 import { useOrionplaceProgress } from '@/composables/useOrionplaceProgress';
@@ -19,6 +20,12 @@ import type {
 } from '@/interfaces/orionplace/products/IProduct';
 import type { IProductSearchFacets } from '@/interfaces/orionplace/products/IProductSearchFacets';
 import type { OrionplaceFeatureApi } from '@/composables/useOrionplaceFeature';
+import {
+  productListLocationFromQuery,
+  productListLocationQuery,
+  sameProductListLocation,
+} from '@/utils/orionplace/productListLocation';
+import type { ProductListLocation } from '@/utils/orionplace/productListLocation';
 
 export type ProductSearchData = IProductSearchFacets & {
   products: { data: IProduct[]; rpag?: IProductPagination };
@@ -36,10 +43,18 @@ export type ProductSearchContext = ProductSearchScope & { categoryId?: number };
  */
 export interface ProductSearchSnapshot {
   scope: string;
+  // The page and filters it was loaded with; see productListLocation.
+  list?: string;
   productIds: number[];
   rpag?: IProductPagination;
 }
 
+const firstListPage: ProductListLocation = { page: 1, filters: {} };
+
+function listSignature(location: ProductListLocation) {
+  return JSON.stringify(productListLocationQuery({}, location));
+}
+
 type OrionplaceStore = ReturnType<typeof useOrionplaceStore>;
 
 /**
@@ -51,6 +66,7 @@ export function productSearchBody(
   store: OrionplaceStore,
   scope: ProductSearchContext,
   page: number,
+  filters = store.searchFilters,
 ) {
   const category = scope.categoryId === undefined
     ? undefined
@@ -65,7 +81,7 @@ export function productSearchBody(
 
   if (scope.categoryId !== undefined) {
     return category
-      ? categorySearchRequest(category, store.searchFilters, page)
+      ? categorySearchRequest(category, filters, page)
       : undefined;
   }
 
@@ -73,7 +89,35 @@ export function productSearchBody(
     return undefined;
   }
 
-  return scopedSearchRequest(scope, store.searchFilters, page);
+  return scopedSearchRequest(scope, filters, page);
+}
+
+/**
+ * A list opened from its URL (Back, a reload) on a later page or with
+ * filters gets only the filtered choices, or none after the first page.
+ * Without stored choices for the scope this also asks for the unfiltered
+ * first page, so the filter panel keeps every seller, price and option to
+ * choose from. The extra request is only for the panel: when it fails the
+ * panel shows the choices of the result.
+ */
+async function preserveFullSearchFacets(
+  store: OrionplaceStore,
+  scope: ProductSearchContext,
+  page: number,
+  requestData: (body: Record<string, unknown>) => Promise<ProductSearchData>,
+) {
+  const needed = page > 1 || Object.keys(store.searchFilters).length > 0;
+  const body   = needed && !store.searchFacets
+    ? productSearchBody(store, scope, 1, {})
+    : undefined;
+
+  if (!body) {
+    return;
+  }
+  const full = await requestData(body).catch(() => undefined);
+  if (full && !store.searchFacets) {
+    store.preserveSearchFacets(full);
+  }
 }
 
 /** Stores the returned products and keeps the scope's first filter choices. */
@@ -91,24 +135,34 @@ export function storeProductSearchPage(
 }
 
 /**
- * Loads the first result page during a server render, with the filters
- * currently in the store. Returns null when the scope cannot be searched.
+ * Loads a result page during a server render: the page and filters of the
+ * address (`location`, the first page by default), so a reload shows the
+ * list the visitor left. Returns null when the scope cannot be searched.
  */
 export async function loadProductSearchSnapshot(
   api: Pick<OrionplaceFeatureApi, 'request'>,
   store: OrionplaceStore,
   scope: ProductSearchContext,
+  location: ProductListLocation = firstListPage,
 ): Promise<ProductSearchSnapshot | null> {
-  const body = productSearchBody(store, scope, 1);
+  store.setSearchFilters(location.filters);
+  const body = productSearchBody(store, scope, location.page);
 
   if (!body) {
     return null;
   }
 
-  const data = await api.request<ProductSearchData>('products_search', body);
+  // Both requests run together; the full choices are kept first.
+  const [data] = await Promise.all([
+    api.request<ProductSearchData>('products_search', body),
+    preserveFullSearchFacets(store, scope, location.page, (full) =>
+      api.request<ProductSearchData>('products_search', full),
+    ),
+  ]);
 
   return {
     scope: JSON.stringify(scope),
+    list: listSignature(location),
     productIds: storeProductSearchPage(store, data),
     rpag: data.products.rpag,
   };
@@ -124,24 +178,41 @@ export function useOrionplaceProductSearch(
     scrollToTop?: boolean;
     // The first page from the server render; see useOrionplaceServerData.
     initial?: ProductSearchSnapshot | null;
+    // `false` keeps the page and filters out of the URL.
+    rememberInAddress?: boolean;
   } = {},
 ) {
   const store       = useOrionplaceStore();
+  const route       = useRoute();
+  const remember    = options.rememberInAddress !== false;
   const api         = options.request ? undefined : useOrionplaceApi();
   const requestData =
     options.request ??
     ((body, signal) =>
       api!.request<ProductSearchData>('products_search', body, signal));
-  // The server result is used only for the scope it was loaded for.
+  // The page and filters in the URL: Back from a product or a reload opens
+  // the list the visitor left.
+  function addressLocation(): ProductListLocation {
+    return remember ? productListLocationFromQuery(route.query) : firstListPage;
+  }
+  const opening     = addressLocation();
+  // The server result is used only for the scope and the page and filters
+  // it was loaded for.
   const initial     =
-    options.initial?.scope === JSON.stringify(toValue(context))
+    options.initial?.scope === JSON.stringify(toValue(context)) &&
+    (options.initial.list ?? listSignature(firstListPage)) ===
+      listSignature(opening)
       ? options.initial
       : undefined;
+  if (initial) {
+    // The filter panel shows the filters this result was loaded with.
+    store.setSearchFilters(opening.filters);
+  }
   const productIds  = ref<number[]>(initial ? [...initial.productIds] : []);
   const pagination  = ref<IProductPagination>(
     initial ? mergeCategoryPagination({}, initial.rpag) : {},
   );
-  const page        = ref(1);
+  const page        = ref(initial ? opening.page : 1);
   const pending     = ref(!initial);
   const failed      = ref(false);
   const loaded      = ref(Boolean(initial));
@@ -150,6 +221,25 @@ export function useOrionplaceProductSearch(
 
   useOrionplaceProgress(() => pending.value);
 
+  // Replaces the URL, so Back from the list still leaves it in one step.
+  function rememberLocation() {
+    const next = { page: page.value, filters: store.searchFilters };
+    if (
+      !remember ||
+      sameProductListLocation(productListLocationFromQuery(route.query), next)
+    ) {
+      return;
+    }
+    void navigateTo(
+      {
+        path: route.path,
+        query: productListLocationQuery(route.query, next),
+        hash: route.hash,
+      },
+      { replace: true },
+    );
+  }
+
   function cancel() {
     request?.abort();
     request       = undefined;
@@ -171,11 +261,20 @@ export function useOrionplaceProductSearch(
       pending.value    = !mounted;
       return;
     }
+    rememberLocation();
     const current    = new AbortController();
     request          = current;
     pending.value    = true;
     try {
-      const data       = await requestData(body, current.signal);
+      const [data]     = await Promise.all([
+        requestData(body, current.signal),
+        preserveFullSearchFacets(
+          store,
+          toValue(context),
+          page.value,
+          (full) => requestData(full, current.signal),
+        ),
+      ]);
       if (current.signal.aborted) {
         return;
       }
@@ -202,11 +301,16 @@ export function useOrionplaceProductSearch(
     store.setSearchFilters({});
     void load(true);
   }
+  // A new scope starts from the page and filters of its URL: none after a
+  // link, the ones the visitor left after Back or a reload.
   function reset() {
+    const location   = addressLocation();
     pagination.value = {};
     productIds.value = [];
     store.setSearchFacets(null);
-    clearFilters();
+    store.setSearchFilters(location.filters);
+    page.value       = location.page;
+    void load();
   }
   function turnPage(value: number) {
     if (

package/templates/app/pages/browse.vue

@@ -14,6 +14,7 @@
   import { directoryLabels } from '@/utils/orionplace/directoryLabels';
   import { storeAddress, storePhoneLink } from '@/utils/orionplace/storeDirectory';
   import { browseLabels } from '@/utils/orionplace/browseLabels';
+  import { productListLocationFromQuery } from '@/utils/orionplace/productListLocation';
   import {
     fixedScopeFilters,
     hasFixedSearchScope,
@@ -63,7 +64,13 @@
   // browser.
   const serverResults         = await useOrionplaceServerData(
     `orionplace:search:${JSON.stringify(scope.value)}`,
-    (api) => loadProductSearchSnapshot(api, store, scope.value),
+    (api) =>
+      loadProductSearchSnapshot(
+        api,
+        store,
+        scope.value,
+        productListLocationFromQuery(route.query),
+      ),
   );
   const results               = useOrionplaceProductSearch(scope, {
     initial: serverResults.value,

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

@@ -6,6 +6,7 @@
   import { useOrionplaceCategoryProducts } from '@/composables/useOrionplaceCategoryProducts';
   import { useOrionplaceServerData } from '@/composables/useOrionplaceServerData';
   import { loadProductSearchSnapshot } from '@/composables/useOrionplaceProductSearch';
+  import { productListLocationFromQuery } from '@/utils/orionplace/productListLocation';
   import { useOrionplaceStorefront } from '@/composables/useOrionplaceStorefront';
   import {
     getAvailableNestedValueFromObject,
@@ -21,12 +22,19 @@
     /^\d+$/.test(String(route.params.id)) ? Number(route.params.id) : 0,
   );
   const category                         = computed(() => store.getCatalogCategory(id.value));
-  // The server render loads the first result page with the visitor's
-  // cookies, so the page HTML lists the category's products and prices.
-  // Filters and further pages load in the browser.
+  // The server render loads the result page of the URL (page and filters,
+  // the first page by default) with the visitor's cookies, so the page HTML
+  // lists the category's products and prices. Later changes load in the
+  // browser.
   const serverResults                    = await useOrionplaceServerData(
     `orionplace:category:${id.value}`,
-    (api) => loadProductSearchSnapshot(api, store, { categoryId: id.value }),
+    (api) =>
+      loadProductSearchSnapshot(
+        api,
+        store,
+        { categoryId: id.value },
+        productListLocationFromQuery(route.query),
+      ),
   );
   const results                          = useOrionplaceCategoryProducts(
     id,

package/templates/app/pages/featured.vue

@@ -1,6 +1,6 @@
 <script setup lang="ts">
   import { computed } from 'vue';
-  import { navigateTo } from '#imports';
+  import { navigateTo, useRoute } from '#imports';
   import { NuxtLink } from '#components';
   import { useOrionplacePageSeo } from '@/composables/useOrionplacePageSeo';
   import { useOrionplaceStore } from '@/stores/orionplace';
@@ -10,15 +10,23 @@
   import { useOrionplaceStorefront } from '@/composables/useOrionplaceStorefront';
   import { featuredLabels } from '@/utils/orionplace/featuredLabels';
   import { browseLabels } from '@/utils/orionplace/browseLabels';
+  import { productListLocationFromQuery } from '@/utils/orionplace/productListLocation';
   import ProductSearchResults from '@/components/orionplace/search/ProductSearchResults.vue';
   import OrionplaceEmptyState from '@/components/orionplace/shared/OrionplaceEmptyState.vue';
 
   const store                 = useOrionplaceStore();
+  const route                 = useRoute();
   // Featured products depend on the signed-in customer's searches: the
-  // server render loads the first page with the visitor's cookies.
+  // server render loads the page of the URL with the visitor's cookies.
   const serverResults         = await useOrionplaceServerData(
     'orionplace:featured',
-    (api) => loadProductSearchSnapshot(api, store, { featured: true }),
+    (api) =>
+      loadProductSearchSnapshot(
+        api,
+        store,
+        { featured: true },
+        productListLocationFromQuery(route.query),
+      ),
   );
   const results               = useOrionplaceFeaturedProducts(
     serverResults.value,

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

@@ -282,3 +282,71 @@ export function storefrontPageMetadata(
     keywords: plainText(values.keywords ?? '') || `${title}, ${copy[2]}`,
   };
 }
+
+/*
+ * Addresses for search engines and link previews. The public origin is the
+ * storefront host the visitor used (the proxy's Host or X-Forwarded-Host),
+ * over HTTPS; a local host keeps HTTP for development.
+ */
+export function storefrontPublicOrigin(host: string | null | undefined): string {
+  const name  = (host ?? '').split(',')[0]!.trim().toLowerCase();
+  if (!/^(?:[a-z0-9-]+(?:\.[a-z0-9-]+)*|\[[0-9a-f:]+\])(?::\d{1,5})?$/.test(name)) {
+    return '';
+  }
+  const local = /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\])(?::\d+)?$/.test(name);
+  return `${local ? 'http' : 'https'}://${name}`;
+}
+
+/**
+ * A complete address for a link preview image: a storefront path such as
+ * `/ps3/blog/posts/images/5` gets the public origin; without an origin it is
+ * left out, since a relative og:image is not loaded by link previews.
+ */
+export function storefrontAbsoluteUrl(
+  value: string | null | undefined,
+  origin: string,
+): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  try {
+    const url = origin ? new URL(value, `${origin}/`) : new URL(value);
+    return /^https?:$/.test(url.protocol) ? url.toString() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// 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+)$/;
+
+/**
+ * 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.
+ */
+export function storefrontCanonicalUrl(
+  origin: string,
+  pathname: string,
+  search: string,
+  locale: string,
+  robots?: string,
+): string | undefined {
+  const path  = pathname.replace(/\/+$/, '') || '/';
+  const query = new URLSearchParams(search);
+  query.delete('locale');
+  if (
+    !origin ||
+    /noindex/i.test(robots ?? '') ||
+    !indexedPage.test(path) ||
+    [...query.keys()].length
+  ) {
+    return undefined;
+  }
+  const url   = new URL(path, `${origin}/`);
+  if (locale) {
+    url.searchParams.set('locale', locale);
+  }
+  return url.toString();
+}

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

@@ -0,0 +1,130 @@
+import type { ProductFacetSelection } from '@/interfaces/orionplace/products/IProductSearchFacets';
+
+// Where a product list is: its result page and the chosen filters. Category,
+// search, seller and featured lists keep it in the URL as `?page&filters`, so
+// a reload and the browser's Back button from a product return to the same
+// list. `filters` is the filter selection as JSON; the address is visitor
+// input, so only plain filter values within the limits below are read.
+export interface ProductListLocation {
+  page: number;
+  filters: ProductFacetSelection;
+}
+
+type QueryValue = string | null | undefined | readonly (string | null)[];
+
+const locationKeys    = ['page', 'filters'];
+const maxPage         = 10000;
+const maxFiltersText  = 4000;
+const maxFilterKeys   = 40;
+const maxFilterIds    = 200;
+const maxFilterString = 100;
+const filterKey       = /^[a-z][a-z0-9_]{0,63}$/;
+
+function first(value: QueryValue) {
+  return Array.isArray(value) ? value[0] : (value as string | null | undefined);
+}
+
+function filterValue(value: unknown): ProductFacetSelection[string] {
+  if (Array.isArray(value)) {
+    const ids = value.filter(
+      (id): id is number => Number.isSafeInteger(id) && id >= 0,
+    );
+
+    return ids.length === value.length && ids.length && ids.length <= maxFilterIds
+      ? ids
+      : undefined;
+  }
+  if (typeof value === 'string') {
+    return value && value.length <= maxFilterString ? value : undefined;
+  }
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  // `false` chooses nothing, as an empty list or text.
+  return value === true ? true : undefined;
+}
+
+export function productListFiltersFromText(
+  text: string | null | undefined,
+): ProductFacetSelection {
+  if (!text || text.length > maxFiltersText) {
+    return {};
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return {};
+  }
+  const result: ProductFacetSelection = {};
+  for (const [key, value] of Object.entries(parsed).slice(0, maxFilterKeys)) {
+    const checked = filterKey.test(key) ? filterValue(value) : undefined;
+    if (checked !== undefined) {
+      result[key] = checked;
+    }
+  }
+
+  return result;
+}
+
+// The filters as URL text, or undefined when nothing is chosen.
+// Keys are sorted, so the same choice always gives the same text.
+export function productListFiltersText(filters: ProductFacetSelection) {
+  const chosen = productListFiltersFromText(JSON.stringify(filters));
+  const keys   = Object.keys(chosen).sort();
+
+  return keys.length
+    ? JSON.stringify(Object.fromEntries(keys.map((key) => [key, chosen[key]])))
+    : undefined;
+}
+
+export function productListLocationFromQuery(
+  query: Record<string, QueryValue>,
+): ProductListLocation {
+  const page = Number(first(query.page));
+
+  return {
+    page: Number.isSafeInteger(page) && page > 0 && page <= maxPage ? page : 1,
+    filters: productListFiltersFromText(first(query.filters)),
+  };
+}
+
+// Compares the URL form, so the same choice in another key order is equal.
+export function sameProductListLocation(
+  left: ProductListLocation,
+  right: ProductListLocation,
+) {
+  return (
+    left.page === right.page &&
+    productListFiltersText(left.filters) === productListFiltersText(right.filters)
+  );
+}
+
+// The query of `next`: other parameters such as `locale` or `q` stay, and the
+// first page without filters adds nothing.
+export function productListLocationQuery(
+  query: Record<string, QueryValue>,
+  next: ProductListLocation,
+) {
+  const result: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(query)) {
+    const text = first(value);
+    if (typeof text === 'string' && !locationKeys.includes(key)) {
+      result[key] = text;
+    }
+  }
+  if (next.page > 1) {
+    result.page = String(next.page);
+  }
+  const filters = productListFiltersText(next.filters);
+  if (filters) {
+    result.filters = filters;
+  }
+
+  return result;
+}