@coveo/atomic 3.27.5-pre.fc6b95219b → 3.28.0-pre.1b995035ea

package/dist/atomic/components/components/commerce/atomic-commerce-text/atomic-commerce-text.js

@@ -0,0 +1,54 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { bindingGuard } from "../../../decorators/binding-guard";
+import { bindings } from "../../../decorators/bindings";
+import { errorGuard } from "../../../decorators/error-guard";
+import { InitializeBindingsMixin } from "../../../mixins/bindings-mixin";
+import { LitElement, html } from 'lit';
+import { customElement, property, state } from 'lit/decorators.js';
+/**
+ * @alpha
+ * The `atomic-commerce-text` component leverages the I18n translation module through the atomic-commerce-interface.
+ */
+let AtomicCommerceText = class AtomicCommerceText extends InitializeBindingsMixin(LitElement) {
+    get strings() {
+        return {
+            value: () => this.bindings.i18n.t(this.value, {
+                count: this.count,
+            }),
+        };
+    }
+    initialize() {
+        if (!this.value) {
+            this.error = new Error('The "value" attribute must be defined.');
+        }
+    }
+    render() {
+        return html `${this.strings.value()}`;
+    }
+};
+__decorate([
+    state()
+], AtomicCommerceText.prototype, "bindings", void 0);
+__decorate([
+    state()
+], AtomicCommerceText.prototype, "error", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], AtomicCommerceText.prototype, "value", void 0);
+__decorate([
+    property({ type: Number, reflect: true })
+], AtomicCommerceText.prototype, "count", void 0);
+__decorate([
+    bindingGuard(),
+    errorGuard()
+], AtomicCommerceText.prototype, "render", null);
+AtomicCommerceText = __decorate([
+    customElement('atomic-commerce-text'),
+    bindings()
+], AtomicCommerceText);
+export { AtomicCommerceText };

package/dist/atomic/components/components/commerce/atomic-product-template/atomic-product-template.js

@@ -10,6 +10,8 @@ import { html, LitElement, nothing } from 'lit';
 import { property, customElement, state } from 'lit/decorators.js';
 import { makeMatchConditions } from '../../common/product-template/product-template-common';
 import { ProductTemplateController } from '../../common/product-template/product-template-controller';
+import '../atomic-commerce-text/atomic-commerce-text';
+import '../atomic-product-text/atomic-product-text';
 import '../atomic-product/atomic-product';
 /**
  * @alpha

package/dist/atomic/components/components/commerce/atomic-product-text/atomic-product-text.js

@@ -0,0 +1,135 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { booleanConverter } from "../../../converters/boolean-converter";
+import { bindingGuard } from "../../../decorators/binding-guard";
+import { bindings } from "../../../decorators/bindings";
+import { createProductContextController } from "../../../decorators/commerce/product-template-decorators.js";
+import { errorGuard } from "../../../decorators/error-guard";
+import { InitializeBindingsMixin } from "../../../mixins/bindings-mixin";
+import { ProductTemplatesHelpers, HighlightUtils, } from '@coveo/headless/commerce';
+import { LitElement, html, nothing } from 'lit';
+import { customElement, property, state } from 'lit/decorators.js';
+import { when } from 'lit/directives/when.js';
+import { getFieldValueCaption } from '../../../utils/field-utils';
+import { renderItemTextFallback } from '../../common/item-text/item-text-fallback.js';
+import { renderItemTextHighlighted } from '../../common/item-text/item-text-highlighted.js';
+import '../atomic-commerce-text/atomic-commerce-text';
+import { getStringValueFromProductOrNull } from '../product-template-component-utils/product-utils.js';
+/**
+ * The `atomic-product-text` component renders the value of a string field for a given product.
+ */
+let AtomicProductText = class AtomicProductText extends InitializeBindingsMixin(LitElement) {
+    constructor() {
+        super(...arguments);
+        /**
+         * Whether to highlight the string field value.
+         *
+         * Only works if the `field` property is set to `excerpt` or `ec_name`.
+         */
+        this.shouldHighlight = true;
+        this.productController = createProductContextController(this);
+    }
+    initialize() {
+        if (!this.product && this.productController.item) {
+            this.product = this.productController.item;
+        }
+    }
+    get shouldRenderHighlights() {
+        return this.shouldHighlight && this.isFieldSupportedForHighlighting();
+    }
+    isFieldSupportedForHighlighting() {
+        return ['ec_name', 'excerpt'].includes(this.field);
+    }
+    get highlightKeywords() {
+        if (!this.shouldRenderHighlights) {
+            return null;
+        }
+        return ProductTemplatesHelpers.getProductProperty(this.product, this.field === 'ec_name' ? 'nameHighlights' : 'excerptHighlights');
+    }
+    renderFallback() {
+        if (!this.default) {
+            return nothing;
+        }
+        return renderItemTextFallback({
+            props: {
+                field: this.field,
+                host: this,
+                logger: this.bindings.engine.logger,
+                defaultValue: this.default,
+                item: this.product,
+                getProperty: (result, property) => ProductTemplatesHelpers.getProductProperty(result, property),
+            },
+        })(html `
+      <atomic-commerce-text
+        .value=${getFieldValueCaption(this.field, this.default, this.bindings.i18n)}
+      ></atomic-commerce-text>
+    `);
+    }
+    renderProductText(textValue) {
+        const highlightKeywords = this.highlightKeywords;
+        return this.shouldRenderHighlights &&
+            highlightKeywords &&
+            highlightKeywords.length > 0
+            ? renderItemTextHighlighted({
+                props: {
+                    textValue,
+                    highlightKeywords,
+                    highlightString: HighlightUtils.highlightString,
+                    onError: (error) => (this.error = error),
+                },
+            })
+            : html `
+          <atomic-commerce-text
+            .value=${getFieldValueCaption(this.field, textValue, this.bindings.i18n)}
+          ></atomic-commerce-text>
+        `;
+    }
+    renderProductTextValue() {
+        const productValueAsString = getStringValueFromProductOrNull(this.product, this.field);
+        if (productValueAsString === null) {
+            return this.renderFallback();
+        }
+        return this.renderProductText(`${productValueAsString}`);
+    }
+    render() {
+        return html `
+      ${when(this.product && this.field, () => this.renderProductTextValue(), () => nothing)}
+    `;
+    }
+};
+__decorate([
+    property({ type: String, reflect: true })
+], AtomicProductText.prototype, "field", void 0);
+__decorate([
+    property({
+        type: Boolean,
+        attribute: 'should-highlight',
+        reflect: true,
+        converter: booleanConverter,
+    })
+], AtomicProductText.prototype, "shouldHighlight", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], AtomicProductText.prototype, "default", void 0);
+__decorate([
+    state()
+], AtomicProductText.prototype, "product", void 0);
+__decorate([
+    state()
+], AtomicProductText.prototype, "bindings", void 0);
+__decorate([
+    state()
+], AtomicProductText.prototype, "error", void 0);
+__decorate([
+    bindingGuard(),
+    errorGuard()
+], AtomicProductText.prototype, "render", null);
+AtomicProductText = __decorate([
+    bindings(),
+    customElement('atomic-product-text')
+], AtomicProductText);
+export { AtomicProductText };

package/dist/atomic/components/components/commerce/index.js

@@ -5,6 +5,7 @@ export { AtomicCommerceInterface } from './atomic-commerce-interface/atomic-comm
 export { AtomicCommerceLayout } from './atomic-commerce-layout/atomic-commerce-layout.js';
 export { AtomicCommercePager } from './atomic-commerce-pager/atomic-commerce-pager.js';
 export { AtomicCommerceProductList } from './atomic-commerce-product-list/atomic-commerce-product-list.js';
+export { AtomicCommerceProductsPerPage } from './atomic-commerce-products-per-page/atomic-commerce-products-per-page.js';
 export { AtomicCommerceQuerySummary } from './atomic-commerce-query-summary/atomic-commerce-query-summary.js';
 export { AtomicCommerceRecommendationList } from './atomic-commerce-recommendation-list/atomic-commerce-recommendation-list.js';
 export { AtomicCommerceSearchBox } from './atomic-commerce-search-box/atomic-commerce-search-box.js';
@@ -12,5 +13,7 @@ export { AtomicCommerceSearchBoxInstantProducts } from './atomic-commerce-search
 export { AtomicCommerceSearchBoxQuerySuggestions } from './atomic-commerce-search-box-query-suggestions/atomic-commerce-search-box-query-suggestions.js';
 export { AtomicCommerceSearchBoxRecentQueries } from './atomic-commerce-search-box-recent-queries/atomic-commerce-search-box-recent-queries.js';
 export { AtomicCommerceSortDropdown } from './atomic-commerce-sort-dropdown/atomic-commerce-sort-dropdown.js';
+export { AtomicCommerceText } from './atomic-commerce-text/atomic-commerce-text.js';
 export { AtomicProduct } from './atomic-product/atomic-product.js';
 export { AtomicProductTemplate } from './atomic-product-template/atomic-product-template.js';
+export { AtomicProductText } from './atomic-product-text/atomic-product-text.js';

package/dist/atomic/components/components/commerce/lazy-index.js

@@ -6,6 +6,7 @@ export default {
     'atomic-commerce-layout': async () => await import('./atomic-commerce-layout/atomic-commerce-layout.js'),
     'atomic-commerce-pager': async () => await import('./atomic-commerce-pager/atomic-commerce-pager.js'),
     'atomic-commerce-product-list': async () => await import('./atomic-commerce-product-list/atomic-commerce-product-list.js'),
+    'atomic-commerce-products-per-page': async () => await import('./atomic-commerce-products-per-page/atomic-commerce-products-per-page.js'),
     'atomic-commerce-query-summary': async () => await import('./atomic-commerce-query-summary/atomic-commerce-query-summary.js'),
     'atomic-commerce-recommendation-list': async () => await import('./atomic-commerce-recommendation-list/atomic-commerce-recommendation-list.js'),
     'atomic-commerce-search-box': async () => await import('./atomic-commerce-search-box/atomic-commerce-search-box.js'),
@@ -13,6 +14,8 @@ export default {
     'atomic-commerce-search-box-query-suggestions': async () => await import('./atomic-commerce-search-box-query-suggestions/atomic-commerce-search-box-query-suggestions.js'),
     'atomic-commerce-search-box-recent-queries': async () => await import('./atomic-commerce-search-box-recent-queries/atomic-commerce-search-box-recent-queries.js'),
     'atomic-commerce-sort-dropdown': async () => await import('./atomic-commerce-sort-dropdown/atomic-commerce-sort-dropdown.js'),
+    'atomic-commerce-text': async () => await import('./atomic-commerce-text/atomic-commerce-text.js'),
     'atomic-product': async () => await import('./atomic-product/atomic-product.js'),
     'atomic-product-template': async () => await import('./atomic-product-template/atomic-product-template.js'),
+    'atomic-product-text': async () => await import('./atomic-product-text/atomic-product-text.js'),
 };

package/dist/atomic/components/components/commerce/product-template-component-utils/error.js

@@ -0,0 +1,6 @@
+export class FieldValueIsNaNError extends Error {
+    constructor(field, value) {
+        super(`Could not parse "${value}" from field "${field}" as a number.`);
+        this.name = 'FieldValueIsNaNError';
+    }
+}

package/dist/atomic/components/components/commerce/product-template-component-utils/product-utils.js

@@ -0,0 +1,35 @@
+import { readFromObject } from "../../../utils/object-utils";
+import { ProductTemplatesHelpers } from '@coveo/headless/commerce';
+import { FieldValueIsNaNError } from './error';
+export function parseValue(product, field) {
+    const value = ProductTemplatesHelpers.getProductProperty(product, field);
+    if (value === null) {
+        return null;
+    }
+    const valueAsNumber = parseFloat(`${value}`);
+    if (Number.isNaN(valueAsNumber)) {
+        throw new FieldValueIsNaNError(field, value);
+    }
+    return valueAsNumber;
+}
+export function getStringValueFromProductOrNull(product, field) {
+    const value = ProductTemplatesHelpers.getProductProperty(product, field);
+    if (typeof value !== 'string' || value.trim() === '') {
+        return null;
+    }
+    return value;
+}
+export function buildStringTemplateFromProduct(template, product, bindings) {
+    return template.replace(/\${(.*?)}/g, (value) => {
+        const key = value.substring(2, value.length - 1);
+        let newValue = readFromObject(product, key);
+        if (!newValue && typeof window !== 'undefined') {
+            newValue = readFromObject(window, key);
+        }
+        if (!newValue) {
+            bindings.engine.logger.warn(`${key} used in the href template is undefined for this product: ${product.permanentid} and could not be found in the window object.`);
+            return '';
+        }
+        return newValue;
+    });
+}

package/dist/atomic/components/components/common/atomic-layout-section/atomic-layout-section.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LitElement } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+/**
+ * The `atomic-layout-section` lets you identify various sections for the related `atomic-search-layout` or `atomic-commerce-layout` component.
+ *
+ * @slot default - The default slot where you can add child components to the section.
+ */
+let AtomicLayoutSection = class AtomicLayoutSection extends LitElement {
+    createRenderRoot() {
+        return this;
+    }
+};
+__decorate([
+    property({ type: String, reflect: true })
+], AtomicLayoutSection.prototype, "section", void 0);
+__decorate([
+    property({ type: String, reflect: true, attribute: 'min-width' })
+], AtomicLayoutSection.prototype, "minWidth", void 0);
+__decorate([
+    property({ type: String, reflect: true, attribute: 'max-width' })
+], AtomicLayoutSection.prototype, "maxWidth", void 0);
+AtomicLayoutSection = __decorate([
+    customElement('atomic-layout-section')
+], AtomicLayoutSection);
+export { AtomicLayoutSection };

package/dist/atomic/components/components/common/fieldset-group.js

@@ -0,0 +1,5 @@
+import { html } from 'lit';
+export const renderFieldsetGroup = ({ props: { label } }) => (children) => html `<fieldset class="contents">
+      <legend class="sr-only">${label}</legend>
+      ${children}
+    </fieldset>`;

package/dist/atomic/components/components/common/index.js

@@ -1,3 +1,4 @@
 // Auto-generated file
 export { AtomicComponentError } from './atomic-component-error/atomic-component-error.js';
 export { AtomicIcon } from './atomic-icon/atomic-icon.js';
+export { AtomicLayoutSection } from './atomic-layout-section/atomic-layout-section.js';

package/dist/atomic/components/components/common/item-text/field-warning.js

@@ -0,0 +1,6 @@
+import { isArray } from '@coveo/bueno';
+export function possiblyWarnOnBadFieldType(field, itemValueRaw, host, logger) {
+    if (isArray(itemValueRaw)) {
+        logger.error(`${host.nodeName.toLowerCase()} cannot be used with multi value field "${field}" with values "${itemValueRaw}".`, host);
+    }
+}

package/dist/atomic/components/components/common/item-text/item-text-fallback.js

@@ -0,0 +1,15 @@
+import { isUndefined } from '@coveo/bueno';
+import { html, nothing } from 'lit';
+import { possiblyWarnOnBadFieldType } from './field-warning.js';
+export const renderItemTextFallback = ({ props }) => (children) => {
+    const { getProperty, item, field, host, logger, defaultValue } = props;
+    const raw = getProperty(item, field);
+    possiblyWarnOnBadFieldType(field, raw, host, logger);
+    if (isUndefined(defaultValue)) {
+        host.remove();
+        return nothing;
+    }
+    else {
+        return html `${children}`;
+    }
+};

package/dist/atomic/components/components/common/item-text/item-text-highlighted.js

@@ -0,0 +1,17 @@
+import { html, nothing } from 'lit';
+import { unsafeHTML } from 'lit/directives/unsafe-html.js';
+import { renderWithHighlights, } from './render-highlights.js';
+/**
+ * The renderItemTextHighlighted functional component renders text with highlighted keywords.
+ */
+export const renderItemTextHighlighted = ({ props }) => {
+    const { textValue, highlightKeywords, highlightString, onError = (error) => console.error(error), } = props;
+    try {
+        const highlightedValue = renderWithHighlights(textValue, highlightKeywords, highlightString);
+        return html `${unsafeHTML(highlightedValue)}`;
+    }
+    catch (error) {
+        onError(error);
+        return nothing;
+    }
+};

package/dist/atomic/components/components/common/item-text/render-highlights.js

@@ -0,0 +1,13 @@
+export function renderWithHighlights(value, highlights, highlightString) {
+    const openingDelimiter = '_openingDelimiter_';
+    const closingDelimiter = '_closingDelimiter_';
+    const highlightedValue = highlightString({
+        content: value,
+        openingDelimiter,
+        closingDelimiter,
+        highlights,
+    });
+    return highlightedValue
+        .replace(new RegExp(openingDelimiter, 'g'), '<b>')
+        .replace(new RegExp(closingDelimiter, 'g'), '</b>');
+}

package/dist/atomic/components/components/common/items-per-page/choices.js

@@ -0,0 +1,47 @@
+import { html } from 'lit';
+import { renderRadioButton } from '../radio-button';
+export const renderChoices = ({ props }) => {
+    const { label, groupName, pageSize, choices, lang, scrollToTopEvent, setItemSize, focusOnFirstResultAfterNextSearch, focusOnNextNewResult, } = props;
+    const focusOnProperResultDependingOnChoice = (choice) => {
+        if (choice < pageSize) {
+            focusOnFirstResultAfterNextSearch()?.then(() => scrollToTopEvent());
+        }
+        else if (choice > pageSize) {
+            focusOnNextNewResult();
+        }
+    };
+    return html `
+    <div
+      part="buttons"
+      role="radiogroup"
+      aria-label=${label}
+      class="flex flex-wrap gap-2"
+    >
+      ${choices.map((choice) => {
+        const isSelected = pageSize === choice;
+        const parts = ['button'];
+        if (isSelected) {
+            parts.push('active-button');
+        }
+        const text = choice.toLocaleString(lang);
+        return renderRadioButton({
+            props: {
+                key: 'choice',
+                groupName,
+                style: 'outline-neutral',
+                checked: isSelected,
+                ariaLabel: text,
+                onChecked: () => {
+                    focusOnProperResultDependingOnChoice(choice);
+                    setItemSize(choice);
+                },
+                class: 'btn-page focus-visible:bg-neutral-light',
+                part: parts.join(' '),
+                text,
+                selectWhenFocused: false,
+            },
+        });
+    })}
+    </div>
+  `;
+};

package/dist/atomic/components/components/common/items-per-page/error.js

@@ -0,0 +1,18 @@
+export class ChoiceIsNaNError extends Error {
+    constructor(choice) {
+        super(`The choice value "${choice}" from the "choicesDisplayed" option is not a number.`);
+        this.name = 'ChoiceIsNaNError';
+    }
+}
+export class InitialChoiceNotInChoicesError extends Error {
+    constructor(initialChoice, choices) {
+        super(`The initial choice value "${initialChoice}" is not included in the choices ${choices}.`);
+        this.name = 'InitialChoiceNotInChoicesError';
+    }
+}
+export class ChoiceIsNonPositiveError extends Error {
+    constructor(choice) {
+        super(`The choice value "${choice}" from the "choicesDisplayed" option is not positive (<= 0).`);
+        this.name = 'ChoiceIsNonPositiveError';
+    }
+}

package/dist/atomic/components/components/common/items-per-page/label.js

@@ -0,0 +1,10 @@
+import { html } from 'lit';
+export const renderLabel = () => (children) => html `
+    <span
+      part="label"
+      class="text-on-background mr-3 self-start text-lg leading-10"
+      aria-hidden="true"
+    >
+      ${children}
+    </span>
+  `;

package/dist/atomic/components/components/common/items-per-page/validate.js

@@ -0,0 +1,19 @@
+import { ChoiceIsNaNError, ChoiceIsNonPositiveError, InitialChoiceNotInChoicesError, } from './error';
+export function convertChoicesToNumbers(choices) {
+    return choices.split(',').map((choice) => {
+        const parsedChoice = parseInt(choice);
+        if (isNaN(parsedChoice)) {
+            throw new ChoiceIsNaNError(choice);
+        }
+        if (parsedChoice <= 0) {
+            throw new ChoiceIsNonPositiveError(parsedChoice);
+        }
+        return parsedChoice;
+    });
+}
+export function validateInitialChoice(initialChoice, choices) {
+    if (!choices.includes(initialChoice)) {
+        throw new InitialChoiceNotInChoicesError(initialChoice, choices);
+    }
+    return initialChoice;
+}

package/dist/atomic/components/components/common/lazy-index.js

@@ -2,4 +2,5 @@
 export default {
     'atomic-component-error': async () => await import('./atomic-component-error/atomic-component-error.js'),
     'atomic-icon': async () => await import('./atomic-icon/atomic-icon.js'),
+    'atomic-layout-section': async () => await import('./atomic-layout-section/atomic-layout-section.js'),
 };

package/dist/atomic/components/facet-date-input.js

@@ -65,13 +65,13 @@ const FacetDateInput = /*@__PURE__*/ proxyCustomElement(class FacetDateInput ext
         // Fallback for Safari < 14.1, date with format yyyy-mm-dd over 1400 (API limit)
         const pattern = '^(1[4-9]\\d{2}|2\\d{3})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$';
         const range = this.rangeGetter();
-        return (h("form", { key: 'd8db4385e4295f182fc9b9db2ade10ff62b59615', class: "mt-4 grid grid-cols-[min-content_1fr] gap-2 px-2", onSubmit: (e) => {
+        return (h("form", { key: '5b9dcc787bc6df5e367c5f42399870887c47d1ac', class: "mt-4 grid grid-cols-[min-content_1fr] gap-2 px-2", onSubmit: (e) => {
                 e.preventDefault();
                 this.apply();
                 return false;
-            } }, h("label", { key: 'bef5b47105d800c423b61c42cc50b6329cc624c1', part: "input-label", class: labelClasses, htmlFor: `${this.facetId}_start` }, startLabel, ":"), h("input", { key: '6dc2ddab55046089ceb8d57883420e6a1935b866', id: `${this.facetId}_start`, part: "input-start", type: "date", ref: (ref) => (this.startRef = ref), class: inputClasses, "aria-label": startAria, placeholder: placeholder, pattern: pattern, required: true,
+            } }, h("label", { key: '402453cff10dc0145067c4915c37f4664062b483', part: "input-label", class: labelClasses, htmlFor: `${this.facetId}_start` }, startLabel, ":"), h("input", { key: '9b29df3dc13bfa9f8a75c7bc4528ed81c75b26a4', id: `${this.facetId}_start`, part: "input-start", type: "date", ref: (ref) => (this.startRef = ref), class: inputClasses, "aria-label": startAria, placeholder: placeholder, pattern: pattern, required: true,
             // API/Index minimum supported date
-            min: this.min || this.formattedDateValue('1401-01-01'), max: this.end ? this.formattedDateValue(this.end) : this.max, value: this.formattedDateValue(range?.start), onInput: (e) => (this.start = parseDate(e.target.value).toDate()) }), h("label", { key: '10aaa6a1477be4f377c05b81025c8f5bcf042e96', part: "input-label", class: labelClasses, htmlFor: `${this.facetId}_end` }, endLabel, ":"), h("input", { key: '3fccac3931ef503413bb9e830f8cc7ec2f31a52d', id: `${this.facetId}_end`, part: "input-end", type: "date", ref: (ref) => (this.endRef = ref), class: inputClasses, "aria-label": endAria, placeholder: placeholder, pattern: pattern, required: true, min: this.formattedDateValue(this.start) || this.min, max: this.max, value: this.formattedDateValue(range?.end), onInput: (e) => (this.end = parseDate(e.target.value).toDate()) }), h(Button, { key: '8bb6165a256975cd26cdb92c2af1b8489b890c72', style: "outline-primary", type: "submit", part: "input-apply-button", class: "col-span-2 truncate p-2.5", ariaLabel: applyAria, text: apply })));
+            min: this.min || this.formattedDateValue('1401-01-01'), max: this.end ? this.formattedDateValue(this.end) : this.max, value: this.formattedDateValue(range?.start), onInput: (e) => (this.start = parseDate(e.target.value).toDate()) }), h("label", { key: 'be0174d19a814f5119ef504f56a60f1d00e690ed', part: "input-label", class: labelClasses, htmlFor: `${this.facetId}_end` }, endLabel, ":"), h("input", { key: '1786cc6d87fe13282dc0c7a4e56c5a979ad10d39', id: `${this.facetId}_end`, part: "input-end", type: "date", ref: (ref) => (this.endRef = ref), class: inputClasses, "aria-label": endAria, placeholder: placeholder, pattern: pattern, required: true, min: this.formattedDateValue(this.start) || this.min, max: this.max, value: this.formattedDateValue(range?.end), onInput: (e) => (this.end = parseDate(e.target.value).toDate()) }), h(Button, { key: '4d15da7ba14e0349e0caa0b576c392ad331c29f9', style: "outline-primary", type: "submit", part: "input-apply-button", class: "col-span-2 truncate p-2.5", ariaLabel: applyAria, text: apply })));
     }
 }, [0, "atomic-facet-date-input", {
         "bindings": [16],

package/dist/atomic/components/facet-number-input.js

@@ -42,11 +42,11 @@ const FacetNumberInput = /*@__PURE__*/ proxyCustomElement(class FacetNumberInput
         const inputClasses = 'p-2.5 input-primary placeholder-neutral-dark min-w-0 mr-1';
         const labelClasses = 'text-neutral-dark text-sm';
         const step = this.type === 'integer' ? '1' : 'any';
-        return (h("form", { key: '805e001012201b280e5820a7674a41f7f20b79ed', class: "mt-4 gap-y-0.5 px-2", part: "input-form", onSubmit: (e) => {
+        return (h("form", { key: 'aeec1e4f98899d1653df921fc0a9c53ca3fcbf3b', class: "mt-4 gap-y-0.5 px-2", part: "input-form", onSubmit: (e) => {
                 e.preventDefault();
                 this.apply();
                 return false;
-            } }, h("label", { key: '6285713ae74850a682225a3805d4b0dfb4312351', part: "label-start", class: labelClasses, htmlFor: `${this.filterState.facetId}_start` }, minText), h("input", { key: '234b78c7576407d5a976e2f1dae6fba679539593', part: "input-start", id: `${this.filterState.facetId}_start`, type: "number", step: step, ref: (ref) => (this.startRef = ref), class: inputClasses, "aria-label": minAria, required: true, min: Number.MIN_SAFE_INTEGER, max: this.end, value: this.filterState.range?.start, onInput: (e) => (this.start = e.target.valueAsNumber) }), h("label", { key: '70161503018f6216d48de99f47671edee1fce28b', part: "label-end", class: labelClasses, htmlFor: `${this.filterState.facetId}_end` }, maxText), h("input", { key: '1a1311e051daf2bac1771cb500a79859aaa0a795', part: "input-end", id: `${this.filterState.facetId}_end`, type: "number", step: step, ref: (ref) => (this.endRef = ref), class: inputClasses, "aria-label": maxAria, required: true, min: this.start, max: Number.MAX_SAFE_INTEGER, value: this.filterState.range?.end, onInput: (e) => (this.end = e.target.valueAsNumber) }), h(Button, { key: '267ee8fa7e6bb2dc8dc248a1c49b0ac757b4efe3', style: "outline-primary", type: "submit", part: "input-apply-button", class: "flex-none truncate p-2.5", ariaLabel: applyAria, text: apply })));
+            } }, h("label", { key: 'edfa0efd988534f6c8228215489220f79504e166', part: "label-start", class: labelClasses, htmlFor: `${this.filterState.facetId}_start` }, minText), h("input", { key: 'c032ead904ce549843de5ca3f124d8502a3e4d14', part: "input-start", id: `${this.filterState.facetId}_start`, type: "number", step: step, ref: (ref) => (this.startRef = ref), class: inputClasses, "aria-label": minAria, required: true, min: Number.MIN_SAFE_INTEGER, max: this.end, value: this.filterState.range?.start, onInput: (e) => (this.start = e.target.valueAsNumber) }), h("label", { key: '5e6950b85237aaf46b09d00487f882044402eec1', part: "label-end", class: labelClasses, htmlFor: `${this.filterState.facetId}_end` }, maxText), h("input", { key: 'c07d8787a0bcdc8f267f3d753752feb14c1e14f2', part: "input-end", id: `${this.filterState.facetId}_end`, type: "number", step: step, ref: (ref) => (this.endRef = ref), class: inputClasses, "aria-label": maxAria, required: true, min: this.start, max: Number.MAX_SAFE_INTEGER, value: this.filterState.range?.end, onInput: (e) => (this.end = e.target.valueAsNumber) }), h(Button, { key: '97b81fcf3f99a3a250b1f4e538dd720893be20fe', style: "outline-primary", type: "submit", part: "input-apply-button", class: "flex-none truncate p-2.5", ariaLabel: applyAria, text: apply })));
     }
     static get style() { return AtomicFacetNumberInputStyle0; }
 }, [0, "atomic-facet-number-input", {

package/dist/atomic/components/global/environment.js

@@ -4,7 +4,7 @@ function getWindow() {
 }
 export function getAtomicEnvironment() {
     return {
-        version: "3.27.5-pre.fc6b95219b".VERSION,
+        version: "3.28.0-pre.1b995035ea".VERSION,
         headlessVersion: VERSION,
     };
 }

package/dist/atomic/components/index.js.map

@@ -1 +1 @@
-{"file":"index.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAca,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,WAAmB,EAAE,UAAkB;QACjD,KAAK,CACH,QAAQ,WAAW,sCAAsC,UAAU,YAAY,CAChF,CAAC;KACH;;;ACfH,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;SAIpC,gBAAgB,CAAI,OAAgB,EAAE,UAAkB;IACtE,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM;QACpC,MAAM,KAAK,GAAG,gBAAgB,CAC5B,oBAAoB,EACpB,CAAC,IAAO;YACN,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;SACtB,CACF,CAAC;QACF,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAE7B,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE;YACjC,MAAM,CACJ,IAAI,kBAAkB,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,UAAU,CAAC,CACnE,CAAC;SACH;KACF,CAAC,CAAC;AACL;;ACkDA;;;;;;;;;;SAUgB,mBAAmB,CAAoB,OAAgB;IACrE,OAAO,gBAAgB,CAAI,OAAO,EAAE,gBAAgB,CAAC,CAAC;AACxD;;;;","names":[],"sources":["src/components/common/item-list/context/item-context-controller.ts","src/components/common/item-list/fetch-item-context.ts","src/decorators/commerce/product-template-decorators.ts"],"sourcesContent":["import {InitializableComponent} from '@/src/decorators/types.js';\nimport {buildCustomEvent} from '@/src/utils/event-utils';\nimport {LitElement, ReactiveController, ReactiveControllerHost} from 'lit';\n\ntype LitElementWithError = Omit<\n  Pick<InitializableComponent, 'error'>,\n  'error'\n> &\n  LitElement & {\n    error: Error | null;\n  };\n\nconst itemContextEventName = 'atomic/resolveResult';\n\nexport class MissingParentError extends Error {\n  constructor(elementName: string, parentName: string) {\n    super(\n      `The \"${elementName}\" element must be the child of an \"${parentName}\" element.`\n    );\n  }\n}\n\nfunction extractFolded<T = Record<string, unknown>>(\n  item: Record<string, unknown>,\n  returnFolded: boolean\n): T {\n  if (returnFolded) {\n    if ('children' in item) {\n      return item as T;\n    } else {\n      return {children: [], result: item} as T;\n    }\n  }\n\n  if ('children' in item && 'result' in item) {\n    return item.result as T;\n  }\n  return item as T;\n}\n\n/**\n * A reactive controller that manages item context data from parent components.\n * Handles fetching item data via custom events and manages error states.\n */\nexport class ItemContextController<T = Record<string, unknown>>\n  implements ReactiveController\n{\n  private host: ReactiveControllerHost & LitElementWithError;\n  private parentName: string;\n  private folded: boolean;\n  private _item: T | null = null;\n  private _error: MissingParentError | null = null;\n\n  constructor(\n    host: ReactiveControllerHost & LitElementWithError,\n    options: {parentName?: string; folded?: boolean} = {}\n  ) {\n    this.host = host;\n    this.parentName = options.parentName ?? 'atomic-result';\n    this.folded = options.folded ?? false;\n    host.addController(this);\n  }\n\n  get item(): T | null {\n    return this._error ? null : this._item;\n  }\n\n  get error(): MissingParentError | null {\n    return this._error;\n  }\n\n  get hasError(): boolean {\n    return this._error !== null;\n  }\n\n  hostConnected(): void {\n    this._resolveItemContext();\n  }\n\n  private _resolveItemContext(): void {\n    const event = buildCustomEvent(\n      itemContextEventName,\n      (item: Record<string, unknown>) => {\n        this._item = extractFolded<T>(item, this.folded);\n        this._error = null;\n        this.host.error = null;\n        this.host.requestUpdate();\n      }\n    );\n\n    const canceled = this.host.dispatchEvent(event);\n    if (canceled) {\n      const elementName = (this.host as Element).nodeName.toLowerCase();\n      this._error = new MissingParentError(elementName, this.parentName);\n      this._item = null;\n      this.host.error = this._error;\n      this.host.requestUpdate();\n    }\n  }\n}\n\ntype ItemContextEventHandler<T> = (item: T) => void;\nexport type ItemContextEvent<T> = CustomEvent<ItemContextEventHandler<T>>;\n","import {closest} from '../../../utils/dom-utils.js';\nimport {buildCustomEvent} from '../../../utils/event-utils.js';\nimport {MissingParentError} from './context/item-context-controller.js';\n\nconst itemContextEventName = 'atomic/resolveResult';\n\ntype ItemContextEventHandler<T> = (item: T) => void;\n\nexport function fetchItemContext<T>(element: Element, parentName: string) {\n  return new Promise<T>((resolve, reject) => {\n    const event = buildCustomEvent<ItemContextEventHandler<T>>(\n      itemContextEventName,\n      (item: T) => {\n        return resolve(item);\n      }\n    );\n    element.dispatchEvent(event);\n\n    if (!closest(element, parentName)) {\n      reject(\n        new MissingParentError(element.nodeName.toLowerCase(), parentName)\n      );\n    }\n  });\n}\n","import {InteractiveItemContextController} from '@/src/components/common/item-list/context/interactive-item-context-controller';\nimport {InteractiveItemContextEvent} from '@/src/components/common/item-list/context/interactive-item-context-controller';\nimport {\n  ItemContextController,\n  ItemContextEvent,\n} from '@/src/components/common/item-list/context/item-context-controller';\nimport {fetchItemContext} from '@/src/components/common/item-list/fetch-item-context';\nimport {InteractiveProduct, Product} from '@coveo/headless/commerce';\nimport {LitElement} from 'lit';\n\n/**\n * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing product context in product template components.\n *\n * @param host - The Lit component instance\n * @param options - Configuration options\n * @returns ItemContextController instance configured for atomic-product\n *\n * @example\n * ```typescript\n * @customElement('my-product-component')\n * export class MyProductComponent extends LitElement {\n *   private productController = createProductContextController(this);\n *\n *   @state() product!: Product;\n *\n *   render() {\n *     this.product = this.productController.item;\n *     return html`<div>${this.product?.ec_name}</div>`;\n *   }\n * }\n * ```\n */\nexport function createProductContextController(\n  host: LitElement & {error: Error | null},\n  options: {folded?: boolean} = {}\n): ItemContextController<Product> {\n  return new ItemContextController<Product>(host, {\n    parentName: 'atomic-product',\n    folded: options.folded ?? false,\n  });\n}\n\n/**\n * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing interactive product context in product template components.\n *\n * @param host - The Lit component instance\n * @returns InteractiveItemContextController instance\n *\n * @example\n * ```typescript\n * @customElement('my-interactive-product-component')\n * export class MyInteractiveProductComponent extends LitElement {\n *   private interactiveProductController = createInteractiveProductContextController(this);\n *\n *   @state() product!: Product;\n *\n *   render() {\n *     this.product = this.interactiveProductController.interactiveItem;\n *     return html`<div>${this.product?.ec_name}</div>`;\n *   }\n * }\n * ```\n */\nexport function createInteractiveProductContextController(\n  host: LitElement & {error: Error}\n): InteractiveItemContextController<InteractiveProduct> {\n  return new InteractiveItemContextController<InteractiveProduct>(host);\n}\n\nexport type ProductContextEvent<T = Product> = ItemContextEvent<T>;\nexport type InteractiveProductContextEvent<\n  T extends InteractiveProduct = InteractiveProduct,\n> = InteractiveItemContextEvent<T>;\n\n/**\n * Retrieves `Product` on a rendered `atomic-product`.\n *\n * This utility function is useful for building custom product template elements, see [Create a Product List](https://docs.coveo.com/en/atomic/latest/cc-search/create-custom-components/native-components/#custom-product-template-component-example) for more information.\n *\n * You should use the utility function in the [`connectedCallback` lifecycle method](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements#using_the_lifecycle_callbacks).\n *\n * @param element - The element that the event is dispatched to, which must be the child of a rendered `atomic-product`.\n * @returns A promise that resolves on initialization of the parent `atomic-product` element, or rejects when there is no parent `atomic-product` element.\n */\nexport function fetchProductContext<T extends Product>(element: Element) {\n  return fetchItemContext<T>(element, 'atomic-product');\n}\n"],"version":3}
+{"file":"index.js","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAca,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,WAAmB,EAAE,UAAkB;QACjD,KAAK,CACH,QAAQ,WAAW,sCAAsC,UAAU,YAAY,CAChF,CAAC;KACH;;;ACfH,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;SAIpC,gBAAgB,CAAI,OAAgB,EAAE,UAAkB;IACtE,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM;QACpC,MAAM,KAAK,GAAG,gBAAgB,CAC5B,oBAAoB,EACpB,CAAC,IAAO;YACN,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;SACtB,CACF,CAAC;QACF,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAE7B,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE;YACjC,MAAM,CACJ,IAAI,kBAAkB,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,UAAU,CAAC,CACnE,CAAC;SACH;KACF,CAAC,CAAC;AACL;;ACkDA;;;;;;;;;;SAUgB,mBAAmB,CAAoB,OAAgB;IACrE,OAAO,gBAAgB,CAAI,OAAO,EAAE,gBAAgB,CAAC,CAAC;AACxD;;;;","names":[],"sources":["src/components/common/item-list/context/item-context-controller.ts","src/components/common/item-list/fetch-item-context.ts","src/decorators/commerce/product-template-decorators.ts"],"sourcesContent":["import {InitializableComponent} from '@/src/decorators/types.js';\nimport {buildCustomEvent} from '@/src/utils/event-utils';\nimport {LitElement, ReactiveController, ReactiveControllerHost} from 'lit';\n\ntype LitElementWithError = Omit<\n  Pick<InitializableComponent, 'error'>,\n  'error'\n> &\n  LitElement & {\n    error: Error | null;\n  };\n\nconst itemContextEventName = 'atomic/resolveResult';\n\nexport class MissingParentError extends Error {\n  constructor(elementName: string, parentName: string) {\n    super(\n      `The \"${elementName}\" element must be the child of an \"${parentName}\" element.`\n    );\n  }\n}\n\nfunction extractFolded<T = Record<string, unknown>>(\n  item: Record<string, unknown>,\n  returnFolded: boolean\n): T {\n  if (returnFolded) {\n    if ('children' in item) {\n      return item as T;\n    } else {\n      return {children: [], result: item} as T;\n    }\n  }\n\n  if ('children' in item && 'result' in item) {\n    return item.result as T;\n  }\n  return item as T;\n}\n\n/**\n * A reactive controller that manages item context data from parent components.\n * Handles fetching item data via custom events and manages error states.\n */\nexport class ItemContextController<T = Record<string, unknown>>\n  implements ReactiveController\n{\n  private host: ReactiveControllerHost & LitElementWithError;\n  private parentName: string;\n  private folded: boolean;\n  private _item: T | null = null;\n  private _error: MissingParentError | null = null;\n\n  constructor(\n    host: ReactiveControllerHost & LitElementWithError,\n    options: {parentName?: string; folded?: boolean} = {}\n  ) {\n    this.host = host;\n    this.parentName = options.parentName ?? 'atomic-result';\n    this.folded = options.folded ?? false;\n    host.addController(this);\n  }\n\n  get item(): T | null {\n    return this._error ? null : this._item;\n  }\n\n  get error(): MissingParentError | null {\n    return this._error;\n  }\n\n  get hasError(): boolean {\n    return this._error !== null;\n  }\n\n  hostConnected(): void {\n    this._resolveItemContext();\n  }\n\n  private _resolveItemContext(): void {\n    const event = buildCustomEvent(\n      itemContextEventName,\n      (item: Record<string, unknown>) => {\n        this._item = extractFolded<T>(item, this.folded);\n        this._error = null;\n        this.host.error = null;\n        this.host.requestUpdate();\n      }\n    );\n\n    const canceled = this.host.dispatchEvent(event);\n    if (canceled) {\n      const elementName = (this.host as Element).nodeName.toLowerCase();\n      this._error = new MissingParentError(elementName, this.parentName);\n      this._item = null;\n      this.host.error = this._error;\n      this.host.requestUpdate();\n    }\n  }\n}\n\ntype ItemContextEventHandler<T> = (item: T) => void;\nexport type ItemContextEvent<T> = CustomEvent<ItemContextEventHandler<T>>;\n","import {closest} from '../../../utils/dom-utils.js';\nimport {buildCustomEvent} from '../../../utils/event-utils.js';\nimport {MissingParentError} from './context/item-context-controller.js';\n\nconst itemContextEventName = 'atomic/resolveResult';\n\ntype ItemContextEventHandler<T> = (item: T) => void;\n\nexport function fetchItemContext<T>(element: Element, parentName: string) {\n  return new Promise<T>((resolve, reject) => {\n    const event = buildCustomEvent<ItemContextEventHandler<T>>(\n      itemContextEventName,\n      (item: T) => {\n        return resolve(item);\n      }\n    );\n    element.dispatchEvent(event);\n\n    if (!closest(element, parentName)) {\n      reject(\n        new MissingParentError(element.nodeName.toLowerCase(), parentName)\n      );\n    }\n  });\n}\n","import {InteractiveItemContextController} from '@/src/components/common/item-list/context/interactive-item-context-controller';\nimport {InteractiveItemContextEvent} from '@/src/components/common/item-list/context/interactive-item-context-controller';\nimport {\n  ItemContextController,\n  ItemContextEvent,\n} from '@/src/components/common/item-list/context/item-context-controller';\nimport {fetchItemContext} from '@/src/components/common/item-list/fetch-item-context';\nimport {InteractiveProduct, Product} from '@coveo/headless/commerce';\nimport {LitElement} from 'lit';\n\n/**\n * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing product context in product template components.\n *\n * @param host - The Lit component instance\n * @param options - Configuration options\n * @returns ItemContextController instance configured for atomic-product\n *\n * @example\n * ```typescript\n * @customElement('my-product-component')\n * export class MyProductComponent extends LitElement {\n *   private productController = createProductContextController(this);\n *\n *   @state() product!: Product;\n *\n *   render() {\n *     this.product = this.productController.item;\n *     return html`<div>${this.product?.ec_name}</div>`;\n *   }\n * }\n * ```\n */\nexport function createProductContextController(\n  host: LitElement & {error: Error | null},\n  options: {folded?: boolean} = {}\n): ItemContextController<Product> {\n  return new ItemContextController<Product>(host, {\n    parentName: 'atomic-product',\n    folded: options.folded ?? false,\n  });\n}\n\n/**\n * Creates a [Lit reactive controller](https://lit.dev/docs/composition/controllers/) for managing interactive product context in product template components.\n *\n * @param host - The Lit component instance\n * @returns InteractiveItemContextController instance\n *\n * @example\n * ```typescript\n * @customElement('my-interactive-product-component')\n * export class MyInteractiveProductComponent extends LitElement {\n *   private interactiveProductController = createInteractiveProductContextController(this);\n *\n *   @state() product!: Product;\n *\n *   render() {\n *     this.product = this.interactiveProductController.interactiveItem;\n *     return html`<div>${this.product?.ec_name}</div>`;\n *   }\n * }\n * ```\n */\nexport function createInteractiveProductContextController(\n  host: LitElement & {error: Error}\n): InteractiveItemContextController<InteractiveProduct> {\n  return new InteractiveItemContextController<InteractiveProduct>(host);\n}\n\nexport type ProductContextEvent<T = Product> = ItemContextEvent<T>;\nexport type InteractiveProductContextEvent<\n  T extends InteractiveProduct = InteractiveProduct,\n> = InteractiveItemContextEvent<T>;\n\n/**\n * Retrieves `Product` on a rendered `atomic-product`.\n *\n * This utility function is useful for building custom product template elements, see [Create a Product List](https://docs.coveo.com/en/atomic/latest/cc-search/create-custom-components/native-components/#custom-product-template-component-example) for more information.\n *\n * You should use the utility function in the [`connectedCallback` lifecycle method](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements#using_the_lifecycle_callbacks).\n *\n * @param element - The element that the event is dispatched to, which must be the child of a rendered `atomic-product`.\n * @returns A promise that resolves on initialization of the parent `atomic-product` element, or rejects when there is no parent `atomic-product` element.\n */\nexport function fetchProductContext<T extends Product>(element: Element) {\n  return fetchItemContext<T>(element, 'atomic-product');\n}\n"],"version":3}

package/dist/atomic/components/interface-common-stencil.js

@@ -2220,7 +2220,7 @@ function getWindow() {
 }
 function getAtomicEnvironment() {
     return {
-        version: "3.27.5-pre.fc6b95219b",
+        version: "3.28.0-pre.1b995035ea",
         headlessVersion: VERSION,
     };
 }

package/dist/atomic/components/product-utils.js

@@ -13,13 +13,6 @@ function parseValue(product, field) {
     }
     return valueAsNumber;
 }
-function getStringValueFromProductOrNull(product, field) {
-    const value = ProductTemplatesHelpers.getProductProperty(product, field);
-    if (typeof value !== 'string' || value.trim() === '') {
-        return null;
-    }
-    return value;
-}
 function buildStringTemplateFromProduct(template, product, bindings) {
     return template.replace(/\${(.*?)}/g, (value) => {
         const key = value.substring(2, value.length - 1);
@@ -35,6 +28,6 @@ function buildStringTemplateFromProduct(template, product, bindings) {
     });
 }
 
-export { buildStringTemplateFromProduct as b, getStringValueFromProductOrNull as g, parseValue as p };
+export { buildStringTemplateFromProduct as b, parseValue as p };
 
 //# sourceMappingURL=product-utils.js.map