oneentry 1.0.152 → 1.0.154

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,46 +102,25 @@ 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);
+        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 caught
+     * error (as IError) on failure, centralizing the repeated try/catch.
+     * @param {() => Promise<unknown>} request - Thunk performing the fetch call.
+     * @returns {Promise<boolean | IError>} `true` on success, IError on failure.
+     */
+    async _fetchBoolean(request) {
+        try {
+            await request();
+            return true;
         }
-        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);
-                });
-            });
+        catch (e) {
+            return e;
         }
     }
     /**
@@ -410,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.
@@ -445,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.
@@ -14,24 +16,12 @@ export default class StateModule {
     _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 +31,4 @@ export default class StateModule {
      */
     constructor(url: string, config: IConfig);
 }
+export {};

package/dist/base/stateModule.js

@@ -1,38 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
+// 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.
@@ -45,7 +16,7 @@ class StateModule {
      * @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, _v, _w, _x, _y, _z, _0, _1;
+        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.
@@ -64,71 +35,16 @@ class StateModule {
         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 = {
-            '400': undefined,
-            '401': undefined,
-            '403': undefined,
-            '404': undefined,
-            '429': undefined,
-            '500': undefined,
-            '502': undefined,
-            '503': undefined,
-            '504': undefined,
-        };
+        this.errorsFunctions = {};
         this.saveFunction = (_r = (_q = config.auth) === null || _q === void 0 ? void 0 : _q.saveFunction) !== null && _r !== void 0 ? _r : null;
-        if (config.errors) {
-            this.isShell = (_s = config.errors.isShell) !== null && _s !== void 0 ? _s : true;
-            if (config.errors.customErrors) {
-                this.errorsFunctions['400'] =
-                    (_t = config.errors.customErrors['400']) !== null && _t !== void 0 ? _t : undefined;
-                this.errorsFunctions['401'] =
-                    (_u = config.errors.customErrors['401']) !== null && _u !== void 0 ? _u : undefined;
-                this.errorsFunctions['403'] =
-                    (_v = config.errors.customErrors['403']) !== null && _v !== void 0 ? _v : undefined;
-                this.errorsFunctions['404'] =
-                    (_w = config.errors.customErrors['404']) !== null && _w !== void 0 ? _w : undefined;
-                this.errorsFunctions['429'] =
-                    (_x = config.errors.customErrors['429']) !== null && _x !== void 0 ? _x : undefined;
-                this.errorsFunctions['500'] =
-                    (_y = config.errors.customErrors['500']) !== null && _y !== void 0 ? _y : undefined;
-                this.errorsFunctions['502'] =
-                    (_z = config.errors.customErrors['502']) !== null && _z !== void 0 ? _z : undefined;
-                this.errorsFunctions['503'] =
-                    (_0 = config.errors.customErrors['503']) !== null && _0 !== void 0 ? _0 : undefined;
-                this.errorsFunctions['504'] =
-                    (_1 = config.errors.customErrors['504']) !== null && _1 !== void 0 ? _1 : undefined;
-            }
-        }
-        else {
-            this.isShell = true;
-        }
-        try {
-            if (typeof process === 'object' &&
-                +process.versions.node.split('.')[0] < 18) {
-                try {
-                    this._NO_FETCH = true;
-                    // Dynamically import https for older Node.js versions
-                    Promise.resolve().then(() => __importStar(require('https'))).then((https) => {
-                        this._https = https;
-                    })
-                        .catch(() => {
-                        this._https = null;
-                    });
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        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];
                 }
-                catch (e) {
-                    this._https = null;
-                }
-            }
-            else {
-                this._NO_FETCH = false;
-                this._https = null;
             }
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (e) {
-            this._NO_FETCH = false;
-            this._https = null;
         }
     }
 }

package/dist/base/syncModules.d.ts

@@ -40,6 +40,10 @@ export default abstract class SyncModules {
     protected _getFullPath(path: string): string;
     /**
      * Converts query parameters into a query string.
+     *
+     * Values are percent-encoded so free-text and special characters (spaces,
+     * `&`, `=`, non-ASCII) cannot corrupt the query string. Keys are known,
+     * machine-safe field names and are left as-is.
      * @param {IProductsQuery | IUploadingQuery | any} query - The query object containing key-value pairs.
      * @returns {string} A string representation of the query parameters.
      */

package/dist/base/syncModules.js

@@ -143,6 +143,10 @@ class SyncModules {
     }
     /**
      * Converts query parameters into a query string.
+     *
+     * Values are percent-encoded so free-text and special characters (spaces,
+     * `&`, `=`, non-ASCII) cannot corrupt the query string. Keys are known,
+     * machine-safe field names and are left as-is.
      * @param {IProductsQuery | IUploadingQuery | any} query - The query object containing key-value pairs.
      * @returns {string} A string representation of the query parameters.
      */
@@ -151,7 +155,7 @@ class SyncModules {
         // 0, false and '' are kept — they are semantically meaningful.
         return Object.keys(query)
             .filter((key) => query[key] !== null && query[key] !== undefined)
-            .map((key) => `${key}=${query[key]}`)
+            .map((key) => `${key}=${encodeURIComponent(query[key])}`)
             .join('&');
     }
     /**