oneentry 1.0.153 → 1.0.154

package/changelog.md

@@ -1,5 +1,42 @@
 # SDK Change Log
 
+## 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/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.
@@ -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('&');
     }
     /**