@laioutr/app-shopware 0.14.4

package/dist/runtime/server/shopware-helper/checkoutUrl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Build the redeem URL against the `LaioutrConnector` plugin's
+ * `/laioutr/connect-session` endpoint.
+ *
+ * Only the opaque, single-use `code` (minted server-to-server via
+ * {@link mintSessionHandoffCode}) travels through the browser — the raw
+ * `sw-context-token` never appears in a URL, history, or `Referer`.
+ */
+export declare const buildConnectSessionUrl: (params: {
+    storefrontUrl: string;
+    code: string;
+}) => string;

package/dist/runtime/server/shopware-helper/checkoutUrl.js

@@ -0,0 +1,5 @@
+export const buildConnectSessionUrl = (params) => {
+  const base = params.storefrontUrl.replace(/\/+$/, "");
+  const query = new URLSearchParams({ code: params.code });
+  return `${base}/laioutr/connect-session?${query.toString()}`;
+};

package/dist/runtime/server/shopware-helper/contextTokenCookie.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cookie options for the `sw-context-token` cookie on the laioutr domain. `httpOnly` so the
+ * token is never readable by client JS (an XSS on laioutr can no longer exfiltrate it).
+ * Pure — no `#imports` — so it is unit-testable.
+ */
+export declare const contextTokenCookieOptions: () => {
+    maxAge: number;
+    path: string;
+    sameSite: "lax";
+    httpOnly: true;
+};

package/dist/runtime/server/shopware-helper/contextTokenCookie.js

@@ -0,0 +1,7 @@
+export const contextTokenCookieOptions = () => ({
+  maxAge: 60 * 60 * 24 * 365,
+  // 1 year
+  path: "/",
+  sameSite: "lax",
+  httpOnly: true
+});

package/dist/runtime/server/shopware-helper/facetMapper.d.ts

@@ -0,0 +1,38 @@
+import { AvailableFilter, QueryWireRequestFilter } from '#orchestr/types';
+export type ShopwareAggregationKey = 'price' | 'shipping-free' | 'manufacturer';
+export interface ShopwareAggregation {
+    name: string;
+    min?: number;
+    max?: number;
+    entities?: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export type ShopwareAggregations = Record<ShopwareAggregationKey, ShopwareAggregation>;
+export declare const mapShopwareAggregationToAvailableFilters: (facets: ShopwareAggregations) => AvailableFilter[];
+export declare const mapSelectedFiltersToShopwareFilters: (filters: QueryWireRequestFilter, currency: string) => {
+    swFilters: ({
+        field: string;
+        type: "contains" | "equalsAny" | "prefix" | "suffix";
+        value: string;
+    } | {
+        field: string;
+        type: "equals";
+        value: string | number | boolean | null;
+    } | {
+        operator: "AND" | "and" | "OR" | "or";
+        queries: import("../types/storeApiTypes.js").components["schemas"]["Filters"];
+        type: "multi" | "not";
+    } | {
+        field: string;
+        parameters: {
+            gt?: number;
+            gte?: number;
+            lt?: number;
+            lte?: number;
+        };
+        type: "range";
+    })[];
+    swBuiltInFilters: Record<"manufacturer" | "shipping-free" | "min-price" | "max-price", string | number | boolean | undefined>;
+};

package/dist/runtime/server/shopware-helper/facetMapper.js

@@ -0,0 +1,79 @@
+import { isRangeFilter } from "#orchestr/types";
+import { Money } from "@screeny05/ts-money";
+export const mapShopwareAggregationToAvailableFilters = (facets) => {
+  const filters = [];
+  const listFacets = ["manufacturer"];
+  const rangeFacets = ["price"];
+  const booleanFacets = ["shipping-free"];
+  for (const facet in facets) {
+    const facetKey = facet;
+    const facetObj = facets[facet];
+    if (listFacets.includes(facetKey)) {
+      filters.push({
+        id: facetObj.name,
+        label: facetObj.name,
+        type: "list",
+        presentation: "text",
+        values: (facetObj.entities ?? []).map((entity) => ({ id: entity.id, label: entity.name }))
+      });
+    } else if (rangeFacets.includes(facetKey)) {
+      filters.push({
+        id: facetObj.name,
+        label: facetObj.name,
+        type: "range",
+        min: 0,
+        max: facetObj.max ?? 0
+      });
+    } else if (booleanFacets.includes(facetKey)) {
+      filters.push({
+        id: facetObj.name,
+        label: facetObj.name,
+        type: "boolean"
+      });
+    }
+  }
+  return filters;
+};
+export const mapSelectedFiltersToShopwareFilters = (filters, currency) => {
+  const swFilters = [];
+  const swBuiltInFilters = {};
+  for (const filter in filters) {
+    const filterObj = filters[filter];
+    if (isRangeFilter(filterObj)) {
+      if (filter === "price") {
+        swBuiltInFilters["min-price"] = filterObj.min === void 0 ? void 0 : new Money(filterObj.min, currency).toDecimal();
+        swBuiltInFilters["max-price"] = filterObj.max === void 0 ? void 0 : new Money(filterObj.max, currency).toDecimal();
+      } else {
+        swFilters.push({
+          type: "range",
+          field: filter,
+          parameters: {
+            lte: filterObj.max,
+            gte: filterObj.min
+          }
+        });
+      }
+    } else if (typeof filterObj === "boolean") {
+      if (filter === "shipping-free") {
+        swBuiltInFilters["shipping-free"] = filterObj;
+      } else {
+        swFilters.push({
+          type: "equals",
+          field: filter,
+          value: filterObj
+        });
+      }
+    } else {
+      if (filter === "manufacturer") {
+        swBuiltInFilters.manufacturer = filterObj.join("|");
+      } else {
+        swFilters.push({
+          type: "equalsAny",
+          field: filter,
+          value: filterObj.join("|")
+        });
+      }
+    }
+  }
+  return { swFilters, swBuiltInFilters };
+};

package/dist/runtime/server/shopware-helper/fetchAllProductVariants.d.ts

@@ -0,0 +1,137 @@
+import { StorefrontClient } from '../types/shopware.js';
+export declare const fetchAllProducts: (storefrontClient: StorefrontClient, { productIds, loadVariants }: {
+    productIds: string[];
+    loadVariants: boolean;
+}) => Promise<{
+    active?: boolean;
+    apiAlias: "product";
+    available?: boolean;
+    availableStock?: number;
+    calculatedCheapestPrice?: {
+        apiAlias?: "calculated_cheapest_price";
+        hasRange?: boolean;
+        listPrice?: import("../types/storeApiTypes.js").components["schemas"]["ListPrice"] | null;
+        quantity?: number;
+        referencePrice?: import("../types/storeApiTypes.js").components["schemas"]["ReferencePrice"] | null;
+        regulationPrice?: {
+            price: number;
+        } | null;
+        totalPrice?: number;
+        unitPrice?: number;
+        variantId?: string | null;
+    };
+    calculatedMaxPurchase?: number;
+    calculatedPrice: import("../types/storeApiTypes.js").components["schemas"]["CalculatedPrice"];
+    calculatedPrices: import("../types/storeApiTypes.js").components["schemas"]["CalculatedPrice"][];
+    canonicalProduct?: import("../types/storeApiTypes.js").components["schemas"]["Product"];
+    canonicalProductId?: string;
+    canonicalProductVersionId?: string;
+    categories?: import("../types/storeApiTypes.js").components["schemas"]["Category"][];
+    categoriesRo?: import("../types/storeApiTypes.js").components["schemas"]["Category"][];
+    categoryIds?: readonly string[];
+    categoryTree?: readonly string[];
+    childCount?: number;
+    children?: import("../types/storeApiTypes.js").components["schemas"]["Product"][];
+    cmsPage?: import("../types/storeApiTypes.js").components["schemas"]["CmsPage"];
+    cmsPageId?: string;
+    cmsPageVersionId?: string;
+    configuratorSettings?: import("../types/storeApiTypes.js").components["schemas"]["ProductConfiguratorSetting"][];
+    cover?: import("../types/storeApiTypes.js").components["schemas"]["ProductMedia"];
+    coverId?: string;
+    createdAt: string;
+    crossSellings?: import("../types/storeApiTypes.js").components["schemas"]["ProductCrossSelling"][];
+    customFields?: import("../types/storeApiTypes.js").GenericRecord;
+    deliveryTime?: import("../types/storeApiTypes.js").components["schemas"]["DeliveryTime"];
+    deliveryTimeId?: string;
+    description?: string;
+    displayGroup?: string;
+    downloads?: import("../types/storeApiTypes.js").components["schemas"]["ProductDownload"][];
+    ean?: string;
+    height?: number;
+    id: string;
+    isCloseout?: boolean;
+    isNew?: boolean;
+    keywords?: string;
+    length?: number;
+    mainCategories?: import("../types/storeApiTypes.js").components["schemas"]["MainCategory"][];
+    manufacturer?: import("../types/storeApiTypes.js").components["schemas"]["ProductManufacturer"];
+    manufacturerId?: string;
+    manufacturerNumber?: string;
+    markAsTopseller?: boolean;
+    maxPurchase?: number;
+    media?: import("../types/storeApiTypes.js").components["schemas"]["ProductMedia"][];
+    metaDescription?: string;
+    metaTitle?: string;
+    minPurchase?: number;
+    name: string;
+    optionIds?: readonly string[];
+    options?: import("../types/storeApiTypes.js").components["schemas"]["PropertyGroupOption"][];
+    packUnit?: string;
+    packUnitPlural?: string;
+    parent?: import("../types/storeApiTypes.js").components["schemas"]["Product"];
+    parentId?: string;
+    parentVersionId?: string;
+    productManufacturerVersionId?: string;
+    productMediaVersionId?: string;
+    productNumber: string;
+    productReviews?: import("../types/storeApiTypes.js").components["schemas"]["ProductReview"][];
+    properties?: import("../types/storeApiTypes.js").components["schemas"]["PropertyGroupOption"][];
+    propertyIds?: readonly string[];
+    purchaseSteps?: number;
+    purchaseUnit?: number;
+    ratingAverage?: number;
+    referenceUnit?: number;
+    releaseDate?: string;
+    restockTime?: number;
+    sales?: number;
+    seoCategory: import("../types/storeApiTypes.js").components["schemas"]["Category"];
+    seoUrls?: import("../types/storeApiTypes.js").components["schemas"]["SeoUrl"][];
+    shippingFree?: boolean;
+    sortedProperties?: import("../types/storeApiTypes.js").GenericRecord;
+    states?: readonly string[];
+    stock: number;
+    streamIds?: readonly string[];
+    streams?: import("../types/storeApiTypes.js").components["schemas"]["ProductStream"][];
+    tagIds?: readonly string[];
+    tags?: import("../types/storeApiTypes.js").components["schemas"]["Tag"][];
+    tax?: import("../types/storeApiTypes.js").components["schemas"]["Tax"];
+    taxId: string;
+    translated: {
+        apiAlias?: string;
+        canonicalProductId?: string;
+        canonicalProductVersionId?: string;
+        cmsPageId?: string;
+        cmsPageVersionId?: string;
+        coverId?: string;
+        deliveryTimeId?: string;
+        description?: string;
+        displayGroup?: string;
+        ean?: string;
+        keywords?: string;
+        manufacturerId?: string;
+        manufacturerNumber?: string;
+        metaDescription?: string;
+        metaTitle?: string;
+        name?: string;
+        packUnit?: string;
+        packUnitPlural?: string;
+        parentId?: string;
+        parentVersionId?: string;
+        productManufacturerVersionId?: string;
+        productMediaVersionId?: string;
+        productNumber?: string;
+        releaseDate?: string;
+        taxId?: string;
+        unitId?: string;
+        versionId?: string;
+    };
+    unit?: import("../types/storeApiTypes.js").components["schemas"]["Unit"];
+    unitId?: string;
+    updatedAt?: string;
+    variantListingConfig?: {
+        displayParent?: boolean;
+    } | null;
+    versionId?: string;
+    weight?: number;
+    width?: number;
+}[]>;

package/dist/runtime/server/shopware-helper/fetchAllProductVariants.js

@@ -0,0 +1,16 @@
+import { resolveProductFields } from "../orchestr-helper/requestedFields.js";
+export const fetchAllProducts = async (storefrontClient, { productIds, loadVariants }) => {
+  const fields = resolveProductFields({ loadVariants });
+  if (productIds.length === 0) {
+    return [];
+  }
+  const response = await storefrontClient.invoke("readProduct post /product", {
+    body: {
+      ids: productIds,
+      ...fields
+    }
+  });
+  const products = response.data.elements ?? [];
+  const all = [...products.flatMap((product) => product.children ?? []), ...products];
+  return all;
+};

package/dist/runtime/server/shopware-helper/getCart.d.ts

@@ -0,0 +1,10 @@
+import { StorefrontClient } from '../types/shopware.js';
+import { Schemas } from '../types/storeApiTypes.js';
+/**
+ * Fetch the current session cart from the Shopware store-api.
+ *
+ * The cart is identified per unique context session (the `sw-context-token`
+ * header/cookie set by the client factory). Callers cache the result in the
+ * `cartFragmentToken` passthrough so a single request resolves the cart once.
+ */
+export declare const getCart: (client: StorefrontClient) => Promise<Schemas["Cart"]>;

package/dist/runtime/server/shopware-helper/getCart.js

@@ -0,0 +1,4 @@
+export const getCart = async (client) => {
+  const cart = await client.invoke("readCart get /checkout/cart");
+  return cart.data;
+};

package/dist/runtime/server/shopware-helper/isShopwareId.d.ts

@@ -0,0 +1,4 @@
+/** This is not absolutely correct, but it's a good enough approximation. */
+export declare const isShopwareId: (id: string) => boolean;
+/** Extract the shopware id from a string. E.g. fallback slugs of format "slug-<shopware-id>" */
+export declare const extractShopwareId: (str: string) => string | undefined;

package/dist/runtime/server/shopware-helper/isShopwareId.js

@@ -0,0 +1,2 @@
+export const isShopwareId = (id) => /^[0-9a-f]{32}$/i.test(id);
+export const extractShopwareId = (str) => str.match(/([0-9a-f]{32})$/i)?.[1];

package/dist/runtime/server/shopware-helper/mappers/slugMapper.d.ts

@@ -0,0 +1,10 @@
+import { ShopwareCategory, ShopwareProduct, ShopwareSeoUrl, WithSeoUrl } from '../../types/shopware.js';
+/** Determine whether a given slug matches a seoPath */
+export declare const isSlugMatchingSeoPath: (slug: string, seoPath: string) => boolean;
+/** Return the canonical seoUrl or the first seoUrl if no canonical is available */
+export declare const findCanonicalSeoUrl: (seoUrls: ShopwareSeoUrl[]) => ShopwareSeoUrl;
+/** Map a generic entity with seoUrls to a slug */
+export declare const getEntitySeoSlug: (rawEntity: WithSeoUrl) => string | undefined;
+export declare const createFallbackSlug: (name: string, id: string) => string;
+/** Get slug of a product. Falls back to sluggified name if no seoUrl is available */
+export declare const entitySlug: (rawEntity: ShopwareProduct | ShopwareCategory) => string;

package/dist/runtime/server/shopware-helper/mappers/slugMapper.js

@@ -0,0 +1,9 @@
+import slug from "slug";
+import { swTranslated } from "../swTranslated.js";
+const extractSlugFromPath = (path) => path.replace(/\/+$/, "");
+const seoUrlToSlug = (seoUrl) => extractSlugFromPath(seoUrl.seoPathInfo);
+export const isSlugMatchingSeoPath = (slug2, seoPath) => extractSlugFromPath(seoPath).toLowerCase() === extractSlugFromPath(slug2).toLowerCase();
+export const findCanonicalSeoUrl = (seoUrls) => seoUrls.find((seoUrl) => seoUrl.isCanonical) ?? seoUrls[0];
+export const getEntitySeoSlug = (rawEntity) => rawEntity.seoUrls && rawEntity.seoUrls.length > 0 ? seoUrlToSlug(findCanonicalSeoUrl(rawEntity.seoUrls)) : void 0;
+export const createFallbackSlug = (name, id) => `${slug(name)}-${id}`;
+export const entitySlug = (rawEntity) => getEntitySeoSlug(rawEntity) ?? createFallbackSlug(swTranslated(rawEntity, "name"), rawEntity.id);

package/dist/runtime/server/shopware-helper/mediaMapper.d.ts

@@ -0,0 +1,8 @@
+import { Media, MediaSourceImage, MediaSourceVideo } from '@laioutr-core/core-types/common';
+import { Schemas } from '../types/storeApiTypes.js';
+type SwMedia = Schemas['Media'];
+export declare const mediaToSrc: (media: SwMedia) => string;
+export declare const mapMediaSourceImage: (media: SwMedia) => MediaSourceImage;
+export declare const mapMediaSourceVideo: (media: SwMedia) => MediaSourceVideo;
+export declare const mapMedia: (media: SwMedia) => Media;
+export {};

package/dist/runtime/server/shopware-helper/mediaMapper.js

@@ -0,0 +1,42 @@
+import { FALLBACK_IMAGE, FALLBACK_IMAGE_URL } from "../const/fallbacks.js";
+export const mediaToSrc = (media) => {
+  if ((!media.thumbnails || media.thumbnails.length === 0) && !media.url) {
+    return FALLBACK_IMAGE_URL;
+  }
+  const thumbnails = media.thumbnails ?? [];
+  const thumbnailSrc = thumbnails.map((thumb) => `${thumb.url} ${thumb.width}x${thumb.height}`);
+  const orgSrc = `${media.url} ${media.metaData?.width ?? 0}x${media.metaData?.height ?? 0}`;
+  return `${media.url}#${encodeURIComponent([...thumbnailSrc, orgSrc].join(", "))}`;
+};
+export const mapMediaSourceImage = (media) => {
+  const src = mediaToSrc(media);
+  if (src === FALLBACK_IMAGE_URL) {
+    return FALLBACK_IMAGE.sources[0];
+  }
+  return {
+    provider: "shopware",
+    width: media.metaData?.width ?? 100,
+    height: media.metaData?.height ?? 100,
+    src
+  };
+};
+export const mapMediaSourceVideo = (media) => ({
+  provider: "shopware",
+  src: media.url,
+  width: media.metaData?.width ?? 0,
+  height: media.metaData?.height ?? 0
+});
+export const mapMedia = (media) => {
+  const type = media.mimeType?.startsWith("video/") ? "video" : "image";
+  const source = type === "image" ? mapMediaSourceImage(media) : mapMediaSourceVideo(media);
+  return {
+    type,
+    // Shopware exposes both `alt` and `title`; prefer the explicit alt text and
+    // fall back to the title, treating blank/`null` as unset. This also keeps the
+    // value `string | undefined` (never `null`) — the canonical Media schema's `alt`
+    // rejects `null`, so an unset-alt asset would otherwise fail validation and be
+    // dropped by the media-library trust boundary (wrapProvider.sanitizeProviderItem).
+    alt: media.alt || media.title || void 0,
+    sources: [source]
+  };
+};

package/dist/runtime/server/shopware-helper/pageIndexEntries.d.ts

@@ -0,0 +1,20 @@
+import type { ShopwareCategory, ShopwareProduct } from '../types/shopware.js';
+import type { PageIndexEntry } from '@laioutr-core/core-types/orchestr';
+/**
+ * Shared by `query` entries and `locate` results so both describe a product page identically.
+ *
+ * `previewImage` is the cover media's **plain** URL, deliberately not `mapMedia`: its encoded srcset
+ * can't be dereferenced by the consumers that read `PageIndexEntry.meta.previewImage` (Cockpit picker,
+ * sitemaps, indexers), which all live outside the Nuxt image pipeline.
+ */
+export declare const toProductPageMeta: (product: ShopwareProduct) => PageIndexEntry["meta"];
+export declare const toProductPageEntry: (product: ShopwareProduct) => PageIndexEntry;
+/**
+ * Shared by `list`/`search` entries and `locate` results so both describe a category page identically.
+ *
+ * `previewImage` is the category media's plain URL for the same reason the product mapper uses one:
+ * the consumers that read it run outside the Nuxt image pipeline and cannot dereference an encoded
+ * srcset.
+ */
+export declare const toCategoryPageMeta: (category: ShopwareCategory) => PageIndexEntry["meta"];
+export declare const toCategoryPageEntry: (category: ShopwareCategory) => PageIndexEntry;

package/dist/runtime/server/shopware-helper/pageIndexEntries.js

@@ -0,0 +1,22 @@
+import { entitySlug } from "./mappers/slugMapper.js";
+import { swTranslated } from "./swTranslated.js";
+export const toProductPageMeta = (product) => ({
+  title: swTranslated(product, "name") ?? product.id,
+  previewImage: product.cover?.media?.url,
+  lastModified: product.updatedAt ?? void 0
+});
+export const toProductPageEntry = (product) => ({
+  params: { slug: entitySlug(product) },
+  subject: { type: "Product", id: product.id },
+  meta: toProductPageMeta(product)
+});
+export const toCategoryPageMeta = (category) => ({
+  title: swTranslated(category, "name") ?? category.name,
+  previewImage: category.media?.url,
+  lastModified: category.updatedAt ?? void 0
+});
+export const toCategoryPageEntry = (category) => ({
+  params: { slug: entitySlug(category) },
+  subject: { type: "Category", id: category.id },
+  meta: toCategoryPageMeta(category)
+});

package/dist/runtime/server/shopware-helper/persistContextToken.d.ts

@@ -0,0 +1,13 @@
+import type { H3Event } from 'h3';
+/**
+ * Persist / refresh the Shopware context-token cookie (httpOnly), then notify host-registered
+ * `shopware:context-token:changed` handlers so a project can mirror the token into its own
+ * session store. No-op when the response carries no token.
+ */
+export declare const persistContextToken: (event: H3Event, token: string | null | undefined) => Promise<void>;
+/**
+ * Clear the context-token cookie and notify host handlers with a null token, so a storefront
+ * logout ends laioutr's mirrored session too. The next store-api call re-bootstraps a guest
+ * context.
+ */
+export declare const clearContextToken: (event: H3Event) => Promise<void>;

package/dist/runtime/server/shopware-helper/persistContextToken.js

@@ -0,0 +1,12 @@
+import { contextTokenCookieOptions } from "./contextTokenCookie.js";
+import { deleteManagedCookie, setManagedCookie, useNitroApp } from "#imports";
+import { CONTEXT_TOKEN_COOKIE } from "../const/cookieKeys.js";
+export const persistContextToken = async (event, token) => {
+  if (!token) return;
+  setManagedCookie(event, CONTEXT_TOKEN_COOKIE, token, contextTokenCookieOptions());
+  await useNitroApp().hooks.callHook("shopware:context-token:changed", { event, token });
+};
+export const clearContextToken = async (event) => {
+  deleteManagedCookie(event, CONTEXT_TOKEN_COOKIE, { path: "/" });
+  await useNitroApp().hooks.callHook("shopware:context-token:changed", { event, token: null });
+};

package/dist/runtime/server/shopware-helper/productLocate.d.ts

@@ -0,0 +1,14 @@
+import type { PageIndexLocateResult } from '@laioutr-core/core-types/orchestr';
+/**
+ * Shape a product `locate` result from a resolved product id.
+ *
+ * `undefined` when the product could not be resolved, so the endpoint answers `null`. Without `meta`,
+ * consumers fall back to the route params.
+ *
+ * Pass `slugsByLocale` — a BCP-47 locale → slug map — only when every one of the project's locales
+ * was looked up. A missing key asserts the product has no page in that locale, which drops its
+ * hreflang alternate and sends the locale switcher to the homepage; omit the argument entirely while
+ * only the current locale is resolved, so consumers treat the rest as unknown. Locales with an empty
+ * slug are dropped from a map that is passed.
+ */
+export declare const buildProductLocate: (productId: string | undefined, meta?: PageIndexLocateResult["meta"], slugsByLocale?: Record<string, string | undefined>) => PageIndexLocateResult | undefined;

package/dist/runtime/server/shopware-helper/productLocate.js

@@ -0,0 +1,9 @@
+export const buildProductLocate = (productId, meta, slugsByLocale) => {
+  if (!productId) return void 0;
+  if (!slugsByLocale) return { subject: { type: "Product", id: productId }, meta };
+  const locales = {};
+  for (const [locale, slug] of Object.entries(slugsByLocale)) {
+    if (slug) locales[locale] = { params: { slug } };
+  }
+  return { subject: { type: "Product", id: productId }, meta, locales };
+};

package/dist/runtime/server/shopware-helper/readCategoryPageMeta.d.ts

@@ -0,0 +1,10 @@
+import type { StorefrontClient } from '../types/shopware.js';
+import type { PageIndexLocateResult } from '@laioutr-core/core-types/orchestr';
+/**
+ * Read a resolved category's page metadata for `pageIndex.locate`. Translations follow the client's
+ * `sw-language-id`, so the name comes back in the locale the lookup was made in.
+ *
+ * Swallows a missing category and a failed read — metadata is a labelling nicety and must never cost
+ * the caller the subject it already resolved.
+ */
+export declare const readCategoryPageMeta: (storefrontClient: StorefrontClient, categoryId: string) => Promise<PageIndexLocateResult["meta"]>;

package/dist/runtime/server/shopware-helper/readCategoryPageMeta.js

@@ -0,0 +1,19 @@
+import { toCategoryPageMeta } from "./pageIndexEntries.js";
+const metaCriteria = {
+  associations: { media: {} },
+  includes: {
+    category: ["id", "name", "translated", "updatedAt", "media"],
+    media: ["url"]
+  }
+};
+export const readCategoryPageMeta = async (storefrontClient, categoryId) => {
+  try {
+    const response = await storefrontClient.invoke("readCategoryList post /category", {
+      body: { ...metaCriteria, ids: [categoryId], limit: 1 }
+    });
+    const category = response.data.elements?.[0];
+    return category ? toCategoryPageMeta(category) : void 0;
+  } catch {
+    return void 0;
+  }
+};

package/dist/runtime/server/shopware-helper/readProductPageMeta.d.ts

@@ -0,0 +1,10 @@
+import type { StorefrontClient } from '../types/shopware.js';
+import type { PageIndexLocateResult } from '@laioutr-core/core-types/orchestr';
+/**
+ * Read a resolved product's page metadata for `pageIndex.locate`. Translations follow the client's
+ * `sw-language-id`, so the name comes back in the locale the lookup was made in.
+ *
+ * Swallows a missing product and a failed read — metadata is a labelling nicety and must never cost
+ * the caller the subject it already resolved.
+ */
+export declare const readProductPageMeta: (storefrontClient: StorefrontClient, productId: string) => Promise<PageIndexLocateResult["meta"]>;

package/dist/runtime/server/shopware-helper/readProductPageMeta.js

@@ -0,0 +1,20 @@
+import { toProductPageMeta } from "./pageIndexEntries.js";
+const metaCriteria = {
+  associations: { cover: {} },
+  includes: {
+    product: ["id", "name", "translated", "updatedAt", "cover"],
+    product_media: ["media"],
+    media: ["url"]
+  }
+};
+export const readProductPageMeta = async (storefrontClient, productId) => {
+  try {
+    const response = await storefrontClient.invoke("readProduct post /product", {
+      body: { ...metaCriteria, ids: [productId], limit: 1 }
+    });
+    const product = response.data.elements?.[0];
+    return product ? toProductPageMeta(product) : void 0;
+  } catch {
+    return void 0;
+  }
+};

package/dist/runtime/server/shopware-helper/resolveAdoptSession.d.ts

@@ -0,0 +1,23 @@
+import type { AdoptSessionTokenParams } from './adoptSession.js';
+export interface AdoptSessionDeps {
+    config: {
+        endpoint: string;
+        accessToken: string;
+    };
+    /** The `code` from a `laioutr:auth-changed` message; absent/empty means logout. */
+    code: string | null | undefined;
+    /** Injected {@link adoptSessionToken}. */
+    adopt: (params: AdoptSessionTokenParams) => Promise<string>;
+    /** Injected token persister (real: `persistContextToken` bound to the event). */
+    persist: (token: string) => Promise<void>;
+    /** Injected token clearer (real: `clearContextToken` bound to the event). */
+    clear: () => Promise<void>;
+}
+/**
+ * Decide how a `laioutr:auth-changed` message affects laioutr's stored session. Pure and
+ * free of `#imports` so the whole matrix is unit-testable: a `code` means login (redeem →
+ * persist); no `code` means logout (clear). The redeemed token stays server-side.
+ */
+export declare const adoptSession: (deps: AdoptSessionDeps) => Promise<{
+    authenticated: boolean;
+}>;

package/dist/runtime/server/shopware-helper/resolveAdoptSession.js

@@ -0,0 +1,13 @@
+export const adoptSession = async (deps) => {
+  if (!deps.code) {
+    await deps.clear();
+    return { authenticated: false };
+  }
+  const token = await deps.adopt({
+    endpoint: deps.config.endpoint,
+    accessToken: deps.config.accessToken,
+    code: deps.code
+  });
+  await deps.persist(token);
+  return { authenticated: true };
+};