@laioutr/app-shopware 0.14.4

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Laioutr GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# Shopware
+
+[![Laioutr][laioutr-src]][laioutr-href]
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+[Laioutr](https://laioutr.com) App integrating [Shopware 6](https://www.shopware.com) as the
+commerce backend for a Laioutr storefront, using Nuxt.
+
+See [laioutr.com](https://laioutr.com) for more information about Laioutr.
+
+- [✨  Release Notes](/CHANGELOG.md)
+
+## Features
+
+- Products, categories, menus, reviews and search served through Laioutr's Orchestr layer, mapped
+  onto the canonical entity model — so storefront components stay backend-agnostic
+- Cart as a first-class entity: add, update and remove items, with server-held Shopware context
+  tokens that never reach the browser
+- Embedded checkout — the Shopware storefront's own checkout rendered in-page, with a same-origin
+  session handoff so the visitor is never bounced to another domain
+- Auth bridge: a storefront login or logout inside the embedded checkout propagates back into the
+  Laioutr session, and hooks let a host app mirror it into an external IdP
+- Page indexes for product detail and category listing pages, so Studio can resolve a URL to the
+  entity behind it
+- Shopware media as a Laioutr media library, plus a `@nuxt/image` provider that serves Shopware's
+  own thumbnails
+- Newsletter subscription and review submission as Orchestr actions
+
+## Requirements
+
+- A Shopware 6 instance with the Store API enabled
+- An [Admin API integration](https://developer.shopware.com/docs/guides/integrations-api/) — used
+  for the media library and for reading the sales channel's currency and language
+- [`LaioutrConnector`](https://github.com/laioutr/shopware-laioutr-connector), the companion
+  Shopware plugin. Required for checkout: it exposes the `connect-session` route that redeems the
+  single-use handoff code and adopts the cart into a storefront session. Without it, product,
+  category, menu and search still work; `checkoutLink` and `GetCheckoutUrlAction` do not.
+
+## Configuration
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@laioutr/app-shopware'],
+  '@laioutr/app-shopware': {
+    endpoint: 'https://shop.example.com/store-api',
+    accessToken: 'SWSC...',
+    adminEndpoint: 'https://shop.example.com/api',
+    adminClientId: 'SWIA...',
+    adminClientSecret: '...',
+    storefrontUrl: 'https://shop.example.com',
+  },
+});
+```
+
+| Option | Required | Purpose |
+| --- | --- | --- |
+| `endpoint` | yes | Store API base URL, `https://<host>/store-api`. |
+| `accessToken` | yes | Sales channel access token. |
+| `adminEndpoint` | yes | Admin API base URL, `https://<host>/api`. |
+| `adminClientId` | yes | Admin API integration ID. |
+| `adminClientSecret` | yes | Admin API integration secret. |
+| `storefrontUrl` | for checkout | Storefront base URL where `LaioutrConnector` is installed. Its origin is exposed publicly so the embedded checkout can pin `postMessage` traffic. |
+| `checkoutLoginCallbackUrl` | no | Absolute URL the storefront returns to after a login inside checkout. Defaults to the request origin; point it at the project's IdP login route for external-IdP projects. |
+| `checkoutLogoutCallbackUrl` | no | Absolute URL the storefront returns to after a logout inside checkout. Point it at the IdP's RP-logout route so a storefront logout ends the external session too. |
+
+`accessToken`, `adminClientId` and `adminClientSecret` are secrets and stay server-side: they land
+in the private runtime config, and only `storefrontUrl`'s origin is exposed publicly. Read them
+from the environment rather than committing them to `nuxt.config.ts`.
+
+## Checkout
+
+The app registers a `Checkout` page type. Tag one page with it in Studio and drop the
+**Shopware Checkout** section on it; the cart's `checkoutLink` resolves to that page, so nothing
+in the storefront needs to know its slug.
+
+Two same-origin routes carry the handoff, both under the app's `/app-shopware/` namespace:
+
+| Route | Purpose |
+| --- | --- |
+| `GET /app-shopware/checkout` | Mints a single-use handoff code server-side and redirects to the storefront's `connect-session`, which adopts the cart and lands on the confirm page. |
+| `POST /app-shopware/adopt-session` | Called by the checkout section when the embedded storefront reports a login or logout, so the new session is adopted (or cleared) server-side. |
+
+The Shopware context token is held server-side and passed by code, never by URL and never in the
+browser — a code is redeemed once and cannot be replayed.
+
+### Session hooks
+
+A host app that owns its own session store can take over token custody through two Nitro hooks:
+
+```ts
+// server/plugins/shopware-session.ts
+export default defineNitroPlugin((nitro) => {
+  // Bail hook: supply the context token from your own store. The cookie is the fallback.
+  // Read-only — it must not mint a token.
+  nitro.hooks.hook('shopware:context-token:resolve', ({ event, result }) => {
+    result.token = mySessionStore.get(event);
+  });
+
+  // Fired after the token is persisted (`token` is the new value) or cleared on a
+  // storefront logout (`token` is `null`).
+  nitro.hooks.hook('shopware:context-token:changed', ({ event, token }) => {
+    token ? mySessionStore.set(event, token) : mySessionStore.clear(event);
+  });
+});
+```
+
+## Development
+
+```bash
+pnpm install
+cp .env.example .env   # point it at a Shopware instance
+pnpm dev               # playground on http://localhost:3000
+pnpm test
+pnpm lint
+```
+
+`@laioutr-core/*` and `@laioutr-app/ui` resolve from Laioutr's registry. Before installing, render
+the template with your token:
+
+```bash
+sed "s|NPM_LAIOUTR_TOKEN|$YOUR_TOKEN|" .npmrc.config > .npmrc
+```
+
+Releases go through [changesets](https://github.com/changesets/changesets): run `pnpm changeset` to
+describe your change, and merging the generated "Version Packages" PR publishes to npm.
+
+## License
+
+[MIT](./LICENSE.md) — Laioutr GmbH
+
+<!-- Badges -->
+
+[laioutr-src]: https://img.shields.io/badge/Laioutr-App-000?style=flat&labelColor=020420
+[laioutr-href]: https://laioutr.com
+[npm-version-src]: https://img.shields.io/npm/v/@laioutr/app-shopware/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/@laioutr/app-shopware
+[npm-downloads-src]: https://img.shields.io/npm/dm/@laioutr/app-shopware.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npmjs.com/package/@laioutr/app-shopware
+[license-src]: https://img.shields.io/npm/l/@laioutr/app-shopware.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/@laioutr/app-shopware
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,88 @@
+import { HookResult, NuxtModule } from '@nuxt/schema';
+import { H3Event } from 'h3';
+
+declare module 'vue' {
+    interface GlobalComponents {
+    }
+    interface ComponentCustomProperties {
+    }
+}
+declare module '@nuxt/schema' {
+    interface PublicRuntimeConfig {
+        ['@laioutr/app-shopware']: RuntimeConfigModulePublic;
+    }
+    interface RuntimeConfig {
+        ['@laioutr/app-shopware']: RuntimeConfigModulePrivate;
+    }
+}
+declare module 'nitropack' {
+    interface NitroRuntimeHooks {
+        /**
+         * Fetch (bail): a host handler may set `result.token` to supply the Shopware context token
+         * from its own session store; the cookie is the fallback. Read-only; must NOT mint a token.
+         */
+        'shopware:context-token:resolve': (args: {
+            event: H3Event;
+            result: {
+                token?: string;
+            };
+        }) => HookResult;
+        /**
+         * Notification: fired after the context token is (re)persisted (`token` is the new value) or
+         * cleared on a storefront logout (`token` is `null`), so a host can mirror the change into its
+         * own store (e.g. keyed by the external IdP subject) — persisting on a value, clearing on null.
+         */
+        'shopware:context-token:changed': (args: {
+            event: H3Event;
+            token: string | null;
+        }) => HookResult;
+    }
+}
+
+/**
+ * The options the module adds to the nuxt.config.ts.
+ */
+interface ModuleOptions {
+    endpoint: string;
+    accessToken: string;
+    adminEndpoint: string;
+    adminClientId: string;
+    adminClientSecret: string;
+    /**
+     * Base URL of the Shopware storefront where the LaioutrConnector plugin is installed
+     * (e.g. `https://shop.example.com`). Required for `GetCheckoutUrlAction` / the cart
+     * `checkoutLink`; those are unavailable when it is unset.
+     */
+    storefrontUrl?: string;
+    /**
+     * Absolute URL the storefront returns to after a login inside checkout. Defaults to the
+     * request origin. Set to the project's IdP login route for external-IdP (SSO) projects.
+     */
+    checkoutLoginCallbackUrl?: string;
+    /**
+     * Absolute URL the storefront returns to after a logout inside checkout. Defaults to the
+     * request origin. Set to the project's IdP RP-logout route so a storefront logout ends the
+     * external session too.
+     */
+    checkoutLogoutCallbackUrl?: string;
+}
+/**
+ * The config the module adds to nuxt.runtimeConfig.public['@laioutr/app-shopware']
+ */
+interface RuntimeConfigModulePublic {
+    /**
+     * Origin (scheme + host) of the Shopware storefront, derived from {@link
+     * ModuleOptions.storefrontUrl}. Exposed publicly so the embedded checkout section can
+     * validate and pin `postMessage` traffic to the storefront frame. Empty when unset.
+     */
+    storefrontOrigin: string;
+}
+/**
+ * The config the module adds to nuxt.runtimeConfig['@laioutr/app-shopware']
+ */
+interface RuntimeConfigModulePrivate extends ModuleOptions {
+}
+declare const module$1: NuxtModule<ModuleOptions>;
+
+export { module$1 as default };
+export type { ModuleOptions, RuntimeConfigModulePrivate, RuntimeConfigModulePublic };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "@laioutr/app-shopware",
+  "version": "0.14.4",
+  "configKey": "@laioutr/app-shopware",
+  "builder": {
+    "@nuxt/module-builder": "1.0.1",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,60 @@
+import { defineNuxtModule, createResolver, addServerHandler, addPlugin, installModule } from '@nuxt/kit';
+import { defu } from 'defu';
+import { CHECKOUT_ENDPOINT_PATH, ADOPT_SESSION_ENDPOINT_PATH } from '../dist/runtime/server/const/checkout.js';
+import { registerLaioutrApp } from '@laioutr-core/kit';
+
+const name = "@laioutr/app-shopware";
+const version = "0.14.4";
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: name
+  },
+  async setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    const resolveRuntimeModule = (path) => resolve("./runtime", path);
+    nuxt.options.build.transpile.push(resolve("./runtime"));
+    nuxt.options.runtimeConfig[name] = defu(nuxt.options.runtimeConfig[name], options);
+    nuxt.options.runtimeConfig.public[name] = defu(nuxt.options.runtimeConfig.public[name], {
+      storefrontOrigin: options.storefrontUrl ? new URL(options.storefrontUrl).origin : ""
+    });
+    nuxt.options.nitro.publicAssets ??= [];
+    nuxt.options.nitro.publicAssets.push({
+      dir: resolveRuntimeModule("./app/public"),
+      maxAge: 60 * 60 * 24 * 7
+      // 7 days
+    });
+    addServerHandler({
+      route: CHECKOUT_ENDPOINT_PATH,
+      method: "get",
+      handler: resolveRuntimeModule("./server/routes/checkout")
+    });
+    addServerHandler({
+      route: ADOPT_SESSION_ENDPOINT_PATH,
+      method: "post",
+      handler: resolveRuntimeModule("./server/routes/adopt-session.post")
+    });
+    await registerLaioutrApp({
+      name,
+      version,
+      orchestrDirs: [resolveRuntimeModule("server/orchestr")],
+      sections: [resolveRuntimeModule("app/sections/")],
+      nuxtImageProviders: {
+        shopware: {
+          name: "shopware",
+          provider: resolveRuntimeModule("./app/image/providers/shopware")
+        }
+      },
+      mediaLibraryProviders: [resolveRuntimeModule("./server/media-libraries/shopware")]
+    });
+    addPlugin(resolveRuntimeModule("./app/plugins/pagetypes"));
+    if (nuxt.options._prepare) {
+      await installModule("@laioutr-core/frontend-core");
+      await installModule("@laioutr-app/ui");
+    }
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/app/components/ShopwareEmbedFrame.d.vue.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "checkout-finish": (orderId: string) => any;
+    "auth-changed": (payload: {
+        from: string;
+        code?: string;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    "onCheckout-finish"?: ((orderId: string) => any) | undefined;
+    "onAuth-changed"?: ((payload: {
+        from: string;
+        code?: string;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/app/components/ShopwareEmbedFrame.vue

@@ -0,0 +1,57 @@
+<script setup>
+import { computed, ref, useRuntimeConfig } from "#imports";
+import { CHECKOUT_ENDPOINT_PATH } from "../../shared/const/checkout";
+import { useShopwareEmbedBridge } from "../composables/useShopwareEmbedBridge";
+const emit = defineEmits(["checkout-finish", "auth-changed"]);
+const storefrontOrigin = computed(() => useRuntimeConfig().public["@laioutr/app-shopware"]?.storefrontOrigin ?? "");
+const frameRef = ref(null);
+const height = ref();
+const loaded = ref(false);
+let hasShownFramePage = false;
+const onFramePageLoaded = () => {
+  loaded.value = true;
+  if (hasShownFramePage) {
+    window.scrollTo({ top: 0, left: 0 });
+  }
+  hasShownFramePage = true;
+};
+const { sendInit } = useShopwareEmbedBridge(frameRef, {
+  storefrontOrigin: storefrontOrigin.value,
+  onResize: (value) => height.value = value,
+  onPageLoaded: onFramePageLoaded,
+  onCheckoutFinish: (orderId) => emit("checkout-finish", orderId),
+  onAuthChanged: (payload) => emit("auth-changed", payload)
+  // laioutr:pw-recovery is received but unused in v1.
+});
+const onFrameLoad = () => {
+  loaded.value = true;
+  sendInit();
+};
+const frameStyle = computed(() => ({ height: height.value ? `${height.value}px` : "600px" }));
+</script>
+
+<template>
+  <div class="shopware-embed-frame">
+    <div v-if="!storefrontOrigin" class="shopware-embed-frame__notice">
+      The Shopware storefront URL is not configured, so the checkout cannot be embedded.
+    </div>
+    <template v-else>
+      <div v-if="!loaded" class="shopware-embed-frame__loading" role="status">
+        <LLoadingSpinner variant="row" />
+        <span class="shopware-embed-frame__loading-label">Loading checkout…</span>
+      </div>
+      <iframe
+        ref="frameRef"
+        :src="CHECKOUT_ENDPOINT_PATH"
+        title="Checkout"
+        class="shopware-embed-frame__iframe"
+        :style="frameStyle"
+        @load="onFrameLoad"
+      />
+    </template>
+  </div>
+</template>
+
+<style scoped>
+.shopware-embed-frame{position:relative}.shopware-embed-frame__iframe{border:0;display:block;width:100%}.shopware-embed-frame__notice{padding:1rem;text-align:center}.shopware-embed-frame__loading{align-items:center;background:var(--background-default);display:flex;flex-direction:column;gap:.75rem;inset:0;justify-content:center;padding:1rem;position:absolute;z-index:1}.shopware-embed-frame__loading-label{font-size:.875rem;opacity:.7}
+</style>

package/dist/runtime/app/components/ShopwareEmbedFrame.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "checkout-finish": (orderId: string) => any;
+    "auth-changed": (payload: {
+        from: string;
+        code?: string;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    "onCheckout-finish"?: ((orderId: string) => any) | undefined;
+    "onAuth-changed"?: ((payload: {
+        from: string;
+        code?: string;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/app/composables/useShopwareEmbedBridge.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from 'vue';
+import { type AuthChangedPayload, type BridgePageLoadedPayload } from '../const/bridge.js';
+export type UseShopwareEmbedBridgeOptions = {
+    /** Configured storefront origin; inbound messages are validated (pinned) against it. */
+    storefrontOrigin: string;
+    onResize?: (height: number) => void;
+    onPageLoaded?: (payload: BridgePageLoadedPayload) => void;
+    onCheckoutFinish?: (orderId: string) => void;
+    onPwRecovery?: () => void;
+    onAuthChanged?: (payload: AuthChangedPayload) => void;
+};
+/**
+ * Wires the parent side of the storefront `postMessage` bridge to the real `window`
+ * `message` event for the lifetime of the calling component. All decision logic lives in
+ * {@link createBridgeHandler} (unit-tested); this only adds/removes the listener and posts
+ * through the frame's `contentWindow`.
+ *
+ * Returns `sendInit` — call it on the iframe's `load` event to proactively complete the
+ * handshake, since the plugin's one-shot `ready` can fire before this listener attaches
+ * (the SSR iframe loads before Vue hydrates).
+ */
+export declare const useShopwareEmbedBridge: (frameRef: Ref<HTMLIFrameElement | null>, options: UseShopwareEmbedBridgeOptions) => {
+    sendInit: () => void;
+};

package/dist/runtime/app/composables/useShopwareEmbedBridge.js

@@ -0,0 +1,22 @@
+import { onBeforeUnmount, onMounted } from "vue";
+import { buildInitMessage } from "../const/bridge.js";
+import { createBridgeHandler } from "../lib/createBridgeHandler.js";
+export const useShopwareEmbedBridge = (frameRef, options) => {
+  const { handleMessage, sendInit } = createBridgeHandler({
+    getFrameWindow: () => frameRef.value?.contentWindow ?? null,
+    storefrontOrigin: options.storefrontOrigin,
+    postInit: (frameWindow, targetOrigin) => frameWindow.postMessage(buildInitMessage(), targetOrigin),
+    onResize: options.onResize,
+    onPageLoaded: options.onPageLoaded,
+    onCheckoutFinish: options.onCheckoutFinish,
+    onPwRecovery: options.onPwRecovery,
+    onAuthChanged: options.onAuthChanged
+  });
+  const listener = (event) => handleMessage(event);
+  onMounted(() => {
+    window.addEventListener("message", listener);
+    sendInit();
+  });
+  onBeforeUnmount(() => window.removeEventListener("message", listener));
+  return { sendInit };
+};

package/dist/runtime/app/const/bridge.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared postMessage contract with the LaioutrConnector storefront bridge
+ * (`Resources/public/laioutr-embed.js` in the `shopware-laioutr-integration` plugin).
+ *
+ * Every message uses the envelope `{ source, version, type, payload }`. The `source`
+ * discriminator lets each side ignore unrelated postMessage traffic; `version` guards
+ * against contract drift. Keep these constants in lock-step with the plugin's bridge.
+ */
+export declare const BRIDGE_SOURCE = "laioutr-shopware";
+export declare const BRIDGE_VERSION = 1;
+/** Handshake reply this (parent) frame posts to pin the storefront origin. */
+export declare const BRIDGE_INIT_TYPE = "laioutr:init";
+/** Messages the storefront bridge sends to this (parent) frame. */
+export type BridgeInboundMessage = {
+    type: 'laioutr:ready';
+    payload: Record<string, never>;
+} | {
+    type: 'laioutr:resize';
+    payload: {
+        height: number;
+    };
+} | {
+    type: 'laioutr:page-loaded';
+    payload: {
+        path: string;
+        route: string | null;
+        navigationId: string | null;
+        salesChannelId: string | null;
+    };
+} | {
+    type: 'laioutr:checkout-finish';
+    payload: {
+        orderId: string;
+    };
+} | {
+    type: 'laioutr:pw-recovery';
+    payload: Record<string, never>;
+} | {
+    type: 'laioutr:auth-changed';
+    payload: {
+        from: string;
+        code?: string;
+    };
+};
+export type BridgeInboundType = BridgeInboundMessage['type'];
+export type BridgePageLoadedPayload = Extract<BridgeInboundMessage, {
+    type: 'laioutr:page-loaded';
+}>['payload'];
+export type AuthChangedPayload = Extract<BridgeInboundMessage, {
+    type: 'laioutr:auth-changed';
+}>['payload'];
+/** The full envelope as it arrives on `MessageEvent.data`. */
+export type BridgeEnvelope = {
+    source: typeof BRIDGE_SOURCE;
+    version: typeof BRIDGE_VERSION;
+} & BridgeInboundMessage;
+/** The contentless handshake reply, posted to the pinned storefront origin. */
+export declare const buildInitMessage: () => {
+    source: string;
+    version: number;
+    type: string;
+    payload: {};
+};

package/dist/runtime/app/const/bridge.js

@@ -0,0 +1,9 @@
+export const BRIDGE_SOURCE = "laioutr-shopware";
+export const BRIDGE_VERSION = 1;
+export const BRIDGE_INIT_TYPE = "laioutr:init";
+export const buildInitMessage = () => ({
+  source: BRIDGE_SOURCE,
+  version: BRIDGE_VERSION,
+  type: BRIDGE_INIT_TYPE,
+  payload: {}
+});

package/dist/runtime/app/image/providers/shopware.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderGetImage } from '@nuxt/image';
+/**
+ * Nuxt image provider using shopware thumbnails.
+ *
+ * The only modifications supported are "width" and "height". The provider tries to find a best-fit image from the available shopware thumbnails.
+ */
+export declare const getImage: ProviderGetImage;

package/dist/runtime/app/image/providers/shopware.js

@@ -0,0 +1,44 @@
+const THUMBNAIL_MATCH_TOLERANCE = 2;
+const matchThumbnail = (thumbnails, options) => {
+  if (!thumbnails.length) {
+    return void 0;
+  }
+  const { width, height } = options;
+  if (!width && !height) {
+    return thumbnails.at(-1);
+  }
+  const matchingThumbnail = thumbnails.find((thumbnail) => {
+    const thumbnailWidth = Math.max(thumbnail.width - THUMBNAIL_MATCH_TOLERANCE, 0);
+    const thumbnailHeight = Math.max(thumbnail.height - THUMBNAIL_MATCH_TOLERANCE, 0);
+    if (width && !height && thumbnailWidth >= width) {
+      return true;
+    }
+    if (!width && height && thumbnailHeight >= height) {
+      return true;
+    }
+    if (width && height && thumbnailWidth >= width && thumbnailHeight >= height) {
+      return true;
+    }
+    return false;
+  });
+  return matchingThumbnail ?? thumbnails.at(-1);
+};
+export const getImage = (src, options = {}) => {
+  const [orgSrc, rawThumbnailSrc] = src.split("#");
+  const thumbnailSrc = decodeURIComponent(rawThumbnailSrc ?? "");
+  const thumbnails = thumbnailSrc ? thumbnailSrc.split(", ").map((thumbnail) => {
+    const [url, size] = thumbnail.split(" ");
+    const [width, height] = size?.split("x").map(Number.parseInt).filter((num) => !Number.isNaN(num)) ?? [0, 0];
+    return {
+      url,
+      width: width ?? height ?? 0,
+      height: height ?? width ?? 0
+    };
+  }).sort((a, b) => a.width - b.width) : [];
+  const match = matchThumbnail(thumbnails, options.modifiers ?? {});
+  return {
+    url: match?.url ?? orgSrc,
+    width: match?.width ?? 0,
+    height: match?.height ?? 0
+  };
+};

package/dist/runtime/app/lib/createBridgeHandler.d.ts

@@ -0,0 +1,44 @@
+import { type AuthChangedPayload, type BridgePageLoadedPayload } from '../const/bridge.js';
+/** Minimal `MessageEvent` shape the handler reads — kept structural so it's testable without a DOM. */
+export type BridgeMessageEvent = {
+    source: unknown;
+    origin: string;
+    data: unknown;
+};
+export type CreateBridgeHandlerOptions = {
+    /** The embedded frame's content window, or `null` before it mounts. */
+    getFrameWindow: () => Window | null;
+    /** Configured storefront origin; inbound messages are validated (pinned) against it. */
+    storefrontOrigin: string;
+    /** Post the contentless handshake reply to the (validated) origin. */
+    postInit: (frameWindow: Window, targetOrigin: string) => void;
+    onResize?: (height: number) => void;
+    onPageLoaded?: (payload: BridgePageLoadedPayload) => void;
+    onCheckoutFinish?: (orderId: string) => void;
+    onPwRecovery?: () => void;
+    onAuthChanged?: (payload: AuthChangedPayload) => void;
+};
+/**
+ * The parent side of the storefront `postMessage` bridge, as a pure message dispatcher.
+ *
+ * Every inbound message must clear three gates before it is acted on:
+ * 1. **Identity** — `event.source` is our embedded frame's window (not some other frame).
+ * 2. **Origin** — `event.origin` matches the configured storefront origin (the pin).
+ * 3. **Envelope** — `parseBridgeMessage` accepts the `{ source, version, type, payload }`.
+ *
+ * On the storefront's contentless `laioutr:ready` ping it replies `laioutr:init` to the
+ * validated origin, which unblocks the plugin's buffered data messages.
+ *
+ * `ready` is a **one-shot** broadcast, and the server-rendered iframe can fire it before
+ * this listener is attached (the browser loads the iframe before Vue hydrates). So the
+ * handshake must not depend on catching it: {@link sendInit} lets the caller *proactively*
+ * post `init` to the configured origin once the frame has loaded. Both paths are
+ * idempotent — the plugin just re-pins and re-flushes.
+ *
+ * All logic lives here (no `window`, no Vue) so it is unit-testable; `useShopwareEmbedBridge`
+ * only wires it to the real `window` `message` event and the component lifecycle.
+ */
+export declare const createBridgeHandler: (options: CreateBridgeHandlerOptions) => {
+    handleMessage: (event: BridgeMessageEvent) => void;
+    sendInit: () => void;
+};