oneentry 1.0.141 → 1.0.142

package/dist/base/asyncModules.d.ts

@@ -1,80 +0,0 @@
-import type { z } from 'zod';
-import type StateModule from './stateModule';
-import SyncModules from './syncModules';
-import type { IError } from './utils';
-/**
- * Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
- * @description Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
- */
-export default abstract class AsyncModules extends SyncModules {
-    protected state: StateModule;
-    protected _NO_FETCH: boolean;
-    protected _https: any;
-    protected _url: string;
-    /**
-     * Constructor initializes the AsyncModules with a given state.
-     * @param {StateModule} state - Instance of StateModule containing configuration and state data.
-     * @description Constructor initializes the AsyncModules with a given state.
-     */
-    protected constructor(state: StateModule);
-    /**
-     * Validates API response against a Zod schema (optional)
-     * @param {unknown} data - The data to validate
-     * @param {z.ZodSchema<T>} [schema] - Optional Zod schema for validation
-     * @returns {T | IError} Validated data or error object
-     * @description Validates response data if validation is enabled in config
-     */
-    protected _validateResponse<T>(data: unknown, schema?: z.ZodSchema<T>): T | IError;
-    /**
-     * Performs an HTTP GET request.
-     * @param {string} path - The path to append to the base URL.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchGet' that performs a GET request
-     */
-    protected _fetchGet<T = unknown>(path: string): Promise<T>;
-    /**
-     * Performs an HTTP POST request.
-     * @param {string} path   - The path to append to the base URL.
-     * @param {unknown} [data] - The data to send in the request body.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchPost' that performs a POST request
-     */
-    protected _fetchPost<T = unknown>(path: string, data?: unknown): Promise<T>;
-    /**
-     * Performs an HTTP PUT request.
-     * @param {string} path - The path to append to the base URL.
-     * @param {unknown} body - The data to send in the request body.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
-     */
-    protected _fetchPut<T = unknown>(path: string, body: unknown): Promise<T>;
-    /**
-     * Performs an HTTP DELETE request.
-     * @param {string} path - The path to append to the base URL.
-     * @param {unknown} body - The body of the request.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
-     */
-    protected _fetchDelete<T = unknown>(path: string, body?: unknown): Promise<T>;
-    /**
-     * Refreshes the authentication token.
-     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
-     * @description Define an asynchronous method 'refreshToken' that attempts to refresh the authentication token
-     */
-    protected refreshToken(): Promise<boolean>;
-    /**
-     * Creates options for HTTP requests.
-     * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
-     * @param {unknown} data - Optional data to include in the request body.
-     * @returns {IHttpOptions} An object representing the request options.
-     */
-    private makeOptions;
-    /**
-     * Handles responses from the browser's fetch API.
-     * @param {string} path - The path to append to the base URL.
-     * @param {IHttpOptions} options - The options for the fetch request.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define an asynchronous method 'browserResponse' that takes a path and options as parameters
-     */
-    private browserResponse;
-}

package/dist/base/asyncModules.js

@@ -1,440 +0,0 @@
-"use strict";
-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");
-/**
- * Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
- * @description Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
- */
-class AsyncModules extends syncModules_1.default {
-    /**
-     * Constructor initializes the AsyncModules with a given state.
-     * @param {StateModule} state - Instance of StateModule containing configuration and state data.
-     * @description Constructor initializes the AsyncModules with a given state.
-     */
-    constructor(state) {
-        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)
-     * @param {unknown} data - The data to validate
-     * @param {z.ZodSchema<T>} [schema] - Optional Zod schema for validation
-     * @returns {T | IError} Validated data or error object
-     * @description Validates response data if validation is enabled in config
-     */
-    _validateResponse(data, schema) {
-        // Skip validation if not enabled or no schema provided
-        if (!this.state.validationEnabled || !schema) {
-            return data;
-        }
-        // Use strict or safe validation based on config
-        if (this.state.validationStrictMode) {
-            const result = (0, validation_1.validateResponse)(schema, data, {
-                logErrors: this.state.validationLogErrors,
-            });
-            if (!result.success) {
-                // Return error object compatible with IError interface
-                return {
-                    statusCode: 422,
-                    message: 'Response validation failed',
-                    pageData: null,
-                    timestamp: new Date().toISOString(),
-                    localizeMessage: result.error.issues
-                        .map((e) => `${e.path.join('.')}: ${e.message}`)
-                        .join(', '),
-                    validationErrors: result.error.issues,
-                };
-            }
-            return result.data;
-        }
-        else {
-            // Non-strict mode: log errors but return original data
-            return (0, validation_1.validateResponseSafe)(schema, data, this.state.validationLogErrors);
-        }
-    }
-    /**
-     * Performs an HTTP GET request.
-     * @param {string} path - The path to append to the base URL.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchGet' that performs a GET request
-     */
-    async _fetchGet(path) {
-        // 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);
-                });
-            });
-        }
-    }
-    /**
-     * Performs an HTTP POST request.
-     * @param {string} path   - The path to append to the base URL.
-     * @param {unknown} [data] - The data to send in the request body.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchPost' that performs a POST request
-     */
-    async _fetchPost(path, data) {
-        // 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();
-            });
-        }
-    }
-    /**
-     * Performs an HTTP PUT request.
-     * @param {string} path - The path to append to the base URL.
-     * @param {unknown} body - The data to send in the request body.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
-     */
-    async _fetchPut(path, body) {
-        // 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();
-            });
-        }
-    }
-    /**
-     * Performs an HTTP DELETE request.
-     * @param {string} path - The path to append to the base URL.
-     * @param {unknown} body - The body of the request.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
-     */
-    async _fetchDelete(path, body) {
-        // 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);
-                });
-            });
-        }
-    }
-    /**
-     * Refreshes the authentication token.
-     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
-     * @description Define an asynchronous method 'refreshToken' that attempts to refresh the authentication token
-     */
-    async refreshToken() {
-        const url = this.state.url +
-            `/api/content/users-auth-providers/marker/` +
-            this.state.providerMarker +
-            `/users/refresh`;
-        /**
-         * Perform a fetch request to the specified URL to refresh the token
-         * @param {string} url - The URL to which the request will be sent
-         * @param {object} options - The options for the fetch request
-         * @param {string} options.method - The HTTP method to use for the request (default: 'POST')
-         * @param {object} options.headers - Set the necessary headers for the request
-         * @param {object} options.body - Send the current refresh token in the request body as a JSON string
-         */
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                // Indicate that the request body is in JSON format
-                'Content-Type': 'application/json',
-                // Include the application token from the state
-                'x-app-token': this.state.token,
-                // Include the device fingerprint
-                'x-device-metadata': this._getDeviceMetadata(),
-            },
-            body: JSON.stringify({ refreshToken: this.state.refreshToken }),
-        });
-        // Check if the response status is OK (status code 200-299)
-        if (response.ok) {
-            // Parse the response body as JSON and store the result
-            const result = await response.json();
-            // Update the state's refreshToken and accessToken with the new tokens from the response
-            this.state.refreshToken = result.refreshToken;
-            this.state.accessToken = result.accessToken;
-            // If a save function is defined in the state, call it with the new refresh token
-            if (this.state.saveFunction) {
-                this.state.saveFunction(result.refreshToken);
-            }
-            // Return true to indicate that the token refresh was successful
-            return true;
-        }
-        else {
-            // Return false to indicate that the token refresh failed
-            return false;
-        }
-    }
-    /**
-     * Creates options for HTTP requests.
-     * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
-     * @param {unknown} data - Optional data to include in the request body.
-     * @returns {IHttpOptions} An object representing the request options.
-     */
-    makeOptions(method, data) {
-        const options = {
-            method: method,
-            headers: {
-                'Content-Type': 'application/json',
-                'x-app-token': this.state.token,
-            },
-        };
-        // if method = 'POST' add x-device-metadata
-        if (method === 'POST') {
-            options.headers = {
-                ...options.headers,
-                'x-device-metadata': this._getDeviceMetadata(),
-            };
-        }
-        // Check if 'data' is an instance of FormData or Blob
-        if (data instanceof FormData || data instanceof Blob) {
-            // Remove the 'Content-Type' header from options.headers
-            delete options.headers['Content-Type'];
-            // Set the 'accept' header to 'application/json', while preserving existing headers
-            options.headers = {
-                ...options.headers,
-                accept: 'application/json',
-            };
-            // Assign 'data' to options.body for sending as request payload
-            options.body = data;
-        }
-        else if (data) {
-            // If 'data' exists and is not FormData or Blob, convert it to a JSON string
-            // and assign it to options.body
-            options.body = JSON.stringify(data);
-        }
-        // Check if there is an access token available in the state
-        if (this.state.accessToken) {
-            // Add an 'Authorization' header with the Bearer token to options.headers
-            options.headers['Authorization'] = 'Bearer ' + this.state.accessToken;
-        }
-        return options;
-    }
-    /**
-     * Handles responses from the browser's fetch API.
-     * @param {string} path - The path to append to the base URL.
-     * @param {IHttpOptions} options - The options for the fetch request.
-     * @returns {Promise<T>} A promise resolving to the response data.
-     * @description Define an asynchronous method 'browserResponse' that takes a path and options as parameters
-     */
-    async browserResponse(path, options) {
-        try {
-            // Perform a fetch request using the full URL obtained from '_getFullPath' and the provided options
-            const 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;
-                }
-            }
-            else {
-                // Handle non-OK responses
-                // Check if the status is 401 (Unauthorized) and custom authentication is not used
-                if (response.status === 401 && !this.state.customAuth) {
-                    // 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;
-                }
-            }
-        }
-        catch (e) {
-            // Handle any errors that occur during the fetch process
-            // Determine whether to return or throw the error based on 'isShell' state
-            if (this.state.isShell) {
-                return e;
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-}
-exports.default = AsyncModules;

package/dist/base/result.d.ts

@@ -1,39 +0,0 @@
-/**
- * Result class for handling response data.
- * @description Result class for handling response data.
- */
-export default class Result {
-    body: any;
-    /**
-     * Constructor that initializes the class with a given data.
-     * @param {Response | string} data - Response or string data.
-     * @description Constructor that initializes the class with a given data, which can be of type Response or string.
-     */
-    constructor(data: Response | string);
-    /**
-     * Asynchronously converts the body to a blob and returns the current instance.
-     * @returns {Promise<Result>} Current instance.
-     * @description Asynchronously converts the body to a blob and returns the current instance.
-     */
-    blob(): Promise<Result>;
-    /**
-     * Asynchronously parses the body as JSON and returns the current instance.
-     * @returns {Promise<Result>} Current instance.
-     * @description Asynchronously parses the body as JSON and returns the current instance.
-     */
-    json(): Promise<Result>;
-    /**
-     * Recursively removes language-specific data from the provided data or the body.
-     * @param {string} langCode - Language code.
-     * @param {any} [data] - Data to process.
-     * @returns {any} Processed data.
-     * @description Recursively removes language-specific data from the provided data or the body.
-     */
-    makeDataWithoutLang(langCode: string, data?: any): any;
-    /**
-     * Recursively simplifies arrays in the provided data or the body by removing single-element arrays.
-     * @param {any} data - The data to simplify.
-     * @returns {any} The simplified data.
-     */
-    makeDataWithoutArray(data?: any): any;
-}