@envive-ai/react-hooks 0.2.1 → 0.2.2

package/dist/application/utils/index.d.ts

@@ -0,0 +1,263 @@
+import "../../index-Dr_c2DDq.js";
+import { FormResponseAttributes, Response as Response$1 } from "../../index-BN-3ctk_.js";
+import "../../index-DsiilEj-.js";
+import "../../utils-B1xLx9S8.js";
+import { Context as Context$1, Message, MessageRole, NextMessageRequest as NextMessageRequest$1, ProductSearchMessageMetadata, Suggestion as Suggestion$1, SupportedEventRequest as SupportedEventRequest$1, UserEvent as UserEvent$1 } from "../../index-CK_J3QMY.js";
+import "../../chatElementDisplayLocation-BwiXrkN7.js";
+import "../../frontendConfig-Dqxbqo8G.js";
+import "../../test-types-EzMFw_U3.js";
+import "../../spiffyWidgets-GILaqHv6.js";
+import "../../search-BLShhjvR.js";
+import "../../index-BoYC9XLW.js";
+import { SpiffyMetricsEventName } from "../../amplitudeContext-BhhYPJSL.js";
+import { MouseEventTypes, NodeSelector, SelectorFactory } from "../../nodeSelector-D5gjDWZ3.js";
+import { Context, NextMessageRequest, SupportedEventRequest, UserEvent } from "@spiffy-ai/commerce-api-client";
+import * as react3 from "react";
+import { ReactElement } from "react";
+
+//#region src/application/utils/analyticsUtils.d.ts
+declare global {
+  interface Window {
+    dataLayer: any[];
+  }
+}
+/**
+ * Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.
+ * This function runs on an interval until the dataLayer is available.
+ */
+declare const initDataLayerWrapper: (track: (eventName: SpiffyMetricsEventName, eventProps?: Record<string, unknown>) => void) => void;
+declare const initAmplitude: (track: (eventName: SpiffyMetricsEventName, eventProps?: Record<string, unknown>) => void) => void;
+//#endregion
+//#region src/application/utils/coreContextToApiContext.d.ts
+declare const coreContextToApiContext: (context: Context$1) => Context;
+//#endregion
+//#region src/application/utils/coreUserEventToApiUserEvent.d.ts
+declare const coreUserEventToApiUserEvent: (data: UserEvent$1) => UserEvent;
+//#endregion
+//#region src/application/utils/divideArray.d.ts
+declare const divideArray: <T>(array: T[], size: number) => T[][];
+//#endregion
+//#region src/application/utils/elementObserver.d.ts
+/**
+ * The `ElementObserver` class monitors all changes related to the specific element it is responsible for.
+ * It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.
+ *
+ * How it works:
+ *
+ * Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,
+ * such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node
+ * changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`
+ * is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`
+ * instance.
+ *
+ * Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.
+ * When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.
+ *
+ */
+declare class ElementObserver {
+  private mutation;
+  private node;
+  private selector;
+  private eventListeners;
+  private classAdded;
+  private classRemoved;
+  private nodeDisplay;
+  private addFn;
+  private removeFn;
+  private changeFn;
+  private classChangeFn;
+  private addChildFn?;
+  private removeChildFn?;
+  private resetFn;
+  constructor(selector: NodeSelector);
+  private handleAttributes;
+  private handleChildList;
+  private addInitialListeners;
+  private clearEventListeners;
+  private renew;
+  getSelector(): NodeSelector;
+  getNode(): HTMLElement | null;
+  synchronize(): void;
+  init(): void;
+  watch(node: Node): void;
+  destroy(): void;
+  render(fn: () => ReactElement): react3.ReactPortal | undefined;
+  fire(event: MouseEventTypes): void;
+  show(): void;
+  hide(): void;
+  registerEvent(event: keyof HTMLElementEventMap, fn: EventListenerOrEventListenerObject): void;
+  registerOnReset(fn: () => void): void;
+  registerOnChange(fn: (el: HTMLElement | null) => void): void;
+  registerOnAdd(fn: (el: HTMLElement | null) => void): void;
+  registerOnRemove(fn: (el: HTMLElement | null) => void): void;
+  registerOnclassChange(fn: (classes?: DOMTokenList) => void): void;
+  registerOnAddChild(fn: (classes?: DOMTokenList) => void): void;
+  registerOnRemoveChild(fn: (classes?: DOMTokenList) => void): void;
+  registerOnClassAdded(className: string, fn: () => void): void;
+  registerOnClassRemoved(className: string, fn: () => void): void;
+}
+//#endregion
+//#region src/application/utils/domObserver.d.ts
+/**
+ * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+ * added or removed from the DOM and notifies the observers for each observable element
+ * when they are ready to be watched.
+ *
+ * How that works:
+ *
+ * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+ * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+ * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+ *
+ * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+ *
+ * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+ * individual element observers and release any associated resources.
+ *
+ * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+ *
+ */
+declare class DOMObserver {
+  private static documentObserver;
+  private static listeners;
+  private static notifyAdition;
+  private static notifyRemoval;
+  private static notifyChildrenChanges;
+  private static mapNodeInstancesToListeners;
+  static add(selector: NodeSelector): ElementObserver;
+  static remove(selector: NodeSelector): void;
+  static observe(): void;
+  static destroy(): void;
+}
+//#endregion
+//#region src/application/utils/imageFilter.d.ts
+declare const getRecentProductImageUrls: (lastMessages: Message[], currentProductId: string | undefined) => string[];
+//#endregion
+//#region src/application/utils/merchantUtils.d.ts
+declare const prepareMerchantPage: () => void;
+//#endregion
+//#region src/application/utils/messageFromFormSubmittedEvent.d.ts
+declare const messageFromFormSubmittedEvent: (event: UserEvent$1, formResponseAttributes: FormResponseAttributes["attributes"]) => Message | undefined;
+//#endregion
+//#region src/application/utils/messageFromQueryEvent.d.ts
+/**
+ * Transforms a query UserEvent object into a Message object for presentation.
+ *
+ * @param event The user event object received from the server
+ *
+ * @returns A Message if the event is a query event, otherwise undefined
+ */
+declare const messageFromQueryEvent: (event: UserEvent$1) => Message | undefined;
+//#endregion
+//#region src/application/utils/messageFromResponse.d.ts
+/**
+ * Transforms a server Response object into a Message object for presentation.
+ *
+ * @param response The response object received from the server containing model generated content
+ *
+ * @returns A Message if the response contains known attributes, undefined otherwise
+ */
+declare const messageFromResponse: (response?: Response$1) => Message | undefined;
+//#endregion
+//#region src/application/utils/messageFromSuggestionEvent.d.ts
+/**
+ * Transforms a UserEvent object into a Message object for presentation.
+ *
+ * @param event The UserEvent object received from the server
+ * @param suggestions A list of generated suggestions to match the event to
+ *
+ * @returns A Message if the event is a suggestion click event, undefined otherwise
+ */
+declare const messageFromSuggestionEvent: (event: UserEvent$1, suggestions: Suggestion$1[]) => Message | undefined;
+//#endregion
+//#region src/application/utils/mutationHelper.d.ts
+declare class MutationHelper {
+  static fireClassChange(record: MutationRecord, node: HTMLElement | null, fn: (classes: DOMTokenList) => void): void;
+  static fireClassAdded(record: MutationRecord, node: HTMLElement | null, classMap: Map<string, () => void>): void;
+  static fireClassRemoved(record: MutationRecord, node: HTMLElement | null, classMap: Map<string, () => void>): void;
+  static fireSubtreeChange(nodes: NodeList, fn?: (nodes: NodeList) => void): void;
+  static isClass(mutation: MutationRecord): boolean;
+  static isChildList(mutation: MutationRecord): boolean;
+}
+//#endregion
+//#region src/application/utils/nextMessageRequestToApiRequest.d.ts
+declare const messageRequestToCommerceMessageRequest: (data: NextMessageRequest$1) => NextMessageRequest;
+//#endregion
+//#region src/application/utils/overrides.d.ts
+type ReplaceOp<T> = {
+  $replace: T;
+};
+type DeleteOp = {
+  $delete: true;
+};
+type Builtin = Date | RegExp | ((...args: unknown[]) => unknown);
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * Override<T> is a DeepPartial-like type with special operators:
+ * - { $replace: T } to replace an entire subtree/array
+ * - { $delete: true } to delete an object key
+ *
+ * Arrays behavior:
+ * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)
+ * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided
+ */
+type Override<T> = T extends Primitive | Builtin ? T | ReplaceOp<T> | DeleteOp : T extends (infer U)[] ? Array<Override<U> | undefined> | ReplaceOp<T> : T extends Map<unknown, unknown> | Set<unknown> ? ReplaceOp<T> : T extends object ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T> : T;
+type MergeOptions = {
+  /**
+   * How to treat arrays when patch provides an array (not $replace):
+   * - 'replace': always use patch array as whole value
+   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)
+   * Note: Arrays of primitives are replaced by default regardless of this option.
+   */
+  arrayStrategy?: 'replace' | 'mergeByIndex';
+  /**
+   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)
+   */
+  nullDeletes?: boolean;
+};
+type NoInfer<T> = [T][T extends unknown ? 0 : never];
+declare function applyOverrides<T>(base: T, patch: Override<NoInfer<T>>, opts?: MergeOptions): T;
+//#endregion
+//#region src/application/utils/stringUtils.d.ts
+declare class StringUtils {
+  static isNullOrEmpty(value: string | undefined): boolean;
+  static trimToNull(value: string | undefined): string | undefined;
+  static capitalize(type: string | undefined): string;
+  /**
+   * Finds the first pattern in an array that matches a given URL.
+   * Patterns can include a single wildcard '*' which matches any sequence of characters.
+   *
+   * @param patterns
+   * @param urlToTest
+   * @returns
+   */
+  static findMatchingPattern(patterns: string[], urlToTest: Location): string | undefined;
+}
+//#endregion
+//#region src/application/utils/supportedEventRequestToApiRequest.d.ts
+declare const coreSupportedEventRequestToApiRequest: (coreSupportedEventRequest: SupportedEventRequest$1) => SupportedEventRequest;
+//#endregion
+//#region src/application/utils/urlsParser.d.ts
+declare const parseHref: (href: string) => {
+  url: URL | undefined;
+  urlSearchParams: URLSearchParams | undefined;
+};
+declare const createUrlWithQueryParams: (url: string, queryParams: Record<string, string>) => string;
+declare const getQueryParam: (key: string) => string | null;
+type SearchMessage = {
+  id: string;
+  role: MessageRole;
+  createdAt: string;
+} & ProductSearchMessageMetadata;
+declare const buildSearchHash: (message: SearchMessage) => string;
+declare const buildSearchStartHash: (query: string) => string;
+declare const parseSearchHash: (hash: string) => {
+  id: string | null;
+  query: string | null;
+};
+//#endregion
+//#region src/application/utils/validation.d.ts
+declare const validateEmail: (value: string) => boolean;
+//#endregion
+export { DOMObserver, DeleteOp, ElementObserver, MergeOptions, MouseEventTypes, MutationHelper, NodeSelector, Override, ReplaceOp, SelectorFactory, StringUtils, applyOverrides, buildSearchHash, buildSearchStartHash, coreContextToApiContext, coreSupportedEventRequestToApiRequest, coreUserEventToApiUserEvent, createUrlWithQueryParams, divideArray, getQueryParam, getRecentProductImageUrls, initAmplitude, initDataLayerWrapper, messageFromFormSubmittedEvent, messageFromQueryEvent, messageFromResponse, messageFromSuggestionEvent, messageRequestToCommerceMessageRequest, parseHref, parseSearchHash, prepareMerchantPage, validateEmail };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/application/utils/analyticsUtils.d.ts","../../../src/application/utils/coreContextToApiContext.d.ts","../../../src/application/utils/coreUserEventToApiUserEvent.d.ts","../../../src/application/utils/divideArray.d.ts","../../../src/application/utils/elementObserver.d.ts","../../../src/application/utils/domObserver.d.ts","../../../src/application/utils/imageFilter.d.ts","../../../src/application/utils/merchantUtils.d.ts","../../../src/application/utils/messageFromFormSubmittedEvent.d.ts","../../../src/application/utils/messageFromQueryEvent.d.ts","../../../src/application/utils/messageFromResponse.d.ts","../../../src/application/utils/messageFromSuggestionEvent.d.ts","../../../src/application/utils/mutationHelper.d.ts","../../../src/application/utils/nextMessageRequestToApiRequest.d.ts","../../../src/application/utils/overrides.d.ts","../../../src/application/utils/stringUtils.d.ts","../../../src/application/utils/supportedEventRequestToApiRequest.d.ts","../../../src/application/utils/urlsParser.d.ts","../../../src/application/utils/validation.d.ts"],"sourcesContent":["import { SpiffyMetricsEventName } from \"src/contexts/amplitudeContext/amplitudeContext\";\ndeclare global {\n    interface Window {\n        dataLayer: any[];\n    }\n}\n/**\n * Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.\n * This function runs on an interval until the dataLayer is available.\n */\nexport declare const initDataLayerWrapper: (track: (eventName: SpiffyMetricsEventName, eventProps?: Record<string, unknown>) => void) => void;\nexport declare const initAmplitude: (track: (eventName: SpiffyMetricsEventName, eventProps?: Record<string, unknown>) => void) => void;\n","import { Context as ApiContext } from '@spiffy-ai/commerce-api-client';\nimport { Context as CoreContext } from '../models';\nexport declare const coreContextToApiContext: (context: CoreContext) => ApiContext;\n","import { UserEvent as ApiUserEvent } from '@spiffy-ai/commerce-api-client';\nimport { UserEvent as CoreUserEvent } from '../models';\nexport declare const coreUserEventToApiUserEvent: (data: CoreUserEvent) => ApiUserEvent;\n","export declare const divideArray: <T>(array: T[], size: number) => T[][];\n","import { ReactElement } from 'react';\nimport { MouseEventTypes } from './mouseEventTypes';\nimport { NodeSelector } from './nodeSelector';\n/**\n * The `ElementObserver` class monitors all changes related to the specific element it is responsible for.\n * It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.\n *\n * How it works:\n *\n * Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,\n * such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node\n * changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`\n * is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`\n * instance.\n *\n * Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.\n * When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.\n *\n */\nexport declare class ElementObserver {\n    private mutation;\n    private node;\n    private selector;\n    private eventListeners;\n    private classAdded;\n    private classRemoved;\n    private nodeDisplay;\n    private addFn;\n    private removeFn;\n    private changeFn;\n    private classChangeFn;\n    private addChildFn?;\n    private removeChildFn?;\n    private resetFn;\n    constructor(selector: NodeSelector);\n    private handleAttributes;\n    private handleChildList;\n    private addInitialListeners;\n    private clearEventListeners;\n    private renew;\n    getSelector(): NodeSelector;\n    getNode(): HTMLElement | null;\n    synchronize(): void;\n    init(): void;\n    watch(node: Node): void;\n    destroy(): void;\n    render(fn: () => ReactElement): import(\"react\").ReactPortal | undefined;\n    fire(event: MouseEventTypes): void;\n    show(): void;\n    hide(): void;\n    registerEvent(event: keyof HTMLElementEventMap, fn: EventListenerOrEventListenerObject): void;\n    registerOnReset(fn: () => void): void;\n    registerOnChange(fn: (el: HTMLElement | null) => void): void;\n    registerOnAdd(fn: (el: HTMLElement | null) => void): void;\n    registerOnRemove(fn: (el: HTMLElement | null) => void): void;\n    registerOnclassChange(fn: (classes?: DOMTokenList) => void): void;\n    registerOnAddChild(fn: (classes?: DOMTokenList) => void): void;\n    registerOnRemoveChild(fn: (classes?: DOMTokenList) => void): void;\n    registerOnClassAdded(className: string, fn: () => void): void;\n    registerOnClassRemoved(className: string, fn: () => void): void;\n}\n","import { ElementObserver } from './elementObserver';\nimport { NodeSelector } from './nodeSelector';\n/**\n * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are\n * added or removed from the DOM and notifies the observers for each observable element\n * when they are ready to be watched.\n *\n * How that works:\n *\n * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.\n * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`\n * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.\n *\n * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.\n *\n * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all\n * individual element observers and release any associated resources.\n *\n * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.\n *\n */\nexport declare class DOMObserver {\n    private static documentObserver;\n    private static listeners;\n    private static notifyAdition;\n    private static notifyRemoval;\n    private static notifyChildrenChanges;\n    private static mapNodeInstancesToListeners;\n    static add(selector: NodeSelector): ElementObserver;\n    static remove(selector: NodeSelector): void;\n    static observe(): void;\n    static destroy(): void;\n}\n","import { Message } from 'src/application/models';\nexport declare const getRecentProductImageUrls: (lastMessages: Message[], currentProductId: string | undefined) => string[];\n","export declare const prepareMerchantPage: () => void;\n","import { FormResponseAttributes, Message, UserEvent } from 'src/application/models';\nexport declare const messageFromFormSubmittedEvent: (event: UserEvent, formResponseAttributes: FormResponseAttributes[\"attributes\"]) => Message | undefined;\n","import { Message, UserEvent } from 'src/application/models';\n/**\n * Transforms a query UserEvent object into a Message object for presentation.\n *\n * @param event The user event object received from the server\n *\n * @returns A Message if the event is a query event, otherwise undefined\n */\nexport declare const messageFromQueryEvent: (event: UserEvent) => Message | undefined;\n","import { Message, Response } from 'src/application/models';\n/**\n * Transforms a server Response object into a Message object for presentation.\n *\n * @param response The response object received from the server containing model generated content\n *\n * @returns A Message if the response contains known attributes, undefined otherwise\n */\nexport declare const messageFromResponse: (response?: Response) => Message | undefined;\n","import { Message, Suggestion, UserEvent } from 'src/application/models';\n/**\n * Transforms a UserEvent object into a Message object for presentation.\n *\n * @param event The UserEvent object received from the server\n * @param suggestions A list of generated suggestions to match the event to\n *\n * @returns A Message if the event is a suggestion click event, undefined otherwise\n */\nexport declare const messageFromSuggestionEvent: (event: UserEvent, suggestions: Suggestion[]) => Message | undefined;\n","export declare class MutationHelper {\n    static fireClassChange(record: MutationRecord, node: HTMLElement | null, fn: (classes: DOMTokenList) => void): void;\n    static fireClassAdded(record: MutationRecord, node: HTMLElement | null, classMap: Map<string, () => void>): void;\n    static fireClassRemoved(record: MutationRecord, node: HTMLElement | null, classMap: Map<string, () => void>): void;\n    static fireSubtreeChange(nodes: NodeList, fn?: (nodes: NodeList) => void): void;\n    static isClass(mutation: MutationRecord): boolean;\n    static isChildList(mutation: MutationRecord): boolean;\n}\n","import { NextMessageRequest as ApiNextMessageRequest } from '@spiffy-ai/commerce-api-client';\nimport { NextMessageRequest } from '../models';\nexport declare const messageRequestToCommerceMessageRequest: (data: NextMessageRequest) => ApiNextMessageRequest;\n","export type ReplaceOp<T> = {\n    $replace: T;\n};\nexport type DeleteOp = {\n    $delete: true;\n};\ntype Builtin = Date | RegExp | ((...args: unknown[]) => unknown);\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined;\n/**\n * Override<T> is a DeepPartial-like type with special operators:\n * - { $replace: T } to replace an entire subtree/array\n * - { $delete: true } to delete an object key\n *\n * Arrays behavior:\n * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)\n * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided\n */\nexport type Override<T> = T extends Primitive | Builtin ? T | ReplaceOp<T> | DeleteOp : T extends (infer U)[] ? Array<Override<U> | undefined> | ReplaceOp<T> : T extends Map<unknown, unknown> | Set<unknown> ? ReplaceOp<T> : T extends object ? {\n    [K in keyof T]?: Override<T[K]> | DeleteOp | null;\n} | ReplaceOp<T> : T;\nexport type MergeOptions = {\n    /**\n     * How to treat arrays when patch provides an array (not $replace):\n     * - 'replace': always use patch array as whole value\n     * - 'mergeByIndex': merge each index recursively (default for arrays of objects)\n     * Note: Arrays of primitives are replaced by default regardless of this option.\n     */\n    arrayStrategy?: 'replace' | 'mergeByIndex';\n    /**\n     * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)\n     */\n    nullDeletes?: boolean;\n};\ntype NoInfer<T> = [T][T extends unknown ? 0 : never];\nexport declare function applyOverrides<T>(base: T, patch: Override<NoInfer<T>>, opts?: MergeOptions): T;\nexport {};\n","declare class StringUtils {\n    static isNullOrEmpty(value: string | undefined): boolean;\n    static trimToNull(value: string | undefined): string | undefined;\n    static capitalize(type: string | undefined): string;\n    /**\n     * Finds the first pattern in an array that matches a given URL.\n     * Patterns can include a single wildcard '*' which matches any sequence of characters.\n     *\n     * @param patterns\n     * @param urlToTest\n     * @returns\n     */\n    static findMatchingPattern(patterns: string[], urlToTest: Location): string | undefined;\n}\nexport { StringUtils };\n","import { SupportedEventRequest as ApiSupportedEventRequest } from '@spiffy-ai/commerce-api-client';\nimport { SupportedEventRequest as CoreSupportedEventRequest } from '../models/api/supportedEventRequest';\nexport declare const coreSupportedEventRequestToApiRequest: (coreSupportedEventRequest: CoreSupportedEventRequest) => ApiSupportedEventRequest;\n","import { MessageRole, ProductSearchMessageMetadata } from '../models/message';\nexport declare const parseHref: (href: string) => {\n    url: URL | undefined;\n    urlSearchParams: URLSearchParams | undefined;\n};\nexport declare const createUrlWithQueryParams: (url: string, queryParams: Record<string, string>) => string;\nexport declare const getQueryParam: (key: string) => string | null;\ntype SearchMessage = {\n    id: string;\n    role: MessageRole;\n    createdAt: string;\n} & ProductSearchMessageMetadata;\nexport declare const buildSearchHash: (message: SearchMessage) => string;\nexport declare const buildSearchStartHash: (query: string) => string;\nexport declare const parseSearchHash: (hash: string) => {\n    id: string | null;\n    query: string | null;\n};\nexport {};\n","export declare const validateEmail: (value: string) => boolean;\n"],"mappings":";;;;;;;;;;;;;;;;;;AACA,IAAI,KAAK,CAAC,KAAK,WAAA,GAAA,CAAA;AACf,IAAW,uBAAU;CAAA;OAAA;OAAA;CAAA;AACrB,IAAW,gBAAa;CAAA;OAAA;OAAA;CAAA;;;;ACDxB,IAAW,0BAA0B;CAAC;OAAW;OAAmB;CAAW;;;;ACA/E,IAAW,8BAA8B;CAAC;OAAW;OAAqB;CAAa;;;;ACFvF,IAAW,cAAc;CAAC;OAAW;OAAS;CAAE;;;;ACIhD,IAAW,kBAAkB;CAAC;OAAW;OAAoB;OAAoB;OAAmB;OAAK;OAAA,OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;ACFzG,IAAE,cAAA;CAAA;OAAA;OAAA;OAAA;CAAA;;;;ACDF,IAAW,4BAA4B,CAAC,WAAW,QAAQ;;;;ACD3D,IAAW,sBAAsB,CAAC,IAAI;;;;ACCtC,IAAW,gCAAgC;CAAC;OAAW;OAAiB;OAA8B;CAAQ;;;;ACA9G,IAAE,wBAAA;CAAA;OAAA;OAAA;CAAA;;;;ACAF,IAAE,sBAAA;CAAA;OAAA;OAAA;CAAA;;;;ACAF,IAAE,6BAAA;CAAA;OAAA;OAAA;OAAA;CAAA;;;;ACDF,IAAW,iBAAiB;CAAC;OAAO;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;ACEpC,IAAW,yCAAyC;CAAC;OAAW;OAA0B;CAAsB;;;;ACFhH,IAAW,YAAY,CAAC,WAAG,EAAA;AAC3B,IAAW,WAAI,CAAA,IAAA;AACf,IAAC,UAAA;CAAA;OAAA;OAAA;CAAA;AACD,IAAI,YAAY,CAAC,IAAI;AACrB,IAAW,WAAM;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACjB,IAAC,eAAA,CAAA,IAAA;AACD,IAAI,UAAU;CAAC;OAAW;OAAS;CAAE;AACrC,IAAW,iBAAiB;CAAC;OAAW;OAAS;OAAS;OAAe;OAAM;OAAA;CAAA;;;;ACP/E,IAAI,cAAc,CAAC,WAAO,SAAA;;;;ACE1B,IAAW,wCAAwC;CAAC;OAAW;OAAiC;CAAyB;;;;ACDzH,IAAW,YAAY;CAAC;OAAW;OAAW;CAAI;AAClD,IAAW,2BAAa,CAAA,WAAA,OAAA;AACxB,IAAW,gBAAgB,CAAC,IAAI;AAChC,IAAC,gBAAA;CAAA;OAAA;OAAA;CAAA;AACD,IAAW,kBAAkB,CAAC,WAAW,cAAc;AACvD,IAAW,uBAAuB,CAAC,IAAI;AACvC,IAAW,kBAAU,CAAA,IAAA;;;;ACPrB,IAAW,gBAAgB,CAAC,IAAI"}

package/dist/application/utils/index.js

@@ -0,0 +1,22 @@
+import "../../types-D3uOF0Oy.js";
+import "../../events-BHJJjPDN.js";
+import "../../models-CgvSM2fW.js";
+import "../../featureGates-Blx10fwB.js";
+import { buildSearchHash, buildSearchStartHash, createUrlWithQueryParams, getQueryParam, parseHref, parseSearchHash } from "../../urlsParser-DUgV_Qy9.js";
+import "../../graphql-W7GMIHUu.js";
+import "../../utils-ARmpTh1O.js";
+import "../../api-D9gmGNAV.js";
+import "../../logger-oAgZx2-m.js";
+import "../../utilityTypes-DynzxjK3.js";
+import "../../variantInfo-BtOYUGWa.js";
+import "../../localStorageContext-Dwgto93_.js";
+import "../../enviveConfig-BSfyz_pm.js";
+import "../../orgAnalyticsConfig-BC4_sEmn.js";
+import "../../atomStore-BuopbV9k.js";
+import "../../app-CoQ1nC-j.js";
+import "../../enviveConfigContext-CJqpRSKu.js";
+import "../../amplitudeContext-CwPtBPhg.js";
+import { NodeSelector, SelectorFactory, StringUtils, applyOverrides, coreContextToApiContext, coreSupportedEventRequestToApiRequest, coreUserEventToApiUserEvent, divideArray, getRecentProductImageUrls, initAmplitude, initDataLayerWrapper, messageFromFormSubmittedEvent, messageFromQueryEvent, messageFromResponse, messageFromSuggestionEvent, messageRequestToCommerceMessageRequest, prepareMerchantPage, validateEmail } from "../../utils-BgMcvG6l.js";
+import { DOMObserver, ElementObserver, MutationHelper } from "../../domObserver-B19-69gW.js";
+
+export { DOMObserver, ElementObserver, MutationHelper, NodeSelector, SelectorFactory, StringUtils, applyOverrides, buildSearchHash, buildSearchStartHash, coreContextToApiContext, coreSupportedEventRequestToApiRequest, coreUserEventToApiUserEvent, createUrlWithQueryParams, divideArray, getQueryParam, getRecentProductImageUrls, initAmplitude, initDataLayerWrapper, messageFromFormSubmittedEvent, messageFromQueryEvent, messageFromResponse, messageFromSuggestionEvent, messageRequestToCommerceMessageRequest, parseHref, parseSearchHash, prepareMerchantPage, validateEmail };

package/dist/atomStore-BuopbV9k.js

@@ -0,0 +1,32 @@
+import { getDefaultStore } from "jotai";
+import { createJSONStorage } from "jotai/utils";
+
+//#region src/atoms/atomStore/atomStore.ts
+let atomStore = null;
+const getAtomStore = () => {
+	if (!atomStore) atomStore = getDefaultStore();
+	return atomStore;
+};
+/**
+* @internal
+*
+* Sets the global atom store to be the provided store.
+*
+* @param store - The store to set the global atom store to.
+*/
+const setAtomStoreForTesting = (store) => {
+	atomStore = store;
+};
+/**
+* @internal
+*
+* Resets the global atom store to null
+*/
+const resetAtomStore = () => {
+	atomStore = null;
+};
+const sessionStorageUtil = createJSONStorage(() => sessionStorage);
+
+//#endregion
+export { getAtomStore, resetAtomStore, sessionStorageUtil, setAtomStoreForTesting };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRvbVN0b3JlLUJ1b3BiVjlrLmpzIiwibmFtZXMiOlsiYXRvbVN0b3JlOiBBdG9tU3RvcmUgfCBudWxsIl0sInNvdXJjZXMiOlsiLi4vc3JjL2F0b21zL2F0b21TdG9yZS9hdG9tU3RvcmUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0RGVmYXVsdFN0b3JlIH0gZnJvbSAnam90YWknO1xuaW1wb3J0IHsgY3JlYXRlSlNPTlN0b3JhZ2UgfSBmcm9tICdqb3RhaS91dGlscyc7XG5cbmV4cG9ydCB0eXBlIEF0b21TdG9yZSA9IFJldHVyblR5cGU8dHlwZW9mIGdldERlZmF1bHRTdG9yZT47XG5sZXQgYXRvbVN0b3JlOiBBdG9tU3RvcmUgfCBudWxsID0gbnVsbDtcblxuZXhwb3J0IGNvbnN0IGdldEF0b21TdG9yZSA9ICgpOiBBdG9tU3RvcmUgPT4ge1xuICBpZiAoIWF0b21TdG9yZSkge1xuICAgIGF0b21TdG9yZSA9IGdldERlZmF1bHRTdG9yZSgpO1xuICB9XG4gIHJldHVybiBhdG9tU3RvcmU7XG59O1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICpcbiAqIFNldHMgdGhlIGdsb2JhbCBhdG9tIHN0b3JlIHRvIGJlIHRoZSBwcm92aWRlZCBzdG9yZS5cbiAqXG4gKiBAcGFyYW0gc3RvcmUgLSBUaGUgc3RvcmUgdG8gc2V0IHRoZSBnbG9iYWwgYXRvbSBzdG9yZSB0by5cbiAqL1xuZXhwb3J0IGNvbnN0IHNldEF0b21TdG9yZUZvclRlc3RpbmcgPSAoc3RvcmU6IEF0b21TdG9yZSkgPT4ge1xuICBhdG9tU3RvcmUgPSBzdG9yZTtcbn07XG5cbi8qKlxuICogQGludGVybmFsXG4gKlxuICogUmVzZXRzIHRoZSBnbG9iYWwgYXRvbSBzdG9yZSB0byBudWxsXG4gKi9cbmV4cG9ydCBjb25zdCByZXNldEF0b21TdG9yZSA9ICgpID0+IHtcbiAgYXRvbVN0b3JlID0gbnVsbDtcbn07XG5cbmV4cG9ydCBjb25zdCBzZXNzaW9uU3RvcmFnZVV0aWwgPSBjcmVhdGVKU09OU3RvcmFnZTxzdHJpbmcgfCB1bmRlZmluZWQ+KCgpID0+IHNlc3Npb25TdG9yYWdlKTtcbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUlBLElBQUlBLFlBQThCO0FBRWxDLE1BQWEscUJBQWdDO0FBQzNDLEtBQUksQ0FBQyxVQUNILGFBQVksaUJBQWlCO0FBRS9CLFFBQU87Ozs7Ozs7OztBQVVULE1BQWEsMEJBQTBCLFVBQXFCO0FBQzFELGFBQVk7Ozs7Ozs7QUFRZCxNQUFhLHVCQUF1QjtBQUNsQyxhQUFZOztBQUdkLE1BQWEscUJBQXFCLHdCQUE0QyxlQUFlIn0=

package/dist/atomStore-CZKe3itM.cjs

@@ -0,0 +1,58 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+let jotai_utils = require("jotai/utils");
+jotai_utils = require_chunk.__toESM(jotai_utils);
+
+//#region src/atoms/atomStore/atomStore.ts
+let atomStore = null;
+const getAtomStore = () => {
+	if (!atomStore) atomStore = (0, jotai.getDefaultStore)();
+	return atomStore;
+};
+/**
+* @internal
+*
+* Sets the global atom store to be the provided store.
+*
+* @param store - The store to set the global atom store to.
+*/
+const setAtomStoreForTesting = (store) => {
+	atomStore = store;
+};
+/**
+* @internal
+*
+* Resets the global atom store to null
+*/
+const resetAtomStore = () => {
+	atomStore = null;
+};
+const sessionStorageUtil = (0, jotai_utils.createJSONStorage)(() => sessionStorage);
+
+//#endregion
+Object.defineProperty(exports, 'getAtomStore', {
+  enumerable: true,
+  get: function () {
+    return getAtomStore;
+  }
+});
+Object.defineProperty(exports, 'resetAtomStore', {
+  enumerable: true,
+  get: function () {
+    return resetAtomStore;
+  }
+});
+Object.defineProperty(exports, 'sessionStorageUtil', {
+  enumerable: true,
+  get: function () {
+    return sessionStorageUtil;
+  }
+});
+Object.defineProperty(exports, 'setAtomStoreForTesting', {
+  enumerable: true,
+  get: function () {
+    return setAtomStoreForTesting;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRvbVN0b3JlLUNaS2UzaXRNLmNqcyIsIm5hbWVzIjpbImF0b21TdG9yZTogQXRvbVN0b3JlIHwgbnVsbCJdLCJzb3VyY2VzIjpbIi4uL3NyYy9hdG9tcy9hdG9tU3RvcmUvYXRvbVN0b3JlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldERlZmF1bHRTdG9yZSB9IGZyb20gJ2pvdGFpJztcbmltcG9ydCB7IGNyZWF0ZUpTT05TdG9yYWdlIH0gZnJvbSAnam90YWkvdXRpbHMnO1xuXG5leHBvcnQgdHlwZSBBdG9tU3RvcmUgPSBSZXR1cm5UeXBlPHR5cGVvZiBnZXREZWZhdWx0U3RvcmU+O1xubGV0IGF0b21TdG9yZTogQXRvbVN0b3JlIHwgbnVsbCA9IG51bGw7XG5cbmV4cG9ydCBjb25zdCBnZXRBdG9tU3RvcmUgPSAoKTogQXRvbVN0b3JlID0+IHtcbiAgaWYgKCFhdG9tU3RvcmUpIHtcbiAgICBhdG9tU3RvcmUgPSBnZXREZWZhdWx0U3RvcmUoKTtcbiAgfVxuICByZXR1cm4gYXRvbVN0b3JlO1xufTtcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqXG4gKiBTZXRzIHRoZSBnbG9iYWwgYXRvbSBzdG9yZSB0byBiZSB0aGUgcHJvdmlkZWQgc3RvcmUuXG4gKlxuICogQHBhcmFtIHN0b3JlIC0gVGhlIHN0b3JlIHRvIHNldCB0aGUgZ2xvYmFsIGF0b20gc3RvcmUgdG8uXG4gKi9cbmV4cG9ydCBjb25zdCBzZXRBdG9tU3RvcmVGb3JUZXN0aW5nID0gKHN0b3JlOiBBdG9tU3RvcmUpID0+IHtcbiAgYXRvbVN0b3JlID0gc3RvcmU7XG59O1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICpcbiAqIFJlc2V0cyB0aGUgZ2xvYmFsIGF0b20gc3RvcmUgdG8gbnVsbFxuICovXG5leHBvcnQgY29uc3QgcmVzZXRBdG9tU3RvcmUgPSAoKSA9PiB7XG4gIGF0b21TdG9yZSA9IG51bGw7XG59O1xuXG5leHBvcnQgY29uc3Qgc2Vzc2lvblN0b3JhZ2VVdGlsID0gY3JlYXRlSlNPTlN0b3JhZ2U8c3RyaW5nIHwgdW5kZWZpbmVkPigoKSA9PiBzZXNzaW9uU3RvcmFnZSk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFJQSxJQUFJQSxZQUE4QjtBQUVsQyxNQUFhLHFCQUFnQztBQUMzQyxLQUFJLENBQUMsVUFDSCx5Q0FBNkI7QUFFL0IsUUFBTzs7Ozs7Ozs7O0FBVVQsTUFBYSwwQkFBMEIsVUFBcUI7QUFDMUQsYUFBWTs7Ozs7OztBQVFkLE1BQWEsdUJBQXVCO0FBQ2xDLGFBQVk7O0FBR2QsTUFBYSw4REFBaUUsZUFBZSJ9

package/dist/atomStore-DKlaDbMx.js

@@ -0,0 +1 @@
+export {  };

package/dist/atoms/app/index.cjs

@@ -0,0 +1,20 @@
+require('../../types-BwNrLPSZ.cjs');
+require('../../models-B1P-dSCW.cjs');
+require('../../featureGates-DcZNrUma.cjs');
+require('../../urlsParser-BV5yF8sa.cjs');
+require('../../graphql-B9HhDXYt.cjs');
+require('../../utils-Cavu4XiM.cjs');
+require('../../api-Bc3_julZ.cjs');
+require('../../logger-Cp7J4YJT.cjs');
+require('../../utilityTypes-xb8SjKSV.cjs');
+require('../../variantInfo-B7IwRpCg.cjs');
+require('../../localStorageContext-cnMYDllE.cjs');
+require('../../enviveConfig-D8vcVPWD.cjs');
+require('../../atomStore-CZKe3itM.cjs');
+const require_app = require('../../app-DN72spgQ.cjs');
+
+exports.appSourceAtom = require_app.appSourceAtom;
+exports.chatIdAtom = require_app.chatIdAtom;
+exports.userIdAtom = require_app.userIdAtom;
+exports.userIdentityAtom = require_app.userIdentityAtom;
+exports.variantInfoAtom = require_app.variantInfoAtom;

package/dist/atoms/app/index.d.cts

@@ -0,0 +1,39 @@
+import "../../index-Bmub8e38.cjs";
+import "../../index-CiWEYzXl.cjs";
+import "../../index-CESxqFso.cjs";
+import "../../utils-B3x_9JTY.cjs";
+import "../../index-C_MIfxF0.cjs";
+import "../../chatElementDisplayLocation-DWmfNX_u.cjs";
+import "../../frontendConfig-DnMZfvcA.cjs";
+import "../../test-types-ThQiO_cc.cjs";
+import "../../spiffyWidgets-BuS00VaQ.cjs";
+import "../../search-y-ioX5Mz.cjs";
+import { VariantInfo } from "../../index-hdbCEjYy.cjs";
+import { UserIdentityContextType } from "../../userIdentityContext-D2oFVFzo.cjs";
+import { ContextEnvEnum, ContextSourceEnum, PageVisitCategory } from "@spiffy-ai/commerce-api-client";
+import * as jotai25 from "jotai";
+import * as jotai_utils0 from "jotai/utils";
+
+//#region src/atoms/app/variant.d.ts
+
+declare const variantInfoAtom: jotai25.WritableAtom<VariantInfo, [newVariant: VariantInfo], void>;
+//#endregion
+//#region src/atoms/app/index.d.ts
+interface AppDetails {
+  orgId: string;
+  orgShortName: string;
+  chatId: string;
+  userId: string;
+  source: ContextSourceEnum;
+  env: ContextEnvEnum;
+  variantInfo: VariantInfo;
+}
+declare const userIdAtom: jotai25.WritableAtom<string, [value: string | undefined], void>;
+declare const userIdentityAtom: jotai25.PrimitiveAtom<UserIdentityContextType | undefined> & {
+  init: UserIdentityContextType | undefined;
+};
+declare const appSourceAtom: jotai25.Atom<ContextSourceEnum>;
+declare const chatIdAtom: jotai25.WritableAtom<string, [string | typeof jotai_utils0.RESET | ((prev: string) => string | typeof jotai_utils0.RESET)], void>;
+//#endregion
+export { AppDetails, appSourceAtom, chatIdAtom, userIdAtom, userIdentityAtom, variantInfoAtom };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F0b21zL2FwcC92YXJpYW50LmQudHMiLCIuLi8uLi8uLi9zcmMvYXRvbXMvYXBwL2luZGV4LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3VwcG9ydGVkRXZlbnRSZXNwb25zZSwgUGFnZVZpc2l0Q2F0ZWdvcnkgfSBmcm9tIFwiQHNwaWZmeS1haS9jb21tZXJjZS1hcGktY2xpZW50XCI7XG5pbXBvcnQgeyBWYXJpYW50SW5mbyB9IGZyb20gXCJzcmMvYXBwbGljYXRpb24vbW9kZWxzXCI7XG5leHBvcnQgaW50ZXJmYWNlIFN1cHBvcnRlZEV2ZW50IGV4dGVuZHMgUGljazxTdXBwb3J0ZWRFdmVudFJlc3BvbnNlLCBcInN1cHBvcnRlZFwiIHwgXCJyZWFkeVwiIHwgXCJjYXRlZ29yeVwiIHwgXCJjb2xsZWN0aW9uc1wiIHwgXCJ0b3BfY2F0ZWdvcnlcIj4ge1xuICAgIG51bWJlck9mUmV2aWV3czogbnVtYmVyIHwgdW5kZWZpbmVkO1xuICAgIG1lcmNoYW50X3RhZ3M/OiBzdHJpbmdbXTtcbn1cbmludGVyZmFjZSBQRFBBdHRyaWJ1dGVzIHtcbiAgICBwcm9kdWN0X2lkPzogc3RyaW5nO1xufVxuaW50ZXJmYWNlIFBMUEF0dHJpYnV0ZXMge1xuICAgIGF0dHJpYnV0ZXM/OiB7XG4gICAgICAgIGlkPzogc3RyaW5nO1xuICAgIH07XG59XG5leHBvcnQgaW50ZXJmYWNlIFVybFJlc29sdmluZ1BEUENvbmZpZyB7XG4gICAgcGRwX2F0dHJpYnV0ZXM6IFBEUEF0dHJpYnV0ZXM7XG4gICAgbnVtYmVyX29mX3Jldmlld3M/OiBudW1iZXI7XG4gICAgY29sbGVjdGlvbnM/OiBzdHJpbmdbXTtcbiAgICBtZXJjaGFudF90YWdzPzogc3RyaW5nW107XG59XG5leHBvcnQgaW50ZXJmYWNlIFVybFJlc29sdmluZ1BMUENvbmZpZyB7XG4gICAgcGxwX2F0dHJpYnV0ZXM6IFBMUEF0dHJpYnV0ZXM7XG4gICAgdG9wX2NhdGVnb3J5Pzogc3RyaW5nO1xufVxuaW50ZXJmYWNlIFVybFJlc29sdmluZ0dlbmVyaWNDb25maWcge1xuICAgIGRldGFpbHM/OiBzdHJpbmc7XG59XG5leHBvcnQgdHlwZSBQYWdlVmFyaWFudENoZWNrQ29uZmlnID0ge1xuICAgIGNoZWNrX3R5cGU6IHN0cmluZztcbiAgICBmZWF0dXJlX2dhdGU/OiBzdHJpbmc7XG4gICAgZXh0cmFjdG9yPzoge1xuICAgICAgICB0eXBlOiBzdHJpbmc7XG4gICAgICAgIG1hcD86IFJlY29yZDxzdHJpbmcsIHN0cmluZ1tdPjtcbiAgICAgICAgdmFsdWU/OiBzdHJpbmc7XG4gICAgfTtcbiAgICBwcm9kdWN0X2lkX2V4dHJhY3Rvcj86IHN0cmluZztcbiAgICBwcm9kdWN0X2lkcz86IHN0cmluZ1tdO1xuICAgIHBscF9pZF9leHRyYWN0b3I/OiBzdHJpbmc7XG4gICAgcGxwX2lkcz86IHN0cmluZ1tdO1xuICAgIGNvbGxlY3Rpb25zPzogc3RyaW5nW107XG4gICAgcXVlcnlfcGFyYW0/OiBzdHJpbmc7XG4gICAgY2F0ZWdvcnk/OiBzdHJpbmc7XG4gICAgdG9wX2NhdGVnb3J5Pzogc3RyaW5nW107XG4gICAgcmV2aWV3X21pbmltdW0/OiBudW1iZXI7XG4gICAgbWVyY2hhbnRfdGFncz86IHN0cmluZ1tdO1xufTtcbmV4cG9ydCB0eXBlIEJhY2tlbmRXaWRnZXRNb3VudGluZ0NvbmZpZyA9IHtcbiAgICBtb3VudGluZ19jb25maWdfaWQ6IHN0cmluZztcbiAgICB3aWRnZXRfY29uZmlnX2lkPzogc3RyaW5nO1xuICAgIG1vdW50aW5nX3BvaW50X3dpZGdldHM/OiBBcnJheTx7XG4gICAgICAgIGNoZWNrczogUGFnZVZhcmlhbnRDaGVja0NvbmZpZ1tdO1xuICAgICAgICB3aWRnZXRfY29uZmlnX2lkOiBzdHJpbmc7XG4gICAgfT47XG59O1xuZXhwb3J0IHR5cGUgQmFja2VuZFBhZ2VWYXJpYW50Q29uZmlnID0ge1xuICAgIHZhcmlhbnRfaWQ6IHN0cmluZztcbiAgICB2YXJpYW50X3R5cGU6IHN0cmluZztcbiAgICB2YXJpYW50X2NoZWNrczogUGFnZVZhcmlhbnRDaGVja0NvbmZpZ1tdO1xuICAgIHdpZGdldF9tb3VudGluZzogQmFja2VuZFdpZGdldE1vdW50aW5nQ29uZmlnW107XG4gICAgcGxwX2lkX2V4dHJhY3Rvcj86IHN0cmluZztcbiAgICBwcm9kdWN0X2lkX2V4dHJhY3Rvcj86IHN0cmluZztcbiAgICBwYXJlbnRfcHJvZHVjdF9pZF9leHRyYWN0b3I/OiBzdHJpbmc7XG59O1xuZXhwb3J0IGludGVyZmFjZSBVcmxSZXNvbHZlclJlc3BvbnNlIHtcbiAgICB2YXJpYW50X3R5cGU6IHN0cmluZztcbiAgICBzcGVjaWZpY19kZXRhaWxzOiBVcmxSZXNvbHZpbmdQRFBDb25maWcgfCBVcmxSZXNvbHZpbmdQTFBDb25maWcgfCBVcmxSZXNvbHZpbmdHZW5lcmljQ29uZmlnO1xuICAgIHJlYWR5OiBib29sZWFuO1xuICAgIHVzZXJfZXZlbnQ/OiB7XG4gICAgICAgIGV2ZW50X2lkPzogc3RyaW5nO1xuICAgICAgICBhdHRyaWJ1dGVzPzogUERQQXR0cmlidXRlcyB8IFBMUEF0dHJpYnV0ZXM7XG4gICAgICAgIGNhdGVnb3J5Pzogc3RyaW5nO1xuICAgICAgICBjcmVhdGVkX2F0Pzogc3RyaW5nO1xuICAgIH07XG4gICAgcGFnZV92YXJpYW50PzogQmFja2VuZFBhZ2VWYXJpYW50Q29uZmlnO1xufVxuZXhwb3J0IHR5cGUgVXJsUmVzb2x2ZXJDYWNoZSA9IFJlY29yZDxzdHJpbmcsIFVybFJlc29sdmVyUmVzcG9uc2UgfCB1bmRlZmluZWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXJsUmVzb2x2ZXJBdG9tOiBpbXBvcnQoXCJqb3RhaVwiKS5Xcml0YWJsZUF0b208VXJsUmVzb2x2ZXJDYWNoZSwgW3ZhbHVlOiB7XG4gICAgdXJsOiBzdHJpbmc7XG4gICAgcmVzcG9uc2U6IFVybFJlc29sdmVyUmVzcG9uc2UgfCB1bmRlZmluZWQ7XG59XSwgdm9pZD47XG5leHBvcnQgZGVjbGFyZSBjb25zdCBzdXBwb3J0ZWRFdmVudEF0b206IGltcG9ydChcImpvdGFpXCIpLldyaXRhYmxlQXRvbTxTdXBwb3J0ZWRFdmVudCB8IHVuZGVmaW5lZCwgW3ZhbHVlOiBTdXBwb3J0ZWRFdmVudCB8IHVuZGVmaW5lZF0sIHZvaWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdmFyaWFudElkQXRvbTogaW1wb3J0KFwiam90YWlcIikuQXRvbTxzdHJpbmcgfCB1bmRlZmluZWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgcHJvZHVjdElkQXRvbTogaW1wb3J0KFwiam90YWlcIikuQXRvbTxzdHJpbmcgfCB1bmRlZmluZWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgcGFyZW50UHJvZHVjdElkQXRvbTogaW1wb3J0KFwiam90YWlcIikuQXRvbTxzdHJpbmcgfCB1bmRlZmluZWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgcHJvZHVjdFVybEF0b206IGltcG9ydChcImpvdGFpXCIpLkF0b208c3RyaW5nIHwgdW5kZWZpbmVkPjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHBscElkQXRvbTogaW1wb3J0KFwiam90YWlcIikuQXRvbTxzdHJpbmcgfCB1bmRlZmluZWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXJsQXRvbTogaW1wb3J0KFwiam90YWlcIikuQXRvbTxzdHJpbmcgfCB1bmRlZmluZWQ+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgcGFnZVZpc2l0Q2F0ZWdvcnlBdG9tOiBpbXBvcnQoXCJqb3RhaVwiKS5BdG9tPFBhZ2VWaXNpdENhdGVnb3J5IHwgdW5kZWZpbmVkPjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHZhcmlhbnRBdG9tOiBpbXBvcnQoXCJqb3RhaVwiKS5BdG9tPFwic2VhcmNoXCIgfCBcInBkcFwiIHwgXCJwbHBcIiB8IFwicGFnZV92aXNpdFwiPjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGhhc1BhcnNlZFZhcmlhbnRJbmZvQXRvbTogaW1wb3J0KFwiam90YWlcIikuUHJpbWl0aXZlQXRvbTxib29sZWFuPiAmIHtcbiAgICBpbml0OiBib29sZWFuO1xufTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHZhcmlhbnRJbmZvQXRvbTogaW1wb3J0KFwiam90YWlcIikuV3JpdGFibGVBdG9tPFZhcmlhbnRJbmZvLCBbbmV3VmFyaWFudDogVmFyaWFudEluZm9dLCB2b2lkPjtcbmV4cG9ydCB7fTtcbiIsImltcG9ydCB7IENvbnRleHRFbnZFbnVtLCBDb250ZXh0U291cmNlRW51bSB9IGZyb20gXCJAc3BpZmZ5LWFpL2NvbW1lcmNlLWFwaS1jbGllbnRcIjtcbmltcG9ydCB7IFZhcmlhbnRJbmZvIH0gZnJvbSBcInNyYy9hcHBsaWNhdGlvbi9tb2RlbHNcIjtcbmltcG9ydCB7IFVzZXJJZGVudGl0eUNvbnRleHRUeXBlIH0gZnJvbSBcInNyYy9jb250ZXh0cy91c2VySWRlbnRpdHlDb250ZXh0L3VzZXJJZGVudGl0eUNvbnRleHRcIjtcbmV4cG9ydCBpbnRlcmZhY2UgQXBwRGV0YWlscyB7XG4gICAgb3JnSWQ6IHN0cmluZztcbiAgICBvcmdTaG9ydE5hbWU6IHN0cmluZztcbiAgICBjaGF0SWQ6IHN0cmluZztcbiAgICB1c2VySWQ6IHN0cmluZztcbiAgICBzb3VyY2U6IENvbnRleHRTb3VyY2VFbnVtO1xuICAgIGVudjogQ29udGV4dEVudkVudW07XG4gICAgdmFyaWFudEluZm86IFZhcmlhbnRJbmZvO1xufVxuZXhwb3J0IHsgdmFyaWFudEluZm9BdG9tIH0gZnJvbSBcIi4vdmFyaWFudFwiO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlcklkQXRvbTogaW1wb3J0KFwiam90YWlcIikuV3JpdGFibGVBdG9tPHN0cmluZywgW3ZhbHVlOiBzdHJpbmcgfCB1bmRlZmluZWRdLCB2b2lkPjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHVzZXJJZGVudGl0eUF0b206IGltcG9ydChcImpvdGFpXCIpLlByaW1pdGl2ZUF0b208VXNlcklkZW50aXR5Q29udGV4dFR5cGUgfCB1bmRlZmluZWQ+ICYge1xuICAgIGluaXQ6IFVzZXJJZGVudGl0eUNvbnRleHRUeXBlIHwgdW5kZWZpbmVkO1xufTtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGFwcFNvdXJjZUF0b206IGltcG9ydChcImpvdGFpXCIpLkF0b208Q29udGV4dFNvdXJjZUVudW0+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY2hhdElkQXRvbTogaW1wb3J0KFwiam90YWlcIikuV3JpdGFibGVBdG9tPHN0cmluZywgW3N0cmluZyB8IHR5cGVvZiBpbXBvcnQoXCJqb3RhaS91dGlsc1wiKS5SRVNFVCB8ICgocHJldjogc3RyaW5nKSA9PiBzdHJpbmcgfCB0eXBlb2YgaW1wb3J0KFwiam90YWkvdXRpbHNcIikuUkVTRVQpXSwgdm9pZD47XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBeUJBLElBQVcsa0JBQVM7Q0FBQTtPQUFBO09BQUE7T0FBQSxRQUFBO0NBQUE7Ozs7QUNwQnBCLElBQVcsYUFBYTtDQUFBO09BQUE7T0FBQTtPQUFBO0NBQUE7QUFFeEIsSUFBVyxhQUFPLENBQUEsU0FBQSxRQUFBLGFBQUE7QUFDbEIsSUFBVyxtQkFBa0I7Q0FBQTtPQUFBO09BQUEsUUFBQTtPQUFBO0NBQUE7QUFDN0IsSUFBVyxnQkFBWTtDQUFBO09BQUE7T0FBQSxRQUFBO0NBQUE7QUFDdkIsSUFBVyxhQUFhO0NBQUM7T0FBRyxhQUFBO09BQUEsYUFBQTtPQUFBLFFBQUE7Q0FBQSJ9

package/dist/atoms/app/index.d.ts

@@ -0,0 +1,39 @@
+import "../../index-Dr_c2DDq.js";
+import "../../index-BN-3ctk_.js";
+import "../../index-DsiilEj-.js";
+import "../../utils-B1xLx9S8.js";
+import "../../index-CK_J3QMY.js";
+import "../../chatElementDisplayLocation-BwiXrkN7.js";
+import "../../frontendConfig-Dqxbqo8G.js";
+import "../../test-types-EzMFw_U3.js";
+import "../../spiffyWidgets-GILaqHv6.js";
+import "../../search-BLShhjvR.js";
+import { VariantInfo } from "../../index-BoYC9XLW.js";
+import { UserIdentityContextType } from "../../userIdentityContext-wYRpgkaJ.js";
+import { ContextEnvEnum, ContextSourceEnum, PageVisitCategory } from "@spiffy-ai/commerce-api-client";
+import * as jotai74 from "jotai";
+import * as jotai_utils0 from "jotai/utils";
+
+//#region src/atoms/app/variant.d.ts
+
+declare const variantInfoAtom: jotai74.WritableAtom<VariantInfo, [newVariant: VariantInfo], void>;
+//#endregion
+//#region src/atoms/app/index.d.ts
+interface AppDetails {
+  orgId: string;
+  orgShortName: string;
+  chatId: string;
+  userId: string;
+  source: ContextSourceEnum;
+  env: ContextEnvEnum;
+  variantInfo: VariantInfo;
+}
+declare const userIdAtom: jotai74.WritableAtom<string, [value: string | undefined], void>;
+declare const userIdentityAtom: jotai74.PrimitiveAtom<UserIdentityContextType | undefined> & {
+  init: UserIdentityContextType | undefined;
+};
+declare const appSourceAtom: jotai74.Atom<ContextSourceEnum>;
+declare const chatIdAtom: jotai74.WritableAtom<string, [string | typeof jotai_utils0.RESET | ((prev: string) => string | typeof jotai_utils0.RESET)], void>;
+//#endregion
+export { AppDetails, appSourceAtom, chatIdAtom, userIdAtom, userIdentityAtom, variantInfoAtom };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/atoms/app/index.js

@@ -0,0 +1,16 @@
+import "../../types-D3uOF0Oy.js";
+import "../../models-CgvSM2fW.js";
+import "../../featureGates-Blx10fwB.js";
+import "../../urlsParser-DUgV_Qy9.js";
+import "../../graphql-W7GMIHUu.js";
+import "../../utils-ARmpTh1O.js";
+import "../../api-D9gmGNAV.js";
+import "../../logger-oAgZx2-m.js";
+import "../../utilityTypes-DynzxjK3.js";
+import "../../variantInfo-BtOYUGWa.js";
+import "../../localStorageContext-Dwgto93_.js";
+import "../../enviveConfig-BSfyz_pm.js";
+import "../../atomStore-BuopbV9k.js";
+import { appSourceAtom, chatIdAtom, userIdAtom, userIdentityAtom, variantInfoAtom } from "../../app-CoQ1nC-j.js";
+
+export { appSourceAtom, chatIdAtom, userIdAtom, userIdentityAtom, variantInfoAtom };

package/dist/atoms/atomStore/index.cjs

@@ -0,0 +1,7 @@
+const require_atomStore = require('../../atomStore-CZKe3itM.cjs');
+require('../../atomStore-CdFkEC8s.cjs');
+
+exports.getAtomStore = require_atomStore.getAtomStore;
+exports.resetAtomStore = require_atomStore.resetAtomStore;
+exports.sessionStorageUtil = require_atomStore.sessionStorageUtil;
+exports.setAtomStoreForTesting = require_atomStore.setAtomStoreForTesting;

package/dist/atoms/atomStore/index.d.cts

@@ -0,0 +1,24 @@
+import { getDefaultStore } from "jotai";
+import * as jotai_vanilla_utils_atomWithStorage0 from "jotai/vanilla/utils/atomWithStorage";
+
+//#region src/atoms/atomStore/atomStore.d.ts
+type AtomStore = ReturnType<typeof getDefaultStore>;
+declare const getAtomStore: () => AtomStore;
+/**
+ * @internal
+ *
+ * Sets the global atom store to be the provided store.
+ *
+ * @param store - The store to set the global atom store to.
+ */
+declare const setAtomStoreForTesting: (store: AtomStore) => void;
+/**
+ * @internal
+ *
+ * Resets the global atom store to null
+ */
+declare const resetAtomStore: () => void;
+declare const sessionStorageUtil: jotai_vanilla_utils_atomWithStorage0.SyncStorage<string | undefined>;
+//#endregion
+export { AtomStore, getAtomStore, resetAtomStore, sessionStorageUtil, setAtomStoreForTesting };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F0b21zL2F0b21TdG9yZS9hdG9tU3RvcmUuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXREZWZhdWx0U3RvcmUgfSBmcm9tICdqb3RhaSc7XG5leHBvcnQgdHlwZSBBdG9tU3RvcmUgPSBSZXR1cm5UeXBlPHR5cGVvZiBnZXREZWZhdWx0U3RvcmU+O1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0QXRvbVN0b3JlOiAoKSA9PiBBdG9tU3RvcmU7XG4vKipcbiAqIEBpbnRlcm5hbFxuICpcbiAqIFNldHMgdGhlIGdsb2JhbCBhdG9tIHN0b3JlIHRvIGJlIHRoZSBwcm92aWRlZCBzdG9yZS5cbiAqXG4gKiBAcGFyYW0gc3RvcmUgLSBUaGUgc3RvcmUgdG8gc2V0IHRoZSBnbG9iYWwgYXRvbSBzdG9yZSB0by5cbiAqL1xuZXhwb3J0IGRlY2xhcmUgY29uc3Qgc2V0QXRvbVN0b3JlRm9yVGVzdGluZzogKHN0b3JlOiBBdG9tU3RvcmUpID0+IHZvaWQ7XG4vKipcbiAqIEBpbnRlcm5hbFxuICpcbiAqIFJlc2V0cyB0aGUgZ2xvYmFsIGF0b20gc3RvcmUgdG8gbnVsbFxuICovXG5leHBvcnQgZGVjbGFyZSBjb25zdCByZXNldEF0b21TdG9yZTogKCkgPT4gdm9pZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHNlc3Npb25TdG9yYWdlVXRpbDogaW1wb3J0KFwiam90YWkvdmFuaWxsYS91dGlscy9hdG9tV2l0aFN0b3JhZ2VcIikuU3luY1N0b3JhZ2U8c3RyaW5nIHwgdW5kZWZpbmVkPjtcbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUVBLElBQVcsWUFBWTtDQUFDO09BQVc7T0FBZTtDQUFBO0FBQ2xELElBQUUsZUFBQSxDQUFBLFdBQUEsVUFBQTtBQUNGLElBQVcseUJBQUEsQ0FBQSxXQUFBLFVBQUE7QUFDWCxJQUFDLGlCQUFBLENBQUEsSUFBQTtBQUNELElBQVcscUJBQXFCLENBQUMsV0FBVyxxQ0FBVSxZQUFBIn0=

package/dist/atoms/atomStore/index.d.ts

@@ -0,0 +1,24 @@
+import { getDefaultStore } from "jotai";
+import * as jotai_vanilla_utils_atomWithStorage0 from "jotai/vanilla/utils/atomWithStorage";
+
+//#region src/atoms/atomStore/atomStore.d.ts
+type AtomStore = ReturnType<typeof getDefaultStore>;
+declare const getAtomStore: () => AtomStore;
+/**
+ * @internal
+ *
+ * Sets the global atom store to be the provided store.
+ *
+ * @param store - The store to set the global atom store to.
+ */
+declare const setAtomStoreForTesting: (store: AtomStore) => void;
+/**
+ * @internal
+ *
+ * Resets the global atom store to null
+ */
+declare const resetAtomStore: () => void;
+declare const sessionStorageUtil: jotai_vanilla_utils_atomWithStorage0.SyncStorage<string | undefined>;
+//#endregion
+export { AtomStore, getAtomStore, resetAtomStore, sessionStorageUtil, setAtomStoreForTesting };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXRvbXMvYXRvbVN0b3JlL2F0b21TdG9yZS5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldERlZmF1bHRTdG9yZSB9IGZyb20gJ2pvdGFpJztcbmV4cG9ydCB0eXBlIEF0b21TdG9yZSA9IFJldHVyblR5cGU8dHlwZW9mIGdldERlZmF1bHRTdG9yZT47XG5leHBvcnQgZGVjbGFyZSBjb25zdCBnZXRBdG9tU3RvcmU6ICgpID0+IEF0b21TdG9yZTtcbi8qKlxuICogQGludGVybmFsXG4gKlxuICogU2V0cyB0aGUgZ2xvYmFsIGF0b20gc3RvcmUgdG8gYmUgdGhlIHByb3ZpZGVkIHN0b3JlLlxuICpcbiAqIEBwYXJhbSBzdG9yZSAtIFRoZSBzdG9yZSB0byBzZXQgdGhlIGdsb2JhbCBhdG9tIHN0b3JlIHRvLlxuICovXG5leHBvcnQgZGVjbGFyZSBjb25zdCBzZXRBdG9tU3RvcmVGb3JUZXN0aW5nOiAoc3RvcmU6IEF0b21TdG9yZSkgPT4gdm9pZDtcbi8qKlxuICogQGludGVybmFsXG4gKlxuICogUmVzZXRzIHRoZSBnbG9iYWwgYXRvbSBzdG9yZSB0byBudWxsXG4gKi9cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHJlc2V0QXRvbVN0b3JlOiAoKSA9PiB2b2lkO1xuZXhwb3J0IGRlY2xhcmUgY29uc3Qgc2Vzc2lvblN0b3JhZ2VVdGlsOiBpbXBvcnQoXCJqb3RhaS92YW5pbGxhL3V0aWxzL2F0b21XaXRoU3RvcmFnZVwiKS5TeW5jU3RvcmFnZTxzdHJpbmcgfCB1bmRlZmluZWQ+O1xuIl0sIm1hcHBpbmdzIjoiOzs7O0FBRUEsSUFBVyxZQUFZO0NBQUM7T0FBVztPQUFlO0NBQUE7QUFDbEQsSUFBRSxlQUFBLENBQUEsV0FBQSxVQUFBO0FBQ0YsSUFBVyx5QkFBQSxDQUFBLFdBQUEsVUFBQTtBQUNYLElBQUMsaUJBQUEsQ0FBQSxJQUFBO0FBQ0QsSUFBVyxxQkFBcUIsQ0FBQyxXQUFXLHFDQUFVLFlBQUEifQ==

package/dist/atoms/atomStore/index.js

@@ -0,0 +1,4 @@
+import { getAtomStore, resetAtomStore, sessionStorageUtil, setAtomStoreForTesting } from "../../atomStore-BuopbV9k.js";
+import "../../atomStore-DKlaDbMx.js";
+
+export { getAtomStore, resetAtomStore, sessionStorageUtil, setAtomStoreForTesting };