oneentry 1.0.153 → 1.0.155

package/README.md

@@ -90,6 +90,8 @@ The second parameter of the constructor takes the 'config'. It contains the foll
 
 - 'guestId' - Optional guest identifier sent as the "x-guest-id" header on unauthenticated requests. It enables guest cart / wishlist / activity flows. In the browser, if you omit it, the SDK generates a stable id and persists it in localStorage. On the server you must pass a per-visitor "guestId" (or call "setGuestId"): the SDK never auto-generates a server id, to avoid sharing one guest across visitors. The header is omitted once a user is authenticated.
 
+- 'deviceMetadata' - Optional device-metadata string sent as the "x-device-metadata" header instead of the fingerprint the SDK computes from the current environment. The API binds refresh tokens to this header, so a server that issues tokens on behalf of a browser (for example, an OAuth code exchange keeping the client secret server-side) must pass the browser's string here — otherwise the issued refresh token is bound to the server's fingerprint and cannot be refreshed from the browser. Obtain the string in the browser via "getDeviceMetadata()" and set/clear it at runtime via "setDeviceMetadata".
+
 - 'traficLimit' - Some methods use more than one request to the CMS so that the data you receive is complete and easy to work with. Pass the value "true" for this parameter to save traffic and decide for yourself what data you need. The default value "false".
 
 - 'auth' - An object with authorization settings. By default, the SDK is configured to work with tokens inside the user's session and does not require any additional work from you. At the same time, the SDK does not store the session state between sessions. If you are satisfied with such settings, do not pass the variable 'auth' at all.

package/changelog.md

@@ -1,5 +1,63 @@
 # SDK Change Log
 
+## v.1.0.155
+
+### What's New
+
+- Config > `deviceMetadata` — new optional config parameter that overrides the `x-device-metadata` header (sent on POST requests and token refresh) instead of the fingerprint computed from the current environment. The API binds refresh tokens to this header, so a server issuing tokens on behalf of a browser (e.g. an OAuth code exchange that keeps the client secret server-side) can now stamp the browser's fingerprint and the issued refresh token stays refreshable from that browser. Previously this required bypassing the SDK with a raw `fetch`.
+- `setDeviceMetadata(deviceMetadata)` — new public method on every module: sets the `x-device-metadata` override at runtime (empty string clears it and falls back to the computed fingerprint).
+- `getDeviceMetadata()` — new public method on every module: returns the `x-device-metadata` string the SDK sends (the override when set, otherwise the environment-derived fingerprint). Use it in the browser to obtain the value that a server-side token-issuing flow must forward; previously this required reaching into the protected `_getDeviceMetadata`.
+
+### Bug Fixes
+
+- `Blocks.getBlocks` — error responses no longer crash block enrichment. On an API error (e.g. `403` without list permission, or `422`) the normalized value is an `IError` without an `items` array; the method previously called `.items.map(...)` unconditionally and threw a `TypeError`. Enrichment now runs only when `items` is an array, and the error response is returned as-is.
+
+- `Pages.getRootPages`, `getPages`, `getChildPagesByParentUrl`, `searchPage` — error responses no longer crash template enrichment. The shared `addTemplateToPages` helper called `.filter(...)` / `.map(...)` on its input; on an API error (e.g. `403` / `422`) that input is an `IError` object, not an array, which threw a `TypeError`. The helper now returns the error response as-is when the input is not an array.
+
+- `Blocks.getProductsByBlockMarker` (used internally by block enrichment) — on an API error the method read `result.items` (which is `undefined` for an `IError`) and returned `undefined` instead of the error. It now returns the normalized error response when there is no `items` array.
+
+### What's Deleted
+
+- AttributesSets > `IAttributeSetsEntity.typeId` and `IAttributeSetsEntity.properties` — removed: the API no longer returns these fields for `getAttributes` / `getAttributeSetByMarker`. The attribute set type is available via the `type` object (`type.id`, `type.type`). The Zod schema (`AttributeSetEntitySchema`) is updated accordingly. The `typeId` **query parameter** of `getAttributes` is unaffected.
+- TemplatePreviews > `ITemplatesPreviewEntity.attributeValues` — removed: the API no longer returns this field for `getTemplatePreviews` / `getTemplatePreviewByMarker` (it was always an empty object). The Zod schema (`TemplatePreviewEntitySchema`) is updated accordingly.
+
+## v.1.0.154
+
+### What's New
+
+- Products > per-method query types — the single `IProductsQuery` is split into focused query types so each method only accepts the parameters it actually supports:
+  - `IProductsQueryBase` — base query (`offset`, `limit`, `sortOrder`, `sortKey`, `signPrice`) used by `getProducts`, `getProductsEmptyPage`, `getProductsByPageId`, `getProductsByPageUrl`.
+  - `IProductsRelatedQuery` — base query plus `statusMarker` and `templateMarker`, used by `getRelatedProductsById`.
+  - `IProductsPriceQuery` — base query without `sortKey`, plus `statusMarker`, used by `getProductsPriceByPageUrl`.
+  - `IProductsByIdsQuery` — only `signPrice` (`ids` is a dedicated method argument), used by `getProductsByIds`.
+  - All four types are now exported.
+
+- Orders > `IOrderProductData.signedPrice` — new optional `signedPrice` (`string`) field: the signed (fixed) product price obtained together with the product data when `signPrice` is set. Used to carry the fixed price into an order line item.
+
+- Products > `IProductInfo.signedPrice` — new optional `signedPrice` (`string`) field on the price-list items returned by `getProductsPriceByPageUrl`; populated with the signed (fixed) price when `signPrice` is set (mirrors `IProductsEntity.signedPrice`).
+
+### What's Changed
+
+- Products > `getProducts`, `getProductsEmptyPage`, `getProductsByPageId`, `getProductsByPageUrl`, `getProductsPriceByPageUrl`, `getRelatedProductsById`, `getProductsByIds` — `userQuery` is now typed with the corresponding per-method query type above instead of the broad `IProductsQuery`. `IProductsQuery` is retained as a **deprecated** alias of `IProductsQueryBase` for backward compatibility.
+
+- Products > `getProductsByIds` — now accepts only `signPrice` in `userQuery` (`IProductsByIdsQuery`); `limit`/`sort`/filter markers are no longer query parameters of this endpoint. As a result `searchProduct` (quick search) no longer forwards an explicit `limit` to the internal `/ids` request.
+
+- Products / Blocks / Orders — JSDoc for `signPrice` / `signedPrice` clarified ("Order storage marker for price fixing…") with links to the "Fixing the price" / "Fixed product price" documentation. Orders > `previewOrder` description cleaned up (removed the stray `???`). No structural change.
+
+- HTTP core — the legacy Node.js `< 18` request path was removed. The SDK previously detected old Node versions and routed requests through a dynamically imported `https` module (`_NO_FETCH` / `state._https`); that branch did **not** perform token refresh, response validation, `errorsFunctions` callbacks or `isShell` handling, so behavior silently degraded on old Node. All requests now go through the native `fetch` path (browser and Node 18+), which collapses four duplicated `_fetchGet` / `_fetchPost` / `_fetchPut` / `_fetchDelete` implementations into one and gives every environment the same auth/validation/error behavior. **The SDK now requires Node 18+** (declared via `engines.node >= 18`).
+
+### Bug Fixes
+
+- Query parameters and free-text search are now URL-encoded (`encodeURIComponent`). Previously values containing spaces, `&`, `=` or non-ASCII characters corrupted the query string — most visibly in the text search of `Products.searchProduct`, `Pages.searchPage` and `Blocks.searchBlock`.
+- `Pages.searchPage` — fixed the `url` query part: when no `url` was passed the request string previously contained stray output (`undefined` / a leading `&`). It is now built correctly and omitted when absent.
+- Auth — the `401 → refresh → retry` path now flows through the same response handling as the initial request. The retried response is checked for `ok`, tolerates an empty body, and runs `errorsFunctions` / honors `isShell`. Previously a failed retry returned the raw error body as if it were successful data, and an empty retry body could throw from `.json()`.
+
+- `defineOneEntry` — initializing the SDK without a project URL or app token no longer crashes with a cryptic `TypeError: Cannot read properties of undefined (reading 'endsWith')`. The function now validates its inputs up front and throws a clear, actionable error instead: a missing/empty `url` (PROJECT_URL) and a missing/empty `config.token` (APP_TOKEN) each produce a descriptive message with a correct usage example. Empty / whitespace-only values (e.g. an unfilled `.env` variable) are treated as missing.
+
+### What's Deleted
+
+- Removed the unused `src/base/result.ts` (dead `Result` class — never imported, and containing a misplaced `await` and unreachable branches).
+
 ## v.1.0.153
 
 ### What's New

package/dist/attribute-sets/attributeSetsInterfaces.d.ts

@@ -206,7 +206,6 @@ interface IAttributeValidators {
  * @property {string} updatedDate - The date when the attribute set was last updated. Example: "2023-10-01T12:00:00Z".
  * @property {number} version - The version number of the attribute set, used for tracking changes or updates. Example: 1.
  * @property {string} identifier - A string that uniquely identifies the attribute set. Example: "attributeSet1".
- * @property {number} typeId - The numerical identifier representing the type of the attribute set. Example: 1.
  * @property {string} title - The title or name of the attribute set. Example: "Product Attributes".
  * @property {Record<string, IAttributeSchemaItem>} schema - Schema fields keyed by marker.
  * @example
@@ -223,12 +222,6 @@ interface IAttributeValidators {
      }
    }
  * @property {boolean} isVisible - Indicates whether the attribute set is visible or not. Example: true.
- * @property {Record<string, unknown>} properties - Additional properties associated with the attribute set; empty object when none.
- * @example
-   {
-     "color": "red",
-     "size": "M"
-   }
  * @property {string} type - The type of the attribute set, which could be a specific classification or category. Example: "product", "user", "etc".
  * @property {number} position - The position number for sorting the attribute set. Example: 1.
  * @description This interface defines the structure of an attribute set entity.
@@ -239,11 +232,9 @@ interface IAttributeSetsEntity {
     updatedDate: string;
     version: number;
     identifier: string;
-    typeId: number;
     title: string;
     schema: Record<string, IAttributeSchemaItem>;
     isVisible: boolean;
-    properties: Record<string, unknown>;
     type: IAttributeSetTypeRef;
     position: number;
 }

package/dist/attribute-sets/attributeSetsSchemas.d.ts

@@ -38,11 +38,9 @@ export declare const AttributeSetEntitySchema: z.ZodObject<{
     updatedDate: z.ZodString;
     version: z.ZodNumber;
     identifier: z.ZodString;
-    typeId: z.ZodNumber;
     title: z.ZodString;
     schema: z.ZodObject<{}, z.core.$loose>;
     isVisible: z.ZodBoolean;
-    properties: z.ZodObject<{}, z.core.$loose>;
     type: z.ZodObject<{
         id: z.ZodNumber;
         type: z.ZodString;
@@ -60,11 +58,9 @@ export declare const AttributeSetsResponseSchema: z.ZodObject<{
         updatedDate: z.ZodString;
         version: z.ZodNumber;
         identifier: z.ZodString;
-        typeId: z.ZodNumber;
         title: z.ZodString;
         schema: z.ZodObject<{}, z.core.$loose>;
         isVisible: z.ZodBoolean;
-        properties: z.ZodObject<{}, z.core.$loose>;
         type: z.ZodObject<{
             id: z.ZodNumber;
             type: z.ZodString;

package/dist/attribute-sets/attributeSetsSchemas.js

@@ -47,11 +47,9 @@ exports.AttributeSetEntitySchema = zod_1.z.object({
     updatedDate: zod_1.z.string(),
     version: zod_1.z.number(),
     identifier: zod_1.z.string(),
-    typeId: zod_1.z.number(),
     title: zod_1.z.string(),
     schema: zod_1.z.object({}).passthrough(),
     isVisible: zod_1.z.boolean(),
-    properties: zod_1.z.object({}).passthrough(),
     type: zod_1.z.object({
         id: zod_1.z.number(),
         type: zod_1.z.string(),

package/dist/base/asyncModules.d.ts

@@ -8,8 +8,6 @@ import type { IError } from './utils';
  */
 export default abstract class AsyncModules extends SyncModules {
     protected state: StateModule;
-    protected _NO_FETCH: boolean;
-    protected _https: any;
     protected _url: string;
     /**
      * Constructor initializes the AsyncModules with a given state.
@@ -86,6 +84,16 @@ export default abstract class AsyncModules extends SyncModules {
      * @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.

package/dist/base/asyncModules.js

@@ -3,9 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable jsdoc/no-undefined-types */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const buffer_1 = require("buffer");
 const syncModules_1 = __importDefault(require("./syncModules"));
 const validation_1 = require("./validation");
 /**
@@ -19,12 +16,9 @@ class AsyncModules extends syncModules_1.default {
      * @description Constructor initializes the AsyncModules with a given state.
      */
     constructor(state) {
-        var _a;
         super(state);
         this.state = state;
         this._url = this.state.url;
-        this._NO_FETCH = state._NO_FETCH;
-        this._https = (_a = state._https) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Validates API response against a Zod schema (optional)
@@ -78,47 +72,7 @@ class AsyncModules extends syncModules_1.default {
      * @description Define a protected asynchronous method '_fetchGet' that performs a GET request
      */
     async _fetchGet(path) {
-        // Create options for the GET request using the 'makeOptions' method
-        const options = this.makeOptions('GET');
-        // Check if the fetch operation should be performed using the Fetch API or an alternative method
-        if (!this._NO_FETCH) {
-            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
-            return await this.browserResponse(path, options);
-        }
-        else {
-            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
-            // Return a new promise to handle the asynchronous nature of the HTTPS request
-            return new Promise((resolve, reject) => {
-                // Use the HTTPS module to send a GET request to the specified path with the given options
-                const req = this._https.get(this._getFullPath(path), // Get the full URL path for the request
-                options, // Pass the options for the request
-                (res) => {
-                    // Handle the response from the server
-                    let responseData = ''; // Initialize a variable to accumulate response data
-                    // Listen for 'data' events to receive chunks of data from the response
-                    res.on('data', (chunk) => {
-                        responseData += chunk; // Append each chunk to the accumulated response data
-                    });
-                    // Listen for the 'end' event to know when the response has been fully received
-                    res.on('end', () => {
-                        try {
-                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
-                            resolve(JSON.parse(responseData));
-                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        }
-                        catch (error) {
-                            // If parsing fails, resolve the promise with the raw response data
-                            resolve(responseData);
-                        }
-                    });
-                });
-                // Listen for 'error' events on the request to handle any errors that occur
-                req.on('error', (error) => {
-                    // Reject the promise with the error
-                    reject(error);
-                });
-            });
-        }
+        return this.browserResponse(path, this.makeOptions('GET'));
     }
     /**
      * Performs an HTTP POST request.
@@ -128,54 +82,7 @@ class AsyncModules extends syncModules_1.default {
      * @description Define a protected asynchronous method '_fetchPost' that performs a POST request
      */
     async _fetchPost(path, data) {
-        // Create options for the POST request using the 'makeOptions' method, including the data to be sent
-        const options = this.makeOptions('POST', data);
-        // Check if the fetch operation should be performed using the Fetch API or an alternative method
-        if (!this._NO_FETCH) {
-            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
-            return await this.browserResponse(path, options);
-        }
-        else {
-            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
-            // Return a new promise to handle the asynchronous nature of the HTTPS request
-            return new Promise((resolve, reject) => {
-                // Use the HTTPS module to send a POST request to the specified path with the given options
-                const req = this._https.request(this._getFullPath(path), // Get the full URL path for the request
-                options, // Pass the options for the request
-                (res) => {
-                    // Handle the response from the server
-                    // Accumulate response chunks in an array for efficient memory usage
-                    const chunks = [];
-                    // Listen for 'data' events to receive chunks of data from the response
-                    res.on('data', (chunk) => {
-                        chunks.push(buffer_1.Buffer.isBuffer(chunk) ? chunk : buffer_1.Buffer.from(chunk));
-                    });
-                    // Listen for the 'end' event to know when the response has been fully received
-                    res.on('end', () => {
-                        try {
-                            // Concatenate all chunks efficiently and parse as JSON
-                            const responseData = buffer_1.Buffer.concat(chunks).toString('utf8');
-                            resolve(JSON.parse(responseData));
-                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        }
-                        catch (error) {
-                            // If parsing fails, resolve the promise with the raw response data
-                            const responseData = buffer_1.Buffer.concat(chunks).toString('utf8');
-                            resolve(responseData);
-                        }
-                    });
-                });
-                // Listen for 'error' events on the request to handle any errors that occur
-                req.on('error', (error) => {
-                    // Reject the promise with the error
-                    reject(error);
-                });
-                // Write the provided data to the request body in JSON format
-                req.write(JSON.stringify(data));
-                // End the request to signal that all data has been sent
-                req.end();
-            });
-        }
+        return this.browserResponse(path, this.makeOptions('POST', data));
     }
     /**
      * Performs an HTTP PUT request.
@@ -185,51 +92,7 @@ class AsyncModules extends syncModules_1.default {
      * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
      */
     async _fetchPut(path, body) {
-        // Create options for the PUT request using the 'makeOptions' method, including the data to be sent
-        const options = this.makeOptions('PUT', body);
-        // Check if the fetch operation should be performed using the Fetch API or an alternative method
-        if (!this._NO_FETCH) {
-            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
-            return await this.browserResponse(path, options);
-        }
-        else {
-            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
-            // Return a new promise to handle the asynchronous nature of the HTTPS request
-            return new Promise((resolve, reject) => {
-                // Use the HTTPS module to send a PUT request to the specified path with the given options
-                const req = this._https.request(this._getFullPath(path), // Get the full URL path for the request
-                options, // Pass the options for the request
-                (res) => {
-                    // Handle the response from the server
-                    let responseData = ''; // Initialize a variable to accumulate response data
-                    // Listen for 'data' events to receive chunks of data from the response
-                    res.on('data', (chunk) => {
-                        responseData += chunk; // Append each chunk to the accumulated response data
-                    });
-                    // Listen for the 'end' event to know when the response has been fully received
-                    res.on('end', () => {
-                        try {
-                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
-                            resolve(JSON.parse(responseData));
-                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        }
-                        catch (error) {
-                            // If parsing fails, resolve the promise with the raw response data
-                            resolve(responseData);
-                        }
-                    });
-                });
-                // Listen for 'error' events on the request to handle any errors that occur
-                req.on('error', (error) => {
-                    // Reject the promise with the error
-                    reject(error);
-                });
-                // Write the provided data to the request body in JSON format
-                req.write(JSON.stringify(body));
-                // End the request to signal that all data has been sent
-                req.end();
-            });
-        }
+        return this.browserResponse(path, this.makeOptions('PUT', body));
     }
     /**
      * Performs an HTTP DELETE request.
@@ -239,47 +102,7 @@ class AsyncModules extends syncModules_1.default {
      * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
      */
     async _fetchDelete(path, body) {
-        // Create options for the DELETE request using the 'makeOptions' method
-        const options = this.makeOptions('DELETE', body);
-        // Check if the fetch operation should be performed using the Fetch API or an alternative method
-        if (!this._NO_FETCH) {
-            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
-            return await this.browserResponse(path, options);
-        }
-        else {
-            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
-            // Return a new promise to handle the asynchronous nature of the HTTPS request
-            return new Promise((resolve, reject) => {
-                // Use the HTTPS module to send a DELETE request to the specified path with the given options
-                const req = this._https.delete(this._getFullPath(path), // Get the full URL path for the request
-                options, // Pass the options for the request
-                (res) => {
-                    // Handle the response from the server
-                    let responseData = ''; // Initialize a variable to accumulate response data
-                    // Listen for 'data' events to receive chunks of data from the response
-                    res.on('data', (chunk) => {
-                        responseData += chunk; // Append each chunk to the accumulated response data
-                    });
-                    // Listen for the 'end' event to know when the response has been fully received
-                    res.on('end', () => {
-                        try {
-                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
-                            resolve(JSON.parse(responseData));
-                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        }
-                        catch (error) {
-                            // If parsing fails, resolve the promise with the raw response data
-                            resolve(responseData);
-                        }
-                    });
-                });
-                // Listen for 'error' events on the request to handle any errors that occur
-                req.on('error', (error) => {
-                    // Reject the promise with the error
-                    reject(error);
-                });
-            });
-        }
+        return this.browserResponse(path, this.makeOptions('DELETE', body));
     }
     /**
      * Wraps a fetch call whose only meaningful outcome is success or failure.
@@ -429,6 +252,24 @@ class AsyncModules extends syncModules_1.default {
         }
         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.
@@ -464,56 +305,45 @@ class AsyncModules extends syncModules_1.default {
                 }
             }
             // Perform a fetch request using the full URL obtained from '_getFullPath' and the provided options
-            const response = await fetch(this._getFullPath(path), 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) {
-                try {
-                    // Attempt to read the response body as text
-                    const text = await response.text();
-                    // If the response body is not empty, parse it as JSON; otherwise, return an empty object
-                    return (text ? JSON.parse(text) : {});
-                    // Alternatively, you could directly return the parsed JSON with 'await response.json()'
-                }
-                catch (e) {
-                    // If parsing the response fails, return the error
-                    return e;
-                }
+                // 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 {
-                // Handle non-OK responses
-                // 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).
-                if (response.status === 401 &&
-                    !this.state.customAuth &&
-                    !proactiveRefreshFailed) {
-                    // Attempt to refresh the access token
-                    const refresh = await this.refreshToken();
-                    if (refresh) {
-                        // Update the Authorization header with the new access token
-                        options.headers['Authorization'] =
-                            'Bearer ' + this.state.accessToken;
-                        // Retry the fetch request with updated headers
-                        const secondResponse = await fetch(this._getFullPath(path), options);
-                        // Return the JSON-parsed response of the retry request
-                        return (await secondResponse.json());
-                    }
-                }
-                // Store the response status and parse the response body as JSON
-                const status = response.status;
-                const res = await response.json();
-                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;
-                }
+                throw res;
             }
         }
         catch (e) {

package/dist/base/stateModule.d.ts

@@ -1,4 +1,6 @@
 import type { IConfig, IError } from './utils';
+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.
@@ -8,30 +10,19 @@ export default class StateModule {
     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;
-    _NO_FETCH: boolean;
-    _https: any;
     isShell: boolean;
     validationEnabled: boolean;
     validationStrictMode: boolean;
     validationLogErrors: boolean;
     rawData: boolean;
-    errorsFunctions: {
-        400?: (data: IError) => any | null;
-        401?: (data: IError) => any | null;
-        403?: (data: IError) => any | null;
-        404?: (data: IError) => any | null;
-        429?: (data: IError) => any | null;
-        500?: (data: IError) => any | null;
-        502?: (data: IError) => any | null;
-        503?: (data: IError) => any | null;
-        504?: (data: IError) => any | null;
-    };
+    errorsFunctions: Partial<Record<ErrorStatusCode, (data: IError) => any>>;
     saveFunction: (param: string) => void | null;
     /**
      * Constructor for StateModule
@@ -41,3 +32,4 @@ export default class StateModule {
      */
     constructor(url: string, config: IConfig);
 }
+export {};