@coveo/headless 3.28.3 → 3.28.4-pre.7521bcce93

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

@@ -0,0 +1,18 @@
+import type { CoreEngine, CoreEngineNext } from '../../../app/engine.js';
+import type { Controller } from '../../../controllers/controller/headless-controller.js';
+import type { SSRCommerceEngine } from '../../commerce/factories/build-factory.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 | SSRCommerceEngine, 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/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/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;
+}

package/dist/esm/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "3.28.3" || 'Test version';
+export const VERSION = "3.28.4-pre.7521bcce93" || 'Test version';
 export const COVEO_FRAMEWORK = ['@coveo/atomic', '@coveo/quantic'];