oneentry 1.0.159 → 1.0.161

package/esm/base/asyncModules.d.ts

@@ -0,0 +1,123 @@
+import type { z } from 'zod';
+import type StateModule from './stateModule.js';
+import SyncModules from './syncModules.js';
+import type { IError } from './utils.js';
+/**
+ * Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
+ * @description Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
+ */
+export default abstract class AsyncModules extends SyncModules {
+    protected state: StateModule;
+    protected _url: string;
+    /**
+     * Constructor initializes the AsyncModules with a given state.
+     * @param {StateModule} state - Instance of StateModule containing configuration and state data.
+     * @description Constructor initializes the AsyncModules with a given state.
+     */
+    protected constructor(state: StateModule);
+    /**
+     * Detects an API error returned as a value instead of being thrown.
+     *
+     * With `isShell` enabled (the default) `browserResponse` returns the error
+     * body — and a caught exception — instead of throwing, so a failed request
+     * is indistinguishable from a successful one by control flow alone.
+     * @param {unknown} value - Value returned by a request.
+     * @returns {boolean} True when the value is an API error (statusCode >= 400) or a thrown error object.
+     * @description Recognizes both the OneEntry error body and errors caught by browserResponse (e.g. a network failure).
+     */
+    protected _isErrorResponse(value: unknown): value is IError;
+    /**
+     * Validates API response against a Zod schema (optional)
+     * @param {unknown} data - The data to validate
+     * @param {() => Promise<z.ZodSchema<T>>} [loadSchema] - Optional loader resolving to the Zod schema for validation
+     * @returns {Promise<T | IError>} Validated data or error object
+     * @description Validates response data if validation is enabled in config.
+     * The schema — and Zod itself — are imported on demand, so a project that leaves
+     * validation disabled (the default) never pulls Zod into its bundle.
+     */
+    protected _validateResponse<T>(data: unknown, loadSchema?: () => Promise<z.ZodSchema<T>>): Promise<T | IError>;
+    /**
+     * Performs an HTTP GET request.
+     * @param {string} path - The path to append to the base URL.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchGet' that performs a GET request
+     */
+    protected _fetchGet<T = unknown>(path: string): Promise<T>;
+    /**
+     * Performs an HTTP POST request.
+     * @param {string} path   - The path to append to the base URL.
+     * @param {unknown} [data] - The data to send in the request body.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPost' that performs a POST request
+     */
+    protected _fetchPost<T = unknown>(path: string, data?: unknown): Promise<T>;
+    /**
+     * Performs an HTTP PUT request.
+     * @param {string} path - The path to append to the base URL.
+     * @param {unknown} body - The data to send in the request body.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
+     */
+    protected _fetchPut<T = unknown>(path: string, body: unknown): Promise<T>;
+    /**
+     * Performs an HTTP DELETE request.
+     * @param {string} path - The path to append to the base URL.
+     * @param {unknown} body - The body of the request.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
+     */
+    protected _fetchDelete<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Wraps a fetch call whose only meaningful outcome is success or failure.
+     *
+     * Several endpoints (cancel/recover subscription, subscribe/unsubscribe to
+     * events) return no useful body — callers only care whether the request
+     * succeeded. This helper resolves to `true` on success and to the error
+     * (as IError) on failure, centralizing the repeated try/catch.
+     *
+     * The returned value has to be inspected as well: with `isShell` enabled
+     * (the default) browserResponse returns the API error instead of throwing
+     * it, so relying on the catch alone would report every failed call — a 404
+     * from cancelSubscription, a 403 from recoverSubscriptions — as a success.
+     * @param {() => Promise<unknown>} request - Thunk performing the fetch call.
+     * @returns {Promise<boolean | IError>} `true` on success, IError on failure.
+     */
+    protected _fetchBoolean(request: () => Promise<unknown>): Promise<boolean | IError>;
+    /**
+     * Refreshes the authentication token (single-flight).
+     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
+     * @description De-duplicates concurrent refreshes — the refresh token is single-use, so parallel requests must share one refresh call instead of each burning a rotated token.
+     */
+    protected refreshToken(): Promise<boolean>;
+    /**
+     * Performs the actual token refresh request (without de-duplication).
+     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
+     * @description Sends POST /users/refresh and, on success, stores the rotated access/refresh tokens and calls saveFunction.
+     */
+    private _performRefresh;
+    /**
+     * Creates options for HTTP requests.
+     * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
+     * @param {unknown} data - Optional data to include in the request body.
+     * @returns {IHttpOptions} An object representing the request options.
+     */
+    private makeOptions;
+    /**
+     * Reads a response body as JSON, tolerating an empty body.
+     *
+     * `Response.json()` throws on an empty body (e.g. 204 or an empty error
+     * payload); this helper mirrors the OK-path guard (`text ? JSON.parse : {}`)
+     * so both the success and the error branches handle empty bodies the same way.
+     * @param {Response} response - The fetch Response to read.
+     * @returns {Promise<unknown>} Parsed JSON, or an empty object when the body is empty/unparsable.
+     */
+    private _parseJson;
+    /**
+     * Handles responses from the browser's fetch API.
+     * @param {string} path - The path to append to the base URL.
+     * @param {IHttpOptions} options - The options for the fetch request.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define an asynchronous method 'browserResponse' that takes a path and options as parameters
+     */
+    private browserResponse;
+}

package/esm/base/asyncModules.js

@@ -0,0 +1,382 @@
+import SyncModules from './syncModules.js';
+/**
+ * Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
+ * @description Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
+ */
+export default class AsyncModules extends SyncModules {
+    /**
+     * Constructor initializes the AsyncModules with a given state.
+     * @param {StateModule} state - Instance of StateModule containing configuration and state data.
+     * @description Constructor initializes the AsyncModules with a given state.
+     */
+    constructor(state) {
+        super(state);
+        this.state = state;
+        this._url = this.state.url;
+    }
+    /**
+     * Detects an API error returned as a value instead of being thrown.
+     *
+     * With `isShell` enabled (the default) `browserResponse` returns the error
+     * body — and a caught exception — instead of throwing, so a failed request
+     * is indistinguishable from a successful one by control flow alone.
+     * @param {unknown} value - Value returned by a request.
+     * @returns {boolean} True when the value is an API error (statusCode >= 400) or a thrown error object.
+     * @description Recognizes both the OneEntry error body and errors caught by browserResponse (e.g. a network failure).
+     */
+    _isErrorResponse(value) {
+        if (value instanceof Error) {
+            return true;
+        }
+        return (value !== null &&
+            typeof value === 'object' &&
+            'statusCode' in value &&
+            typeof value.statusCode === 'number' &&
+            value.statusCode >= 400);
+    }
+    /**
+     * Validates API response against a Zod schema (optional)
+     * @param {unknown} data - The data to validate
+     * @param {() => Promise<z.ZodSchema<T>>} [loadSchema] - Optional loader resolving to the Zod schema for validation
+     * @returns {Promise<T | IError>} Validated data or error object
+     * @description Validates response data if validation is enabled in config.
+     * The schema — and Zod itself — are imported on demand, so a project that leaves
+     * validation disabled (the default) never pulls Zod into its bundle.
+     */
+    async _validateResponse(data, loadSchema) {
+        // Skip validation if not enabled or no schema provided
+        if (!this.state.validationEnabled || !loadSchema) {
+            return data;
+        }
+        // Skip validation for error responses (statusCode indicates API error)
+        if (this._isErrorResponse(data)) {
+            return data;
+        }
+        // Pull the schema and the Zod-backed validators only now that they are needed
+        const [schema, { validateResponse, validateResponseSafe }] = await Promise.all([loadSchema(), import('./validation.js')]);
+        // Use strict or safe validation based on config
+        if (this.state.validationStrictMode) {
+            const result = validateResponse(schema, data, {
+                logErrors: this.state.validationLogErrors,
+            });
+            if (!result.success) {
+                // Return error object compatible with IError interface
+                return {
+                    statusCode: 422,
+                    message: 'Response validation failed',
+                    pageData: null,
+                    timestamp: new Date().toISOString(),
+                    localizeMessage: result.error.issues
+                        .map((e) => `${e.path.join('.')}: ${e.message}`)
+                        .join(', '),
+                    validationErrors: result.error.issues,
+                };
+            }
+            return result.data;
+        }
+        else {
+            // Non-strict mode: log errors but return original data
+            return validateResponseSafe(schema, data, this.state.validationLogErrors);
+        }
+    }
+    /**
+     * Performs an HTTP GET request.
+     * @param {string} path - The path to append to the base URL.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchGet' that performs a GET request
+     */
+    async _fetchGet(path) {
+        return this.browserResponse(path, this.makeOptions('GET'));
+    }
+    /**
+     * Performs an HTTP POST request.
+     * @param {string} path   - The path to append to the base URL.
+     * @param {unknown} [data] - The data to send in the request body.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPost' that performs a POST request
+     */
+    async _fetchPost(path, data) {
+        return this.browserResponse(path, this.makeOptions('POST', data));
+    }
+    /**
+     * Performs an HTTP PUT request.
+     * @param {string} path - The path to append to the base URL.
+     * @param {unknown} body - The data to send in the request body.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
+     */
+    async _fetchPut(path, body) {
+        return this.browserResponse(path, this.makeOptions('PUT', body));
+    }
+    /**
+     * Performs an HTTP DELETE request.
+     * @param {string} path - The path to append to the base URL.
+     * @param {unknown} body - The body of the request.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
+     */
+    async _fetchDelete(path, body) {
+        return this.browserResponse(path, this.makeOptions('DELETE', body));
+    }
+    /**
+     * Wraps a fetch call whose only meaningful outcome is success or failure.
+     *
+     * Several endpoints (cancel/recover subscription, subscribe/unsubscribe to
+     * events) return no useful body — callers only care whether the request
+     * succeeded. This helper resolves to `true` on success and to the error
+     * (as IError) on failure, centralizing the repeated try/catch.
+     *
+     * The returned value has to be inspected as well: with `isShell` enabled
+     * (the default) browserResponse returns the API error instead of throwing
+     * it, so relying on the catch alone would report every failed call — a 404
+     * from cancelSubscription, a 403 from recoverSubscriptions — as a success.
+     * @param {() => Promise<unknown>} request - Thunk performing the fetch call.
+     * @returns {Promise<boolean | IError>} `true` on success, IError on failure.
+     */
+    async _fetchBoolean(request) {
+        try {
+            const result = await request();
+            if (this._isErrorResponse(result)) {
+                return result;
+            }
+            return true;
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    /**
+     * Refreshes the authentication token (single-flight).
+     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
+     * @description De-duplicates concurrent refreshes — the refresh token is single-use, so parallel requests must share one refresh call instead of each burning a rotated token.
+     */
+    async refreshToken() {
+        // Reuse an in-flight refresh if one is already running (shared via state
+        // across all module instances). Prevents parallel requests from each firing
+        // their own refresh and invalidating the single-use refresh token.
+        if (this.state._refreshPromise) {
+            return this.state._refreshPromise;
+        }
+        const promise = this._performRefresh();
+        this.state._refreshPromise = promise;
+        try {
+            return await promise;
+        }
+        finally {
+            // Clear so the next genuine 401 (e.g. mid-session expiry) can refresh again.
+            this.state._refreshPromise = null;
+        }
+    }
+    /**
+     * Performs the actual token refresh request (without de-duplication).
+     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
+     * @description Sends POST /users/refresh and, on success, stores the rotated access/refresh tokens and calls saveFunction.
+     */
+    async _performRefresh() {
+        const url = this.state.url +
+            `/api/content/users-auth-providers/marker/` +
+            this.state.providerMarker +
+            `/users/refresh`;
+        /**
+         * Perform a fetch request to the specified URL to refresh the token
+         * @param {string} url - The URL to which the request will be sent
+         * @param {object} options - The options for the fetch request
+         * @param {string} options.method - The HTTP method to use for the request (default: 'POST')
+         * @param {object} options.headers - Set the necessary headers for the request
+         * @param {object} options.body - Send the current refresh token in the request body as a JSON string
+         */
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                // Indicate that the request body is in JSON format
+                'Content-Type': 'application/json',
+                // Include the application token from the state
+                'x-app-token': this.state.token,
+                // Include the device fingerprint
+                'x-device-metadata': this._getDeviceMetadata(),
+                // x-guest-id is intentionally omitted: refresh is an auth-only call
+                // (a pure guest has no refresh token), so guest scoping does not apply.
+            },
+            body: JSON.stringify({ refreshToken: this.state.refreshToken }),
+        });
+        // Check if the response status is OK (status code 200-299)
+        if (response.ok) {
+            // Parse the response body as JSON and store the result
+            const result = await response.json();
+            // Update the state's refreshToken and accessToken with the new tokens from the response
+            this.state.refreshToken = result.refreshToken;
+            this.state.accessToken = result.accessToken;
+            // If a save function is defined in the state, call it with the new refresh token
+            if (this.state.saveFunction) {
+                this.state.saveFunction(result.refreshToken);
+            }
+            // Return true to indicate that the token refresh was successful
+            return true;
+        }
+        else {
+            // Return false to indicate that the token refresh failed
+            return false;
+        }
+    }
+    /**
+     * Creates options for HTTP requests.
+     * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
+     * @param {unknown} data - Optional data to include in the request body.
+     * @returns {IHttpOptions} An object representing the request options.
+     */
+    makeOptions(method, data) {
+        const options = {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-app-token': this.state.token,
+            },
+        };
+        // Guest identifier — enables guest cart/wishlist/activity flows.
+        // Only sent for unauthenticated requests: once a user is logged in their
+        // own identity scopes the data, and sending the guest id would link the
+        // anonymous trail to the account. Omitted entirely when no id is available
+        // (e.g. server-side without an explicit guestId — see _getGuestId).
+        if (!this.state.accessToken) {
+            const guestId = this._getGuestId();
+            if (guestId) {
+                options.headers['x-guest-id'] = guestId;
+            }
+        }
+        // if method = 'POST' add x-device-metadata
+        if (method === 'POST') {
+            options.headers = {
+                ...options.headers,
+                'x-device-metadata': this._getDeviceMetadata(),
+            };
+        }
+        // Check if 'data' is an instance of FormData or Blob
+        if (data instanceof FormData || data instanceof Blob) {
+            // Remove the 'Content-Type' header from options.headers
+            delete options.headers['Content-Type'];
+            // Set the 'accept' header to 'application/json', while preserving existing headers
+            options.headers = {
+                ...options.headers,
+                accept: 'application/json',
+            };
+            // Assign 'data' to options.body for sending as request payload
+            options.body = data;
+        }
+        else if (data) {
+            // If 'data' exists and is not FormData or Blob, convert it to a JSON string
+            // and assign it to options.body
+            options.body = JSON.stringify(data);
+        }
+        // Check if there is an access token available in the state
+        if (this.state.accessToken) {
+            // Add an 'Authorization' header with the Bearer token to options.headers
+            options.headers['Authorization'] = 'Bearer ' + this.state.accessToken;
+        }
+        return options;
+    }
+    /**
+     * Reads a response body as JSON, tolerating an empty body.
+     *
+     * `Response.json()` throws on an empty body (e.g. 204 or an empty error
+     * payload); this helper mirrors the OK-path guard (`text ? JSON.parse : {}`)
+     * so both the success and the error branches handle empty bodies the same way.
+     * @param {Response} response - The fetch Response to read.
+     * @returns {Promise<unknown>} Parsed JSON, or an empty object when the body is empty/unparsable.
+     */
+    async _parseJson(response) {
+        try {
+            const text = await response.text();
+            return text ? JSON.parse(text) : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Handles responses from the browser's fetch API.
+     * @param {string} path - The path to append to the base URL.
+     * @param {IHttpOptions} options - The options for the fetch request.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define an asynchronous method 'browserResponse' that takes a path and options as parameters
+     */
+    async browserResponse(path, options) {
+        // Set when a proactive refresh ran and failed (dead/expired refresh token):
+        // used below to skip the reactive refresh so we don't fire a second,
+        // equally-doomed refresh on the 401 that the request is about to return.
+        let proactiveRefreshFailed = false;
+        try {
+            // Proactive (eager) refresh: a session restored from storage has a refresh
+            // token but no access token yet. Sending the first authenticated request
+            // without an access token GUARANTEES a 401 (then a reactive refresh + retry)
+            // — a spurious 401 logged on every page load even for a perfectly valid
+            // session. Obtaining the access token up-front turns that into a clean 200.
+            // Fires at most once per session (skipped once accessToken is set), and is
+            // off for custom-auth callers who manage tokens themselves.
+            if (!this.state.accessToken &&
+                this.state.refreshToken &&
+                !this.state.customAuth) {
+                const refreshed = await this.refreshToken();
+                if (refreshed) {
+                    // Authenticated now — attach the bearer and drop the guest scoping
+                    // that makeOptions added while no access token was present.
+                    options.headers['Authorization'] = 'Bearer ' + this.state.accessToken;
+                    delete options.headers['x-guest-id'];
+                }
+                else {
+                    proactiveRefreshFailed = true;
+                }
+            }
+            // Perform a fetch request using the full URL obtained from '_getFullPath' and the provided options
+            let response = await fetch(this._getFullPath(path), options);
+            // Reactive refresh for mid-session expiry: access token was present but
+            // the server rejected it. Skipped when a proactive refresh already ran
+            // and failed (the refresh token is dead — retrying would 400 again).
+            // On success the request is retried once; the retry response then flows
+            // through the SAME ok / error handling below (status check, errorsFunctions,
+            // isShell) instead of being returned blindly.
+            if (!response.ok &&
+                response.status === 401 &&
+                !this.state.customAuth &&
+                !proactiveRefreshFailed) {
+                const refresh = await this.refreshToken();
+                if (refresh) {
+                    // Update the Authorization header with the new access token and retry.
+                    options.headers['Authorization'] = 'Bearer ' + this.state.accessToken;
+                    response = await fetch(this._getFullPath(path), options);
+                }
+            }
+            // Check if the response status is OK (status code 200-299)
+            if (response.ok) {
+                // Read the body as text; if it is empty return an empty object,
+                // otherwise parse it as JSON. A parse failure propagates to the
+                // catch below and is handled according to isShell.
+                const text = await response.text();
+                return (text ? JSON.parse(text) : {});
+            }
+            // Handle non-OK responses (applies to the first response and to a failed retry).
+            const status = response.status;
+            const res = await this._parseJson(response);
+            const statusKey = status;
+            if (this.state.errorsFunctions && this.state.errorsFunctions[statusKey]) {
+                this.state.errorsFunctions[statusKey](res);
+            }
+            // Determine whether to return or throw the response based on 'isShell' state
+            if (this.state.isShell) {
+                return res;
+            }
+            else {
+                throw res;
+            }
+        }
+        catch (e) {
+            // Handle any errors that occur during the fetch process
+            // Determine whether to return or throw the error based on 'isShell' state
+            if (this.state.isShell) {
+                return e;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+}

package/esm/base/lazySchema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a lazy schema loader bound to a module of Zod schemas.
+ *
+ * Validation is opt-in (`config.validation.enabled`, `false` by default), yet a static
+ * `import { PageEntitySchema } from './pagesSchemas'` would put Zod into the import graph
+ * of every consumer regardless. Binding the module behind a dynamic `import()` keeps it —
+ * and Zod — out of the bundle until a request actually needs to be validated.
+ * @param {() => Promise<TSchemas>} importSchemas - Dynamic import of the module holding the schemas.
+ * @returns {(name: keyof TSchemas) => () => Promise<TSchemas[keyof TSchemas]>} Function that takes
+ * a schema name and returns a loader for that schema.
+ * @description Usage: `const schema = createSchemaLoader(() => import('./pagesSchemas'))`,
+ * then `this._validateResponse(data, schema('PageEntitySchema'))`. The schema name is
+ * checked against the module's exports, so a typo is a compile-time error.
+ */
+export default function createSchemaLoader<TSchemas>(importSchemas: () => Promise<TSchemas>): <TName extends keyof TSchemas>(name: TName) => () => Promise<TSchemas[TName]>;

package/esm/base/lazySchema.js

@@ -0,0 +1,17 @@
+/**
+ * Creates a lazy schema loader bound to a module of Zod schemas.
+ *
+ * Validation is opt-in (`config.validation.enabled`, `false` by default), yet a static
+ * `import { PageEntitySchema } from './pagesSchemas'` would put Zod into the import graph
+ * of every consumer regardless. Binding the module behind a dynamic `import()` keeps it —
+ * and Zod — out of the bundle until a request actually needs to be validated.
+ * @param {() => Promise<TSchemas>} importSchemas - Dynamic import of the module holding the schemas.
+ * @returns {(name: keyof TSchemas) => () => Promise<TSchemas[keyof TSchemas]>} Function that takes
+ * a schema name and returns a loader for that schema.
+ * @description Usage: `const schema = createSchemaLoader(() => import('./pagesSchemas'))`,
+ * then `this._validateResponse(data, schema('PageEntitySchema'))`. The schema name is
+ * checked against the module's exports, so a typo is a compile-time error.
+ */
+export default function createSchemaLoader(importSchemas) {
+    return (name) => () => importSchemas().then((schemas) => schemas[name]);
+}

package/esm/base/stateModule.d.ts

@@ -0,0 +1,35 @@
+import type { IConfig, IError } from './utils.js';
+declare const ERROR_STATUS_CODES: readonly [400, 401, 403, 404, 429, 500, 502, 503, 504];
+type ErrorStatusCode = (typeof ERROR_STATUS_CODES)[number];
+/**
+ * State module for managing application state and configuration.
+ * @description State module for managing application state and configuration.
+ */
+export default class StateModule {
+    url: string | undefined;
+    lang: string | undefined;
+    token: string | undefined;
+    guestId: string | undefined;
+    deviceMetadata: string | undefined;
+    accessToken: string | undefined;
+    traficLimit: boolean;
+    refreshToken: string | undefined;
+    _refreshPromise: Promise<boolean> | null;
+    providerMarker: string;
+    customAuth: boolean;
+    isShell: boolean;
+    validationEnabled: boolean;
+    validationStrictMode: boolean;
+    validationLogErrors: boolean;
+    rawData: boolean;
+    errorsFunctions: Partial<Record<ErrorStatusCode, (data: IError) => any>>;
+    saveFunction: (param: string) => void | null;
+    /**
+     * Constructor for StateModule
+     * @param {string} url - Base URL for API requests.
+     * @param {IConfig} config - Configuration object.
+     * @description Constructor for StateModule.
+     */
+    constructor(url: string, config: IConfig);
+}
+export {};

package/esm/base/stateModule.js

@@ -0,0 +1,51 @@
+// HTTP status codes for which a custom error handler may be configured.
+const ERROR_STATUS_CODES = [
+    400, 401, 403, 404, 429, 500, 502, 503, 504,
+];
+/**
+ * State module for managing application state and configuration.
+ * @description State module for managing application state and configuration.
+ */
+export default class StateModule {
+    /**
+     * Constructor for StateModule
+     * @param {string} url - Base URL for API requests.
+     * @param {IConfig} config - Configuration object.
+     * @description Constructor for StateModule.
+     */
+    constructor(url, config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+        // In-flight token refresh, shared across all module instances (they share this
+        // state object). De-duplicates concurrent refreshes so the single-use refresh
+        // token is not burned by parallel requests. Null when no refresh is running.
+        this._refreshPromise = null;
+        this.url = url;
+        this.lang = (_a = config.langCode) !== null && _a !== void 0 ? _a : 'en_US';
+        this.token = config.token;
+        // Normalize empty string to undefined: an explicit '' must not masquerade
+        // as a set guest id (it would otherwise suppress id resolution).
+        this.guestId = config.guestId || undefined;
+        // Same normalization as guestId: an explicit '' must not suppress the
+        // environment-derived fingerprint.
+        this.deviceMetadata = config.deviceMetadata || undefined;
+        this.traficLimit = config.traficLimit || false;
+        this.validationEnabled = (_c = (_b = config.validation) === null || _b === void 0 ? void 0 : _b.enabled) !== null && _c !== void 0 ? _c : false;
+        this.validationStrictMode = (_e = (_d = config.validation) === null || _d === void 0 ? void 0 : _d.strictMode) !== null && _e !== void 0 ? _e : false;
+        this.validationLogErrors = (_g = (_f = config.validation) === null || _f === void 0 ? void 0 : _f.logErrors) !== null && _g !== void 0 ? _g : true;
+        this.rawData = (_h = config.rawData) !== null && _h !== void 0 ? _h : false;
+        this.refreshToken = (_k = (_j = config.auth) === null || _j === void 0 ? void 0 : _j.refreshToken) !== null && _k !== void 0 ? _k : undefined;
+        this.providerMarker = (_m = (_l = config.auth) === null || _l === void 0 ? void 0 : _l.providerMarker) !== null && _m !== void 0 ? _m : 'email';
+        this.customAuth = (_p = (_o = config.auth) === null || _o === void 0 ? void 0 : _o.customAuth) !== null && _p !== void 0 ? _p : false;
+        this.errorsFunctions = {};
+        this.saveFunction = (_r = (_q = config.auth) === null || _q === void 0 ? void 0 : _q.saveFunction) !== null && _r !== void 0 ? _r : null;
+        this.isShell = (_t = (_s = config.errors) === null || _s === void 0 ? void 0 : _s.isShell) !== null && _t !== void 0 ? _t : true;
+        const customErrors = (_u = config.errors) === null || _u === void 0 ? void 0 : _u.customErrors;
+        if (customErrors) {
+            for (const code of ERROR_STATUS_CODES) {
+                if (customErrors[code]) {
+                    this.errorsFunctions[code] = customErrors[code];
+                }
+            }
+        }
+    }
+}