@coveo/headless 3.28.4-pre.d32ce92b15 → 3.28.4-pre.d4e891a69f

package/dist/cjs/ssr-next/headless.cjs

@@ -1306,7 +1306,7 @@ var import_toolkit2 = require("@reduxjs/toolkit");
 var import_toolkit = require("@reduxjs/toolkit");
 
 // src/utils/version.ts
-var VERSION = "3.28.4-pre.d32ce92b15";
+var VERSION = "3.28.4-pre.d4e891a69f";
 var COVEO_FRAMEWORK = ["@coveo/atomic", "@coveo/quantic"];
 
 // src/api/analytics/analytics-selectors.ts

package/dist/definitions/api/commerce/common/product.d.ts

@@ -130,6 +130,10 @@ export interface BaseProduct {
      * The length and offset of each word to highlight in the product excerpt string.
      */
     excerptsHighlights?: HighlightKeyword[];
+    /**
+     * The ID of the response that returned the product.
+     */
+    responseId?: string;
 }
 export interface Product extends BaseProduct {
     /**

package/dist/definitions/ssr-commerce-next.index.d.ts

@@ -93,7 +93,7 @@ export type { InstantProducts, InstantProductsDefinition, InstantProductsOptions
 export { defineInstantProducts } from './ssr-next/commerce/controllers/instant-products/headless-instant-products.ssr.js';
 export type { CorePaginationOptions, Pagination, PaginationOptions, PaginationProps, PaginationState, } from './ssr-next/commerce/controllers/pagination/headless-core-commerce-pagination.ssr.js';
 export { definePagination } from './ssr-next/commerce/controllers/pagination/headless-core-commerce-pagination.ssr.js';
-export type { CommerceSearchParameters, ParameterManager, ParameterManagerProps, ParameterManagerState, Parameters, ProductListingParameters, SSRParameterManagerProps, } from './ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.js';
+export type { CommerceSearchParameters, ParameterManager, ParameterManagerDefinition, ParameterManagerProps, ParameterManagerState, Parameters, ProductListingParameters, SSRParameterManagerProps, } from './ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.js';
 export { defineParameterManager } from './ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.js';
 export type { ProductList, ProductListing, ProductListState, Search, } from './ssr-next/commerce/controllers/product-list/headless-product-list.ssr.js';
 export { defineProductList } from './ssr-next/commerce/controllers/product-list/headless-product-list.ssr.js';

package/dist/definitions/ssr-next/commerce/controller-utils.d.ts

@@ -1,19 +1,18 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
 import type { Controller } from '../../controllers/controller/headless-controller.js';
-import type { ControllersMap } from '../common/types/controllers.js';
 import type { SSRCommerceEngine } from './factories/build-factory.js';
 import type { SolutionType } from './types/controller-constants.js';
-import type { ControllerDefinitionOption, ControllerDefinitionsMap, InferControllerStaticStateMapFromControllers } from './types/controller-definitions.js';
-import type { InferControllerPropsMapFromDefinitions, InferControllersMapFromDefinition } from './types/controller-inference.js';
+import type { ControllerDefinitionOption, ControllerDefinitionsMap } from './types/controller-definitions.js';
+import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromDefinitionsWithSolutionType, InferControllersMapFromDefinition } from './types/controller-inference.js';
 import type { EngineStaticState } from './types/engine.js';
-export declare function createStaticState<TSearchAction extends UnknownAction>({ searchActions, controllers, }: {
+export declare function createStaticState<TSearchAction extends UnknownAction, TControllerDefinitions extends ControllerDefinitionsMap<Controller>>({ searchActions, controllers, }: {
     searchActions: TSearchAction[];
-    controllers: ControllersMap;
-}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromControllers<ControllersMap>>;
+    controllers: InferControllersMapFromDefinition<TControllerDefinitions, SolutionType>;
+}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllerDefinitions, SolutionType>>;
 export declare function buildControllerDefinitions<TControllerDefinitionsMap extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType>({ definitionsMap, engine, solutionType, propsMap, }: {
     definitionsMap: TControllerDefinitionsMap;
     engine: SSRCommerceEngine;
     solutionType: TSolutionType;
-    propsMap: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
+    propsMap?: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
 }): InferControllersMapFromDefinition<TControllerDefinitionsMap, TSolutionType>;
 export declare function ensureAtLeastOneSolutionType(options?: ControllerDefinitionOption): void;

package/dist/definitions/ssr-next/commerce/controllers/context/headless-context.ssr.d.ts

@@ -1,7 +1,9 @@
 import { type Context, type ContextOptions, type ContextProps, type ContextState, type UserLocation, type View } from '../../../../controllers/commerce/context/headless-context.js';
 import type { UniversalControllerDefinitionWithProps } from '../../types/controller-definitions.js';
 export type { Context, ContextProps, ContextState, View, UserLocation, ContextOptions, };
-export interface ContextDefinition extends UniversalControllerDefinitionWithProps<Context, ContextOptions> {
+export interface ContextDefinition extends UniversalControllerDefinitionWithProps<Context, {
+    initialState: ContextOptions;
+}> {
 }
 /**
  * Defines a `Context` controller instance.

package/dist/definitions/ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.d.ts

@@ -4,13 +4,14 @@ import type { ProductListingParameters } from '../../../../features/commerce/pro
 import type { CommerceSearchParameters } from '../../../../features/commerce/search-parameters/search-parameters-actions.js';
 import type { ControllerDefinitionOption, SubControllerDefinitionWithProps } from '../../types/controller-definitions.js';
 export type { ParameterManager, ParameterManagerProps, ParameterManagerState, Parameters, ProductListingParameters, CommerceSearchParameters, };
+export type ParameterManagerDefinition<TOptions extends ControllerDefinitionOption | undefined> = SubControllerDefinitionWithProps<ParameterManager<MappedParameterTypes<TOptions>>, TOptions, SSRParameterManagerProps<MappedParameterTypes<TOptions>>>;
 /**
  * Defines a `ParameterManager` controller instance.
  * @group Definers
  *
  * @returns The `ParameterManager` controller definition.
  */
-export declare function defineParameterManager<TOptions extends ControllerDefinitionOption | undefined>(options?: TOptions): SubControllerDefinitionWithProps<ParameterManager<MappedParameterTypes<TOptions>>, TOptions, SSRParameterManagerProps<MappedParameterTypes<TOptions>>>;
+export declare function defineParameterManager<TOptions extends ControllerDefinitionOption | undefined>(options?: TOptions): ParameterManagerDefinition<TOptions>;
 export interface SSRParameterManagerProps<T extends Parameters> extends Omit<ParameterManagerProps<T>, 'excludeDefaultParameters'> {
 }
 type MappedParameterTypes<TOptions extends ControllerDefinitionOption | undefined> = TOptions extends {

package/dist/definitions/ssr-next/commerce/types/controller-inference.d.ts

@@ -8,7 +8,7 @@ export type InferStaticState<T extends {
 export type InferHydratedState<T extends {
     hydrateStaticState(...args: unknown[]): Promise<unknown>;
 }> = Awaited<ReturnType<T['hydrateStaticState']>>;
-export type InferControllerPropsFromDefinition<TController extends ControllerDefinition<Controller>> = TController extends ControllerDefinitionWithProps<Controller, infer Props> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? Props : Props & RecommendationControllerSettings : TController extends ControllerDefinitionWithoutProps<Controller> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? {} : RecommendationControllerSettings : unknown;
+type InferControllerPropsFromDefinition<TController extends ControllerDefinition<Controller>> = TController extends ControllerDefinitionWithProps<Controller, infer Props> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? Props : Props & RecommendationControllerSettings : TController extends ControllerDefinitionWithoutProps<Controller> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? {} : RecommendationControllerSettings : unknown;
 export type InferControllerPropsMapFromDefinitions<TControllers extends ControllerDefinitionsMap<Controller>> = {
     [K in keyof TControllers as HasKeys<InferControllerPropsFromDefinition<TControllers[K]>> extends false ? never : K]: InferControllerPropsFromDefinition<TControllers[K]>;
 };
@@ -17,5 +17,6 @@ export type InferControllersMapFromDefinition<TControllers extends ControllerDef
     [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerFromDefinition<TControllers[K]>;
 };
 export type InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllers extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
-    [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>>;
+    [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>> & InferControllerPropsFromDefinition<TControllers[K]>;
 };
+export {};

package/dist/definitions/ssr-next/common/builders/controller-builder.d.ts

@@ -0,0 +1,17 @@
+import type { CoreEngine, CoreEngineNext } from '../../../app/engine.js';
+import type { Controller } from '../../../controllers/controller/headless-controller.js';
+import type { BaseControllerDefinitionWithoutProps, BaseControllerDefinitionWithProps } from '../types/controllers.js';
+/**
+ * Builder class for creating controllers from definitions
+ */
+export declare class ControllerBuilder<TDefinition extends Partial<BaseControllerDefinitionWithoutProps<TEngine, TController>> & Partial<BaseControllerDefinitionWithProps<TEngine, TController, TProps>>, TEngine extends CoreEngine | CoreEngineNext, TProps, TController extends Controller = Controller> {
+    private _definition;
+    private _engine;
+    private _props?;
+    private _additionalArgs;
+    constructor(definition: TDefinition, engine: TEngine, props?: TProps);
+    withAdditionalArgs(additionalArgs?: unknown[]): this;
+    build(): TController;
+    private buildWithoutProps;
+    private buildWithProps;
+}

package/dist/definitions/ssr-next/common/builders/static-controller-builder.d.ts

@@ -0,0 +1,24 @@
+import type { Controller } from '../../../controllers/controller/headless-controller.js';
+import type { ControllerWithKind } from '../../commerce/types/controller-definitions.js';
+import type { Kind } from '../../commerce/types/kind.js';
+export type StaticControllerState = {
+    initialState?: Controller['state'];
+    _kind?: Kind;
+} & Pick<ControllerWithKind, 'state'>;
+/**
+ * Builder class for creating static controller
+ */
+declare class StaticControllerBuilder {
+    private _state?;
+    private _kind?;
+    private _initialState?;
+    withState(state: StaticControllerState['state']): this;
+    withKind(kind: Kind): this;
+    withInitialState(initialState: StaticControllerState['initialState']): this;
+    /**
+     * Builds and returns the static controller state object
+     */
+    build(): StaticControllerState;
+}
+export declare function createStaticControllerBuilder<TController extends Controller>(controller: TController): StaticControllerBuilder;
+export {};

package/dist/definitions/ssr-next/common/controller-utils.d.ts

@@ -1,15 +1,15 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
 import type { CoreEngine, CoreEngineNext } from '../../app/engine.js';
 import type { Controller } from '../../controllers/controller/headless-controller.js';
-import type { ControllerDefinitionsMap, ControllersMap } from './types/controllers.js';
+import type { ControllerDefinitionsMap } from './types/controllers.js';
 import type { EngineStaticState } from './types/engine.js';
-import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromControllers, InferControllersMapFromDefinition } from './types/inference.js';
+import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromDefinitions, InferControllersMapFromDefinition } from './types/inference.js';
 export declare function buildControllerDefinitions<TControllerDefinitionsMap extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>, TEngine extends CoreEngine | CoreEngineNext>({ definitionsMap, engine, propsMap, }: {
     definitionsMap: TControllerDefinitionsMap;
     engine: TEngine;
-    propsMap: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
+    propsMap?: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
 }): InferControllersMapFromDefinition<TControllerDefinitionsMap>;
-export declare function createStaticState<TSearchAction extends UnknownAction>({ searchAction, controllers, }: {
+export declare function createStaticState<TSearchAction extends UnknownAction, TControllerDefinitions extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>>({ searchAction, controllers, }: {
     searchAction: TSearchAction;
-    controllers: ControllersMap;
-}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromControllers<ControllersMap>>;
+    controllers: InferControllersMapFromDefinition<TControllerDefinitions>;
+}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromDefinitions<TControllerDefinitions>>;

package/dist/definitions/ssr-next/common/types/controllers.d.ts

@@ -9,6 +9,12 @@ export interface ControllerStaticState<TState> {
 export interface ControllerStaticStateMap {
     [customName: string]: ControllerStaticState<unknown>;
 }
+export interface BaseControllerDefinitionWithoutProps<TEngine, TController extends Controller> {
+    build(engine: TEngine, ...args: unknown[]): TController;
+}
+export interface BaseControllerDefinitionWithProps<TEngine, TController extends Controller, TProps> {
+    buildWithProps(engine: TEngine, props?: TProps, ...args: unknown[]): TController;
+}
 export interface ControllerDefinitionWithoutProps<TEngine extends CoreEngine | CoreEngineNext, TController extends Controller> {
     /**
      * Creates an instance of the given controller.

package/dist/definitions/ssr-next/common/types/inference.d.ts

@@ -2,7 +2,7 @@ import type { CoreEngine, CoreEngineNext } from '../../../app/engine.js';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { ControllerDefinition, ControllerDefinitionsMap, ControllerDefinitionWithoutProps, ControllerDefinitionWithProps, ControllerStaticState, ControllersMap } from './controllers.js';
 import type { HasKeys } from './utilities.js';
-export type InferControllerPropsFromDefinition<TController extends ControllerDefinition<CoreEngine | CoreEngineNext, Controller>> = TController extends ControllerDefinitionWithProps<CoreEngine | CoreEngineNext, Controller, infer Props> ? Props : TController extends ControllerDefinitionWithoutProps<CoreEngine | CoreEngineNext, Controller> ? {} : unknown;
+type InferControllerPropsFromDefinition<TController extends ControllerDefinition<CoreEngine | CoreEngineNext, Controller>> = TController extends ControllerDefinitionWithProps<CoreEngine | CoreEngineNext, Controller, infer Props> ? Props : TController extends ControllerDefinitionWithoutProps<CoreEngine | CoreEngineNext, Controller> ? {} : unknown;
 export type InferControllerPropsMapFromDefinitions<TControllers extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>> = {
     [K in keyof TControllers as HasKeys<InferControllerPropsFromDefinition<TControllers[K]>> extends false ? never : K]: InferControllerPropsFromDefinition<TControllers[K]>;
 };
@@ -12,8 +12,9 @@ export type InferControllersMapFromDefinition<TControllers extends ControllerDef
 };
 export type InferControllerStaticStateFromController<TController extends Controller> = ControllerStaticState<TController['state']>;
 export type InferControllerStaticStateMapFromDefinitions<TControllers extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>> = {
-    [K in keyof TControllers]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>>;
+    [K in keyof TControllers]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>> & InferControllerPropsFromDefinition<TControllers[K]>;
 };
 export type InferControllerStaticStateMapFromControllers<TControllers extends ControllersMap> = {
     [K in keyof TControllers]: InferControllerStaticStateFromController<TControllers[K]>;
 };
+export {};

package/dist/definitions/test/mock-controller.d.ts

@@ -0,0 +1,9 @@
+import type { CoreEngine, CoreEngineNext } from '../app/engine.js';
+import type { Controller } from '../controllers/controller/headless-controller.js';
+import type { SSRCommerceEngine } from '../ssr/commerce/factories/build-factory.js';
+interface MockController {
+    initialState?: Record<string, unknown>;
+}
+export declare function buildMockController(): Controller;
+export declare function buildMockControllerWithInitialState(_engine: CoreEngine | CoreEngineNext | SSRCommerceEngine, props: MockController): Controller;
+export {};

package/dist/definitions/test/mock-ssr-controller-definitions.d.ts

@@ -0,0 +1,38 @@
+import type { SearchEngine } from '../app/search-engine/search-engine.js';
+import type { Controller } from '../controllers/controller/headless-controller.js';
+import type { Kind } from '../ssr/commerce/types/kind.js';
+import type { ControllerDefinitionWithoutProps, ControllerDefinitionWithProps } from '../ssr-next/common/types/controllers.js';
+interface MockController {
+    initialState?: Record<string, unknown>;
+}
+interface MockControllerDefinitionWithoutProps extends ControllerDefinitionWithoutProps<SearchEngine, Controller> {
+}
+interface MockControllerDefinitionWithProps extends ControllerDefinitionWithProps<SearchEngine, Controller, MockController> {
+}
+type SolutionTypeAvailabilities = {
+    listing?: boolean;
+    search?: boolean;
+    standalone?: boolean;
+    recommendation?: boolean;
+};
+export declare function defineMockController(): MockControllerDefinitionWithoutProps;
+export declare function defineMockControllerWithProps(): MockControllerDefinitionWithProps;
+export declare function defineMockCommerceController(options?: SolutionTypeAvailabilities): {
+    build: import("vitest").Mock<(_engine: any) => Controller>;
+    listing: boolean;
+    search: boolean;
+    standalone: boolean;
+    recommendation: boolean;
+};
+export declare function defineMockCommerceControllerWithProps(options?: SolutionTypeAvailabilities): {
+    buildWithProps: import("vitest").Mock<(engine: any, props: any) => {
+        state: {};
+        subscribe(listener: () => void): import("redux").Unsubscribe;
+        _kind: Kind;
+    }>;
+    listing: boolean;
+    search: boolean;
+    standalone: boolean;
+    recommendation: boolean;
+};
+export {};

package/dist/esm/controllers/commerce/core/interactive-product/headless-core-interactive-product.js

@@ -49,7 +49,8 @@ permanentid '${props.options.product.permanentid}':\n\n${warnings.join('\n')}\n\
                     props.options.product.permanentid,
             },
             position: props.options.product.position,
-            responseId: props.responseIdSelector(engine[stateKey]),
+            responseId: props.options.product.responseId ??
+                props.responseIdSelector(engine[stateKey]),
         }));
     };
     return {

package/dist/esm/features/commerce/instant-products/instant-products-slice.js

@@ -25,7 +25,7 @@ export const instantProductsReducer = createReducer(getInstantProductsInitialSta
             totalCountFiltered: totalEntries,
             ...action.meta.arg,
         }, state, {
-            products: products.map((product, index) => preprocessProduct(product, index + 1)),
+            products: products.map((product, index) => preprocessProduct(product, index + 1, responseId)),
         });
     })
         .addCase(fetchInstantProducts.rejected, (state, action) => {
@@ -45,6 +45,7 @@ export const instantProductsReducer = createReducer(getInstantProductsInitialSta
         if (currentParentIndex === -1 || childToPromote === undefined) {
             return;
         }
+        const responseId = products[currentParentIndex].responseId;
         const position = products[currentParentIndex].position;
         const { children, totalNumberOfChildren } = products[currentParentIndex];
         const newParent = {
@@ -52,21 +53,23 @@ export const instantProductsReducer = createReducer(getInstantProductsInitialSta
             children,
             totalNumberOfChildren,
             position,
+            responseId,
         };
         const newProducts = [...products];
         newProducts.splice(currentParentIndex, 1, newParent);
         cache.products = newProducts;
     });
 });
-function preprocessProduct(product, position) {
+function preprocessProduct(product, position, responseId) {
     const isParentAlreadyInChildren = product.children.some((child) => child.permanentid === product.permanentid);
     if (product.children.length === 0 || isParentAlreadyInChildren) {
-        return { ...product, position };
+        return { ...product, position, responseId };
     }
     const { children, totalNumberOfChildren: _totalNumberOfChildren, ...restOfProduct } = product;
     return {
         ...product,
         children: [restOfProduct, ...children],
         position,
+        responseId,
     };
 }

package/dist/esm/features/commerce/product-listing/product-listing-slice.js

@@ -14,7 +14,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
         .addCase(fetchProductListing.fulfilled, (state, action) => {
         const paginationOffset = getPaginationOffset(action.payload);
         handleFullfilled(state, action.payload.response);
-        state.products = action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1));
+        state.products = action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, action.payload.response.responseId));
     })
         .addCase(fetchMoreProducts.fulfilled, (state, action) => {
         if (!action.payload) {
@@ -22,7 +22,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
         }
         const paginationOffset = getPaginationOffset(action.payload);
         handleFullfilled(state, action.payload.response);
-        state.products = state.products.concat(action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1)));
+        state.products = state.products.concat(action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, action.payload?.response.responseId)));
     })
         .addCase(fetchProductListing.pending, (state, action) => {
         handlePending(state, action.meta.requestId);
@@ -40,6 +40,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
         if (currentParentIndex === -1 || childToPromote === undefined) {
             return;
         }
+        const responseId = products[currentParentIndex].responseId;
         const position = products[currentParentIndex].position;
         const { children, totalNumberOfChildren } = products[currentParentIndex];
         const newParent = {
@@ -47,6 +48,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
             children,
             totalNumberOfChildren,
             position,
+            responseId,
         };
         products.splice(currentParentIndex, 1, newParent);
     })
@@ -74,15 +76,16 @@ function getPaginationOffset(payload) {
     const pagination = payload.response.pagination;
     return pagination.page * pagination.perPage;
 }
-function preprocessProduct(product, position) {
+function preprocessProduct(product, position, responseId) {
     const isParentAlreadyInChildren = product.children.some((child) => child.permanentid === product.permanentid);
     if (product.children.length === 0 || isParentAlreadyInChildren) {
-        return { ...product, position };
+        return { ...product, position, responseId };
     }
     const { children, totalNumberOfChildren: _totalNumberOfChildren, ...restOfProduct } = product;
     return {
         ...product,
         children: [restOfProduct, ...children],
         position,
+        responseId,
     };
 }

package/dist/esm/features/commerce/recommendations/recommendations-slice.js

@@ -31,7 +31,7 @@ export const recommendationsReducer = createReducer(getRecommendationsInitialSta
             return;
         }
         const paginationOffset = getPaginationOffset(action.payload);
-        recommendations.products = response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1));
+        recommendations.products = response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, response.responseId));
     })
         .addCase(fetchMoreRecommendations.fulfilled, (state, action) => {
         if (!action.payload) {
@@ -45,7 +45,7 @@ export const recommendationsReducer = createReducer(getRecommendationsInitialSta
             return;
         }
         const paginationOffset = getPaginationOffset(action.payload);
-        recommendations.products = recommendations.products.concat(response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1)));
+        recommendations.products = recommendations.products.concat(response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, response.responseId)));
     })
         .addCase(fetchRecommendations.pending, (state, action) => {
         handlePending(state, action.meta.arg.slotId);
@@ -67,6 +67,7 @@ export const recommendationsReducer = createReducer(getRecommendationsInitialSta
         if (currentParentIndex === -1 || childToPromote === undefined) {
             return;
         }
+        const responseId = products[currentParentIndex].responseId;
         const position = products[currentParentIndex].position;
         const { children, totalNumberOfChildren } = products[currentParentIndex];
         const newParent = {
@@ -74,6 +75,7 @@ export const recommendationsReducer = createReducer(getRecommendationsInitialSta
             children,
             totalNumberOfChildren,
             position,
+            responseId,
         };
         products.splice(currentParentIndex, 1, newParent);
     })
@@ -119,15 +121,16 @@ function getPaginationOffset(actionPayload) {
     const pagination = actionPayload.response.pagination;
     return pagination.page * pagination.perPage;
 }
-function preprocessProduct(product, position) {
+function preprocessProduct(product, position, responseId) {
     const isParentAlreadyInChildren = product.children.some((child) => child.permanentid === product.permanentid);
     if (product.children.length === 0 || isParentAlreadyInChildren) {
-        return { ...product, position };
+        return { ...product, position, responseId };
     }
     const { children, totalNumberOfChildren: _totalNumberOfChildren, ...restOfProduct } = product;
     return {
         ...product,
         children: [restOfProduct, ...children],
         position,
+        responseId,
     };
 }

package/dist/esm/features/commerce/search/search-slice.js

@@ -14,7 +14,7 @@ export const commerceSearchReducer = createReducer(getCommerceSearchInitialState
         .addCase(executeSearch.fulfilled, (state, action) => {
         const paginationOffset = getPaginationOffset(action.payload);
         handleFulfilled(state, action.payload.response, action.payload.queryExecuted);
-        state.products = action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1));
+        state.products = action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, action.payload.response.responseId));
     })
         .addCase(fetchMoreProducts.fulfilled, (state, action) => {
         if (!action.payload) {
@@ -22,7 +22,7 @@ export const commerceSearchReducer = createReducer(getCommerceSearchInitialState
         }
         const paginationOffset = getPaginationOffset(action.payload);
         handleFulfilled(state, action.payload.response, action.payload.queryExecuted);
-        state.products = state.products.concat(action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1)));
+        state.products = state.products.concat(action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, action.payload?.response.responseId)));
     })
         .addCase(executeSearch.pending, (state, action) => {
         handlePending(state, action.meta.requestId);
@@ -40,6 +40,7 @@ export const commerceSearchReducer = createReducer(getCommerceSearchInitialState
         if (currentParentIndex === -1 || childToPromote === undefined) {
             return;
         }
+        const responseId = products[currentParentIndex].responseId;
         const position = products[currentParentIndex].position;
         const { children, totalNumberOfChildren } = products[currentParentIndex];
         const newParent = {
@@ -47,6 +48,7 @@ export const commerceSearchReducer = createReducer(getCommerceSearchInitialState
             children,
             totalNumberOfChildren,
             position,
+            responseId,
         };
         products.splice(currentParentIndex, 1, newParent);
     })
@@ -76,15 +78,16 @@ function getPaginationOffset(payload) {
     const pagination = payload.response.pagination;
     return pagination.page * pagination.perPage;
 }
-function preprocessProduct(product, position) {
+function preprocessProduct(product, position, responseId) {
     const isParentAlreadyInChildren = product.children.some((child) => child.permanentid === product.permanentid);
     if (product.children.length === 0 || isParentAlreadyInChildren) {
-        return { ...product, position };
+        return { ...product, position, responseId };
     }
     const { children, totalNumberOfChildren: _totalNumberOfChildren, ...restOfProduct } = product;
     return {
         ...product,
         children: [restOfProduct, ...children],
         position,
+        responseId,
     };
 }

package/dist/esm/ssr-next/commerce/controller-utils.js

@@ -1,22 +1,13 @@
 import { clone, filterObject, mapObject } from '../../utils/utils.js';
+import { ControllerBuilder } from '../common/builders/controller-builder.js';
+import { createStaticControllerBuilder } from '../common/builders/static-controller-builder.js';
 import { InvalidControllerDefinition } from '../common/errors.js';
-function hasKindProperty(controller) {
-    return '_kind' in controller;
-}
 export function createStaticState({ searchActions, controllers, }) {
     return {
-        controllers: mapObject(controllers, (controller) => ({
-            state: clone(controller.state),
-            ...(hasKindProperty(controller) && { _kind: controller._kind }),
-        })),
+        controllers: mapObject(controllers, (controller) => createStaticControllerBuilder(controller).build()),
         searchActions: searchActions.map((action) => clone(action)),
     };
 }
-function buildControllerFromDefinition({ definition, engine, solutionType, props, }) {
-    return ('build' in definition
-        ? definition.build(engine, solutionType)
-        : definition.buildWithProps(engine, props, solutionType));
-}
 export function buildControllerDefinitions({ definitionsMap, engine, solutionType, propsMap, }) {
     const controllerMap = mapObject(definitionsMap, (definition, key) => {
         const unavailableInSolutionType = () => !(solutionType in definition) ||
@@ -26,12 +17,9 @@ export function buildControllerDefinitions({ definitionsMap, engine, solutionTyp
         if (unavailableInSolutionType()) {
             return null;
         }
-        return buildControllerFromDefinition({
-            definition,
-            engine,
-            solutionType,
-            props,
-        });
+        return new ControllerBuilder(definition, engine, props)
+            .withAdditionalArgs([solutionType])
+            .build();
     });
     return filterObject(controllerMap, (value) => value !== null);
 }

package/dist/esm/ssr-next/commerce/controllers/cart/headless-cart.ssr.js

@@ -1,5 +1,4 @@
 import { buildCart, } from '../../../../controllers/commerce/context/cart/headless-cart.js';
-import { MissingControllerProps } from '../../../common/errors.js';
 import { createControllerWithKind, Kind } from '../../types/kind.js';
 /**
  * Defines a `Cart` controller instance.
@@ -14,10 +13,9 @@ export function defineCart() {
         standalone: true,
         recommendation: true,
         buildWithProps: (engine, props) => {
-            if (props === undefined) {
-                throw new MissingControllerProps(Kind.Cart);
-            }
-            const controller = buildCart(engine, { initialState: props.initialState });
+            const controller = buildCart(engine, {
+                initialState: props ? props.initialState : {},
+            });
             return createControllerWithKind(controller, Kind.Cart);
         },
     };

package/dist/esm/ssr-next/commerce/controllers/context/headless-context.ssr.js

@@ -17,7 +17,7 @@ export function defineContext() {
             if (props === undefined) {
                 throw new MissingControllerProps(Kind.Context);
             }
-            const controller = buildContext(engine, { options: props });
+            const controller = buildContext(engine, { options: props.initialState });
             return createControllerWithKind(controller, Kind.Context);
         },
     };

package/dist/esm/ssr-next/common/builders/controller-builder.js

@@ -0,0 +1,38 @@
+/**
+ * Builder class for creating controllers from definitions
+ */
+export class ControllerBuilder {
+    _definition;
+    _engine;
+    _props;
+    _additionalArgs = [];
+    constructor(definition, engine, props) {
+        this._definition = definition;
+        this._engine = engine;
+        this._props = props;
+    }
+    withAdditionalArgs(additionalArgs = []) {
+        this._additionalArgs = additionalArgs;
+        return this;
+    }
+    build() {
+        if ('build' in this._definition &&
+            typeof this._definition.build === 'function') {
+            return this.buildWithoutProps();
+        }
+        if ('buildWithProps' in this._definition &&
+            typeof this._definition.buildWithProps === 'function') {
+            return this.buildWithProps();
+        }
+        throw new Error('Controller definition must have a build or buildWithProps method.');
+    }
+    buildWithoutProps() {
+        const buildFn = this._definition.build;
+        return buildFn(this._engine, ...this._additionalArgs);
+    }
+    buildWithProps() {
+        const buildWithPropsFn = this._definition.buildWithProps;
+        const controller = buildWithPropsFn(this._engine, this._props, ...this._additionalArgs);
+        return { ...controller, initialState: controller.state };
+    }
+}

package/dist/esm/ssr-next/common/builders/static-controller-builder.js

@@ -0,0 +1,46 @@
+import { clone } from '../../../utils/utils.js';
+/**
+ * Builder class for creating static controller
+ */
+class StaticControllerBuilder {
+    _state;
+    _kind;
+    _initialState;
+    withState(state) {
+        this._state = clone(state);
+        return this;
+    }
+    withKind(kind) {
+        this._kind = kind;
+        return this;
+    }
+    withInitialState(initialState) {
+        this._initialState = clone(initialState);
+        return this;
+    }
+    /**
+     * Builds and returns the static controller state object
+     */
+    build() {
+        const result = {
+            state: this._state,
+        };
+        if (this._kind) {
+            result._kind = this._kind;
+        }
+        if (this._initialState) {
+            result.initialState = this._initialState;
+        }
+        return result;
+    }
+}
+export function createStaticControllerBuilder(controller) {
+    const builder = new StaticControllerBuilder().withState(controller.state);
+    if ('_kind' in controller) {
+        builder.withKind(controller._kind);
+    }
+    if ('initialState' in controller) {
+        builder.withInitialState(controller.initialState);
+    }
+    return builder;
+}