@coveo/atomic 3.34.0-pre.00dc0c9faa → 3.34.0-pre.011ede392f

package/dist/types/components/commerce/product-template-component-utils/context/interactive-product-context-controller.d.ts

@@ -0,0 +1,27 @@
+import type { InteractiveProduct } from '@coveo/headless/commerce';
+import type { LitElement } from 'lit';
+import { InteractiveItemContextController } from "../../../common/item-list/context/interactive-item-context-controller";
+/**
+ * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing interactive product context in product template components.
+ *
+ * @param host - The Lit component instance
+ * @returns InteractiveItemContextController instance
+ *
+ * @example
+ * ```typescript
+ * @customElement('my-interactive-product-component')
+ * export class MyInteractiveProductComponent extends LitElement {
+ *   private interactiveProductController = createInteractiveProductContextController(this);
+ *
+ *   @state() product!: Product;
+ *
+ *   render() {
+ *     this.product = this.interactiveProductController.interactiveItem;
+ *     return html`<div>${this.product?.ec_name}</div>`;
+ *   }
+ * }
+ * ```
+ */
+export declare function createInteractiveProductContextController(host: LitElement & {
+    error: Error;
+}): InteractiveItemContextController<InteractiveProduct>;

package/dist/types/components/commerce/product-template-component-utils/context/product-context-controller.d.ts

@@ -0,0 +1,33 @@
+import type { InteractiveProduct, Product } from '@coveo/headless/commerce';
+import type { LitElement } from 'lit';
+import type { InteractiveItemContextEvent } from "../../../common/item-list/context/interactive-item-context-controller";
+import { ItemContextController, type ItemContextEvent } from "../../../common/item-list/context/item-context-controller";
+/**
+ * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing product context in product template components.
+ *
+ * @param host - The Lit component instance
+ * @param options - Configuration options
+ * @returns ItemContextController instance configured for atomic-product
+ *
+ * @example
+ * ```typescript
+ * @customElement('my-product-component')
+ * export class MyProductComponent extends LitElement {
+ *   private productController = createProductContextController(this);
+ *
+ *   @state() product!: Product;
+ *
+ *   render() {
+ *     this.product = this.productController.item;
+ *     return html`<div>${this.product?.ec_name}</div>`;
+ *   }
+ * }
+ * ```
+ */
+export declare function createProductContextController(host: LitElement & {
+    error: Error | null;
+}, options?: {
+    folded?: boolean;
+}): ItemContextController<Product>;
+export type ProductContextEvent<T = Product> = ItemContextEvent<T>;
+export type InteractiveProductContextEvent<T extends InteractiveProduct = InteractiveProduct> = InteractiveItemContextEvent<T>;

package/dist/types/components/commerce/product-template-component-utils/{stencil-product-template-decorators.d.ts → context/stencil-product-template-decorators.d.ts}

@@ -9,6 +9,6 @@ import { Product } from '@coveo/headless/commerce';
  * @param element - The element that the event is dispatched to, which must be the child of a rendered "atomic-product".
  * @returns A promise that resolves on initialization of the parent "atomic-product" element, or rejects when there is no parent "atomic-product" element.
  *
- * @deprecated should only be used for Stencil components. For Lit components, use `fetchProductContext` from \@/src/decorators/commerce/product-template-decorators.ts
+ * @deprecated should only be used for Stencil components. For Lit components, use `fetchProductContext` from \@/src/components/commerce/product-template-component-utils/context/fetch-product-context.ts
  */
 export declare function productContext<T extends Product>(element: Element): Promise<T>;

package/dist/types/components/common/atomic-layout-section/atomic-layout-section.d.ts

@@ -1,5 +1,5 @@
 import { LitElement } from 'lit';
-import type { Section } from './sections';
+import type { Section } from './atomic-layout-section-utils';
 declare const AtomicLayoutSection_base: import("../../../mixins/mixin-common").Constructor<{
     injectStyles(dynamicStyles?: import("lit").CSSResultGroup): Promise<void>;
 }> & typeof LitElement;

package/dist/types/components/common/facets/facet-search/facet-search-input-guard.d.ts

@@ -6,7 +6,7 @@ export interface FacetSearchInputGuardProps {
     numberOfDisplayedValues: number;
 }
 declare class FacetSearchInputGuardDirective extends Directive {
-    render({ canShowMoreValues, numberOfDisplayedValues, withSearch, }: FacetSearchInputGuardProps, content: () => unknown): typeof nothing | import("lit-html").TemplateResult<1>;
+    render({ canShowMoreValues, numberOfDisplayedValues, withSearch, }: FacetSearchInputGuardProps, content: () => unknown): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export declare const facetSearchInputGuard: (values_0: FacetSearchInputGuardProps, content: () => unknown) => import("lit-html/directive.js").DirectiveResult<typeof FacetSearchInputGuardDirective>;
 export {};

package/dist/types/components/common/layout/custom-render-controller.d.ts

@@ -0,0 +1,25 @@
+import type { LitElement, ReactiveController, ReactiveControllerHost } from 'lit';
+import type { ItemRenderingFunction } from "../item-list/item-list-common";
+import type { AnyItem } from "../item-list/unfolded-item";
+export interface CustomRenderHost extends ReactiveControllerHost {
+    shadowRoot?: ShadowRoot | null;
+}
+export interface CustomRenderOptions {
+    renderingFunction: () => ItemRenderingFunction<AnyItem> | undefined;
+    itemData: () => AnyItem | undefined;
+    rootElementRef: () => HTMLElement | undefined;
+    linkContainerRef?: () => HTMLElement | undefined;
+    onRenderComplete?: (element: HTMLElement, output: string) => void;
+}
+/**
+ * A reactive controller that manages custom rendering function execution for item components.
+ */
+export declare class CustomRenderController implements ReactiveController {
+    private options;
+    private hasExecutedRenderFunction;
+    constructor(host: CustomRenderHost & LitElement, options: CustomRenderOptions);
+    hostConnected(): void;
+    hostUpdated(): void;
+    private resetRenderState;
+    private executeRenderFunction;
+}

package/dist/types/components/common/layout/item-layout-controller.d.ts

@@ -0,0 +1,47 @@
+import type { LitElement, ReactiveController, ReactiveControllerHost } from 'lit';
+import type { ItemRenderingFunction } from "../item-list/item-list-common";
+import type { AnyItem } from "../item-list/unfolded-item";
+import { type ItemDisplayDensity, type ItemDisplayImageSize, type ItemDisplayLayout, ItemLayout } from './display-options';
+export interface ItemLayoutHost extends ReactiveControllerHost {
+    shadowRoot?: ShadowRoot | null;
+}
+export interface LayoutDisplayConfig {
+    display: ItemDisplayLayout;
+    density: ItemDisplayDensity;
+    imageSize: ItemDisplayImageSize;
+}
+export interface ItemLayoutOptions {
+    elementPrefix: string;
+    renderingFunction: () => ItemRenderingFunction<AnyItem> | undefined;
+    content: () => ParentNode | undefined;
+    layoutConfig: () => LayoutDisplayConfig;
+    itemClasses: () => string;
+}
+/**
+ * A reactive controller that manages layout creation and class application for item components.
+ */
+export declare class ItemLayoutController implements ReactiveController {
+    private host;
+    private options;
+    private layoutInstance;
+    constructor(host: ItemLayoutHost & LitElement, options: ItemLayoutOptions);
+    hostConnected(): void;
+    hostUpdated(): void;
+    /**
+     * Gets the current layout instance
+     */
+    getLayout(): ItemLayout | null;
+    /**
+     * Gets combined layout and extra classes
+     */
+    getCombinedClasses(additionalContent?: string): string[];
+    /**
+     * Applies layout classes to a specific element (useful for custom rendering)
+     */
+    applyLayoutClassesToElement(element: HTMLElement, additionalContent?: string): void;
+    private applyLayoutClasses;
+    private createLayout;
+    private hasCustomRenderFunction;
+    private addClassesToElements;
+    private observeAndApplyClasses;
+}

package/dist/types/components/common/no-items/guard.d.ts

@@ -6,7 +6,7 @@ interface NoItemsGuardProps {
     hasResults: boolean;
 }
 declare class NoItemsGuardDirective extends Directive {
-    render({ firstSearchExecuted, isLoading, hasResults }: NoItemsGuardProps, content: () => unknown): typeof nothing | import("lit-html").TemplateResult<1>;
+    render({ firstSearchExecuted, isLoading, hasResults }: NoItemsGuardProps, content: () => unknown): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export declare const noItemsGuard: (values_0: NoItemsGuardProps, content: () => unknown) => import("lit-html/directive.js").DirectiveResult<typeof NoItemsGuardDirective>;
 export {};

package/dist/types/components/common/refine-modal/guard.d.ts

@@ -6,7 +6,7 @@ export interface RefineToggleGuardProps {
     hasItems: boolean;
 }
 declare class RefineToggleGuardDirective extends Directive {
-    render({ hasError, firstRequestExecuted, hasItems }: RefineToggleGuardProps, content: () => unknown): typeof nothing | import("lit-html").TemplateResult<1>;
+    render({ hasError, firstRequestExecuted, hasItems }: RefineToggleGuardProps, content: () => unknown): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export declare const refineToggleGuard: (values_0: RefineToggleGuardProps, content: () => unknown) => import("lit-html/directive.js").DirectiveResult<typeof RefineToggleGuardDirective>;
 export {};

package/dist/types/components/common/smart-snippets/atomic-smart-snippet-source.d.ts

@@ -1,8 +1,8 @@
 import { Result } from '@coveo/headless';
 import { EventEmitter } from '../../../stencil-public-runtime';
 import { InitializableComponent } from '../../../utils/initialization-utils';
-import { ResultContextEvent } from '../../search/result-template-components/result-template-decorators';
 import { AnyBindings } from '../interface/bindings';
+import { ResultContextEvent } from "../../search/result-template-component-utils/context/stencil-result-template-decorators";
 /**
  * @part source-url
  * @part source-title

package/dist/types/components/common/sort/sort-guard.d.ts

@@ -5,5 +5,5 @@ interface SortGuardProps {
     hasError: boolean;
     isLoading: boolean;
 }
-export declare const sortGuard: ({ firstSearchExecuted, hasError, hasResults, isLoading }: SortGuardProps, sortTemplate: () => TemplateResult) => typeof nothing | TemplateResult | typeof noChange;
+export declare const sortGuard: ({ firstSearchExecuted, hasError, hasResults, isLoading }: SortGuardProps, sortTemplate: () => TemplateResult) => TemplateResult | typeof nothing | typeof noChange;
 export {};

package/dist/types/components/common/validate-props-controller/validate-props-controller.d.ts

@@ -0,0 +1,32 @@
+import type { Schema } from '@coveo/bueno';
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * A reactive controller that validates the props of a Lit component against a
+ * provided Bueno schema.
+ *
+ * It validates the props when the host is connected to the DOM and whenever
+ * the host updates, revalidating only if the props have changed since the last
+ * validation.
+ *
+ * If validation fails, the controller sets the `error` property on the host.
+ */
+export declare class ValidatePropsController<TProps extends Record<string, unknown>> implements ReactiveController {
+    private host;
+    private getProps;
+    private schema;
+    private currentProps?;
+    private previousProps?;
+    /**
+     * Creates a `ValidatePropsController`.
+     *
+     * @param host The host element.
+     * @param getProps A function that returns the current props to validate.
+     * @param schema The Bueno schema to validate the props against.
+     */
+    constructor(host: ReactiveControllerHost & HTMLElement & {
+        error: Error;
+    }, getProps: () => TProps, schema: Schema<TProps>);
+    hostConnected(): void;
+    hostUpdate(): void;
+    private _validateProps;
+}

package/dist/types/components/search/atomic-relevance-inspector/atomic-relevance-inspector.d.ts

@@ -1,15 +1,25 @@
-import { EventEmitter } from '../../../stencil-public-runtime';
-import { Bindings } from '../atomic-search-interface/atomic-search-interface';
+import { LitElement } from 'lit';
+import "../../common/atomic-modal/atomic-modal";
+import type { Bindings } from "../atomic-search-interface/interfaces";
+import type { InitializableComponent } from "../../../decorators/types.js";
 /**
  * The `atomic-relevance-inspector` component is used internally to offer insight on search page relevance, as well as information to help troubleshoot issues during development.
+ *
+ * @internal
  */
-export declare class AtomicRelevanceInspector {
-    /**
-     * The Atomic interface bindings, namely the headless search engine and i18n instances.
-     */
+export declare class AtomicRelevanceInspector extends LitElement implements InitializableComponent<Bindings> {
     bindings: Bindings;
+    error: Error;
     open: boolean;
-    closeRelevanceInspector: EventEmitter<null> | undefined;
-    render(): any;
+    initialize: () => void;
+    disconnectedCallback(): void;
+    render(): import("lit-html").TemplateResult<1>;
+    private handleRelevanceInspectorDoubleClick;
+    private handleCloseRelevanceInspector;
     private get adminHref();
 }
+declare global {
+    interface HTMLElementTagNameMap {
+        'atomic-relevance-inspector': AtomicRelevanceInspector;
+    }
+}

package/dist/types/components/search/atomic-result/atomic-result.d.ts

@@ -3,7 +3,7 @@ import { DisplayConfig } from '../../common/item-list/stencil-item-decorators';
 import { ItemRenderingFunction } from '../../common/item-list/stencil-item-list-common';
 import { ItemDisplayDensity, ItemDisplayImageSize, ItemDisplayLayout } from '../../common/layout/display-options';
 import { SearchStore } from '../atomic-search-interface/store';
-import { InteractiveResultContextEvent, ResultContextEvent } from '../result-template-components/result-template-decorators';
+import { InteractiveResultContextEvent, ResultContextEvent } from "../result-template-component-utils/context/stencil-result-template-decorators";
 /**
  * The `atomic-result` component is used internally by the `atomic-result-list` component.
  */

package/dist/types/components/search/atomic-search-box-recent-queries/atomic-search-box-recent-queries.d.ts

@@ -0,0 +1,45 @@
+import { type SearchBox } from '@coveo/headless';
+import { LitElement } from 'lit';
+import type { SearchBoxSuggestionsComponent } from "../../../decorators/types";
+import type { SearchBoxSuggestions, SearchBoxSuggestionsBindings } from '../../common/suggestions/suggestions-types';
+import type { Bindings } from '../atomic-search-interface/interfaces';
+/**
+ * The `atomic-search-box-recent-queries` component can be added as a child of an `atomic-search-box` component, allowing for the configuration of recent query suggestions.
+ */
+export declare class AtomicSearchBoxRecentQueries extends LitElement implements SearchBoxSuggestionsComponent<Bindings> {
+    bindings: SearchBoxSuggestionsBindings<SearchBox, Bindings>;
+    private recentQueriesList;
+    private storage;
+    error: Error;
+    /**
+     * The SVG icon to display.
+     *
+     * - Use a value that starts with `http://`, `https://`, `./`, or `../`, to fetch and display an icon from a given location.
+     * - Use a value that starts with `assets://`, to display an icon from the Atomic package.
+     * - Use a stringified SVG to display it directly.
+     */
+    icon?: string;
+    /**
+     * The maximum number of suggestions to display when the user types in the input field.
+     */
+    maxWithQuery: number;
+    /**
+     * The maximum number of suggestions to display initially, when the input field is empty.
+     */
+    maxWithoutQuery?: number;
+    connectedCallback(): void;
+    initialize(): SearchBoxSuggestions;
+    private retrieveLocalStorage;
+    private updateLocalStorage;
+    private warnUser;
+    private disableFeature;
+    private renderItems;
+    private renderClear;
+    private renderItem;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'atomic-search-box-recent-queries': AtomicSearchBoxRecentQueries;
+    }
+}

package/dist/types/components/search/atomic-search-interface/atomic-search-interface.d.ts

@@ -3,6 +3,7 @@ import { type i18n } from 'i18next';
 import { type CSSResultGroup, LitElement } from 'lit';
 import type { CommonBindings, NonceBindings } from "../../common/interface/bindings";
 import { type BaseAtomicInterface } from "../../common/interface/interface-controller";
+import "../atomic-relevance-inspector/atomic-relevance-inspector";
 import { type SearchStore } from './store';
 import "../../common/atomic-modal/atomic-modal";
 export type InitializationOptions = SearchEngineConfiguration;
@@ -16,7 +17,6 @@ declare const AtomicSearchInterface_base: typeof LitElement;
 export declare class AtomicSearchInterface extends AtomicSearchInterface_base implements BaseAtomicInterface<SearchEngine> {
     bindings: Bindings;
     error: Error;
-    relevanceInspectorIsOpen: boolean;
     urlManager: UrlManager;
     searchStatus: SearchStatus;
     private unsubscribeUrlManager;
@@ -24,6 +24,7 @@ export declare class AtomicSearchInterface extends AtomicSearchInterface_base im
     private initialized;
     private store;
     private interfaceController;
+    private relevanceInspector?;
     static styles: CSSResultGroup;
     /**
      * A list of non-default fields to include in the query results.
@@ -120,6 +121,9 @@ export declare class AtomicSearchInterface extends AtomicSearchInterface_base im
     disconnectedCallback(): void;
     private handleInitialization;
     scrollToTop(): void;
+    /**
+     * @deprecated provided for backward compatibility. set the 'open' property directly on the relevance inspector instead.
+     */
     closeRelevanceInspector(): void;
     /**
      * Initializes the connection with the headless search engine using options for `accessToken` (required), `organizationId` (required), `environment` (defaults to `prod`), and `renewAccessToken`.
@@ -143,13 +147,12 @@ export declare class AtomicSearchInterface extends AtomicSearchInterface_base im
     updateIconAssetsPath(): void;
     private getBindings;
     private initFieldsToInclude;
+    private updateFieldsToInclude;
     registerFieldsToInclude(): void;
     private initEngine;
     private getSearchConfiguration;
     private get fragment();
     private initUrlManager;
-    private handleRelevanceInspectorDoubleClick;
-    private initRelevanceInspector;
     private initSearchStatus;
     private updateHash;
     private onHashChange;

package/dist/types/components/search/index.d.ts

@@ -1,5 +1,6 @@
 export { AtomicPager } from './atomic-pager/atomic-pager.js';
 export { AtomicQuerySummary } from './atomic-query-summary/atomic-query-summary.js';
+export { AtomicRelevanceInspector } from './atomic-relevance-inspector/atomic-relevance-inspector.js';
 export { AtomicResultSectionActions } from './atomic-result-section-actions/atomic-result-section-actions.js';
 export { AtomicResultSectionBadges } from './atomic-result-section-badges/atomic-result-section-badges.js';
 export { AtomicResultSectionBottomMetadata } from './atomic-result-section-bottom-metadata/atomic-result-section-bottom-metadata.js';
@@ -10,5 +11,6 @@ export { AtomicResultSectionTitle } from './atomic-result-section-title/atomic-r
 export { AtomicResultSectionTitleMetadata } from './atomic-result-section-title-metadata/atomic-result-section-title-metadata.js';
 export { AtomicResultSectionVisual } from './atomic-result-section-visual/atomic-result-section-visual.js';
 export { AtomicResultsPerPage } from './atomic-results-per-page/atomic-results-per-page.js';
+export { AtomicSearchBoxRecentQueries } from './atomic-search-box-recent-queries/atomic-search-box-recent-queries.js';
 export { AtomicSearchInterface } from './atomic-search-interface/atomic-search-interface.js';
 export { AtomicSearchLayout } from './atomic-search-layout/atomic-search-layout.js';

package/dist/types/components/search/result-template-component-utils/context/fetch-result-context.d.ts

@@ -0,0 +1,8 @@
+import type { FoldedResult, Result } from '@coveo/headless';
+/**
+ * Retrieves `Result` on a rendered `atomic-result`.
+ *
+ * @param element - The element that the event is dispatched to
+ * @returns A promise that resolves on initialization of the parent `atomic-result` element, or rejects if missing
+ */
+export declare function fetchResultContext<T extends Result | FoldedResult = Result>(element: Element): Promise<T>;

package/dist/types/components/search/result-template-component-utils/context/interactive-result-context-controller.d.ts

@@ -0,0 +1,12 @@
+import type { InteractiveResult } from '@coveo/headless';
+import type { LitElement } from 'lit';
+import { InteractiveItemContextController } from "../../../common/item-list/context/interactive-item-context-controller";
+/**
+ * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing interactive result context in result template components.
+ *
+ * @param host - The Lit component instance
+ * @returns InteractiveItemContextController instance
+ */
+export declare function createInteractiveResultContextController(host: LitElement & {
+    error: Error;
+}): InteractiveItemContextController<InteractiveResult>;

package/dist/types/components/search/result-template-component-utils/context/result-context-controller.d.ts

@@ -0,0 +1,18 @@
+import type { FoldedResult, InteractiveResult, Result } from '@coveo/headless';
+import type { LitElement } from 'lit';
+import type { InteractiveItemContextEvent } from "../../../common/item-list/context/interactive-item-context-controller";
+import { ItemContextController, type ItemContextEvent } from "../../../common/item-list/context/item-context-controller";
+/**
+ * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing result context in result template components.
+ *
+ * @param host - The Lit component instance
+ * @param options - Configuration options
+ * @returns ItemContextController instance configured for atomic-result
+ */
+export declare function createResultContextController(host: LitElement & {
+    error: Error | null;
+}, options?: {
+    folded?: boolean;
+}): ItemContextController<Result | FoldedResult>;
+export type ResultContextEvent<T = Result | FoldedResult> = ItemContextEvent<T>;
+export type InteractiveResultContextEvent<T extends InteractiveResult = InteractiveResult> = InteractiveItemContextEvent<T>;

package/dist/types/components/search/{result-template-components/result-template-decorators.d.ts → result-template-component-utils/context/stencil-result-template-decorators.d.ts}

@@ -1,5 +1,5 @@
 import { FoldedResult, Result } from '@coveo/headless';
-import { InteractiveItemContextEvent, ItemContextEvent } from '../../common/item-list/stencil-item-decorators';
+import { InteractiveItemContextEvent, ItemContextEvent } from "../../../common/item-list/stencil-item-decorators";
 /**
  * A [StencilJS property decorator](https://stenciljs.com/) to be used for result template components.
  * This allows the Stencil component to fetch the current result from its rendered parent, the `atomic-result` component.
@@ -8,6 +8,8 @@ import { InteractiveItemContextEvent, ItemContextEvent } from '../../common/item
  * @ResultContext() private result!: Result;
  *
  * For more information and examples, view the "Utilities" section of the readme.
+ *
+ * @deprecated should only be used for Stencil components. For Lit components, use `createResultContextController` from \@/src/components/search/result-template-component-utils/context/result-context-controller.ts
  */
 export declare function ResultContext(opts?: {
     folded: boolean;
@@ -22,7 +24,9 @@ export type InteractiveResultContextEvent = InteractiveItemContextEvent;
  *
  * You should use the method in the [connectedCallback lifecycle method](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements#using_the_lifecycle_callbacks).
  *
- * @param element The element that the event is dispatched to, which must be the child of a rendered "atomic-result".
+ * @param element The element that the event is dispatched to, which must be the child of a rendered "atomic-result" element.
  * @returns A promise that resolves on initialization of the parent "atomic-result" element, or rejects when there is no parent "atomic-result" element.
+ *
+ * @deprecated should only be used for Stencil components. For Lit components, use `fetchResultContext` from \@/src/components/search/result-template-component-utils/context/fetch-result-context.ts
  */
 export declare function resultContext<T extends Result | FoldedResult = Result>(element: Element): Promise<T>;