oneentry 1.0.123 → 1.0.125

package/dist/base/asyncModules.js

@@ -5,7 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const syncModules_1 = __importDefault(require("./syncModules"));
 // import { IError } from './utils';
+/**
+ * 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 state - Instance of StateModule containing configuration and state data.
+     */
     constructor(state) {
         var _a;
         super(state);
@@ -15,162 +22,252 @@ class AsyncModules extends syncModules_1.default {
         this._https = (_a = state._https) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * fetchGet
-     *
-     * @param path
-     * @returns
+     * Performs an HTTP GET request.
+     * @param path - The path to append to the base URL.
+     * @return 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) => {
-                const req = this._https.get(this._getFullPath(path), options, (res) => {
-                    let data = '';
+                // 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) => {
-                        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', () => {
-                        resolve(JSON.parse(data));
+                        try {
+                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
+                            resolve(JSON.parse(responseData));
+                        }
+                        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);
                 });
             });
         }
     }
     /**
-     * fetchPost
-     *
-     * @param path
-     * @param data
-     * @returns
+     * Performs an HTTP POST request.
+     * @param path - The path to append to the base URL.
+     * @param data - The data to send in the request body.
+     * @return 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) => {
-                const req = this._https.request(this._getFullPath(path), options, (res) => {
-                    let responseData = '';
+                // 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
+                    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;
+                        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(data));
+                // End the request to signal that all data has been sent
                 req.end();
             });
         }
     }
     /**
-     * fetchPut
-     * @param path
-     * @param data
-     * @returns
+     * Performs an HTTP PUT request.
+     * @param path - The path to append to the base URL.
+     * @param data - The data to send in the request body.
+     * @return A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
      */
     async _fetchPut(path, data) {
+        // Create options for the PUT request using the 'makeOptions' method, including the data to be sent
         const options = this.makeOptions('PUT', 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) => {
-                const req = this._https.request(this._getFullPath(path), options, (res) => {
-                    let responseData = '';
+                // 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;
+                        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', () => {
-                        resolve(JSON.parse(responseData));
+                        try {
+                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
+                            resolve(JSON.parse(responseData));
+                        }
+                        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(data));
+                // End the request to signal that all data has been sent
                 req.end();
             });
         }
     }
     /**
-     * _fetchDelete
-     * @param path
-     * @param data
-     * @returns
+     * Performs an HTTP DELETE request.
+     * @param path - The path to append to the base URL.
+     * @param data - Optional data to send in the request body.
+     * @return A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async _fetchDelete(path, data) {
+        // Create options for the DELETE request using the 'makeOptions' method
         const options = this.makeOptions('DELETE');
+        // 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) => {
-                const req = this._https.delete(this._getFullPath(path), options, (res) => {
-                    let data = '';
+                // 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) => {
-                        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', () => {
-                        resolve(JSON.parse(data));
+                        try {
+                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
+                            resolve(JSON.parse(responseData));
+                        }
+                        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);
                 });
             });
         }
     }
     /**
-     * refreshToken
-     *
-     * @returns
+     * Refreshes the authentication token.
+     * @return 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() {
+        // Perform a fetch request to the specified URL to refresh the token
         const response = await fetch(this.state.url +
             `/api/content/users-auth-providers/marker/email/users/refresh`, {
+            // Use the POST method for the request
             method: 'POST',
+            // Set the necessary headers for the request
             headers: {
-                'Content-Type': 'application/json',
-                'x-app-token': this.state.token,
+                'Content-Type': 'application/json', // Indicate that the request body is in JSON format
+                'x-app-token': this.state.token, // Include the application token from the state
             },
+            // Send the current refresh token in the request body as a JSON string
             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;
         }
     }
     /**
-     * makeOptions
-     * @param method
-     * @param data
-     * @returns
+     * Creates options for HTTP requests.
+     * @param method - The HTTP method (GET, POST, PUT, DELETE, etc.).
+     * @param data - Optional data to include in the request body.
+     * @return An object representing the request options.
      */
     makeOptions(method, data) {
         const options = {
@@ -180,51 +277,82 @@ class AsyncModules extends syncModules_1.default {
                 '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;
     }
     /**
-     * browserResponse
-     * @param path
-     * @param options
-     * @returns
+     * Handles responses from the browser's fetch API.
+     * @param path - The path to append to the base URL.
+     * @param options - The options for the fetch request.
+     * @return 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 {
-                    return await response.json();
+                    // 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();
+                // Handle different HTTP status codes with corresponding error functions
                 if (status == 400) {
                     if (this.state.errorsFunctions && this.state.errorsFunctions['400']) {
                         this.state.errorsFunctions['400'](res);
@@ -250,6 +378,7 @@ class AsyncModules extends syncModules_1.default {
                         this.state.errorsFunctions['500'](res);
                     }
                 }
+                // Determine whether to return or throw the response based on 'isShell' state
                 if (this.state.isShell) {
                     return res;
                 }
@@ -259,6 +388,8 @@ class AsyncModules extends syncModules_1.default {
             }
         }
         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;
             }

package/dist/base/result.js

@@ -3,48 +3,63 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-restricted-syntax */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 class Result {
+    // Constructor that initializes the class with a given data, which can be of type Response or string.
     constructor(data) {
         this.body = data;
     }
+    // Asynchronously converts the body to a blob and returns the current instance.
     async blob() {
+        // Convert the body to a blob using the blob() method.
         this.body = await this.body.blob();
         return this;
     }
+    // Asynchronously parses the body as JSON and returns the current instance.
     async json() {
+        // Check if the body is a string, then parse it as JSON, otherwise call the json() method.
         this.body =
             (await typeof this.body) === 'string'
                 ? JSON.parse(this.body)
                 : this.body.json();
         return this;
     }
+    // Recursively removes language-specific data from the provided data or the body.
     makeDataWithoutLang(langCode, data) {
         if (data) {
+            // If data is an array, recursively process each item.
             if (Array.isArray(data)) {
                 return data.map((item) => this.makeDataWithoutLang(langCode, item));
             }
             else {
+                // Iterate through each key in the data object.
                 for (const key in data) {
+                    // If the value is an object containing the specified language code, replace it with the language-specific value.
                     if (typeof data[key] === 'object' &&
                         data[key] &&
                         langCode in data[key]) {
                         data[key] = data[key][langCode];
                     }
                     else if (typeof data[key] === 'object' && data[key] != null) {
+                        // If the value is an object, recursively process it
                         data[key] = this.makeDataWithoutLang(langCode, data[key]);
                     }
                     else if (Array.isArray(data[key])) {
+                        // If the value is an array, recursively process each item.
                         data[key] = data.map((item) => this.makeDataWithoutLang(langCode, item));
                     }
                 }
+                // Return the processed data.
                 return data;
             }
         }
         else {
+            // Process the body if no specific data is provided.
             if (Array.isArray(this.body)) {
                 this.body = this.body.map((item) => this.makeDataWithoutLang(langCode, item));
             }
             else {
+                // Iterate through each key in the body object.
                 for (const key in this.body) {
+                    // Similar processing as above but applied to the body.
                     if (typeof this.body[key] === 'object' &&
                         this.body[key] &&
                         langCode in this.body[key]) {
@@ -62,19 +77,24 @@ class Result {
             return this;
         }
     }
+    // Recursively simplifies arrays in the provided data or the body by removing single-element arrays.
     makeDataWithoutArray(data) {
         if (data) {
+            // If data is an array, recursively process each item.
             if (Array.isArray(data)) {
                 return data.map((item) => this.makeDataWithoutArray(item));
             }
             else {
+                // Iterate through each key in the data object.
                 for (const key in data) {
+                    // If the value is a single-element array, replace it with the element itself.
                     if (Array.isArray(data[key]) && data[key].length === 1) {
                         data[key] = data[key][0];
                     }
                     else if (typeof data[key] === 'object' &&
                         data[key] &&
                         !Array.isArray(data[key])) {
+                        // If the value is an object, recursively process it.
                         data[key] = this.makeDataWithoutArray(data[key]);
                     }
                 }
@@ -82,11 +102,14 @@ class Result {
             }
         }
         else {
+            // Process the body if no specific data is provided.
             if (Array.isArray(this.body)) {
                 return this.body.map((item) => this.makeDataWithoutArray(item));
             }
             else {
+                // Iterate through each key in the body object.
                 for (const key in this.body) {
+                    // Similar processing as above but applied to the body.
                     if (Array.isArray(this.body[key]) && this.body[key].length === 1) {
                         this.body[key] = this.body[key][0];
                     }