oneentry 1.0.124 → 1.0.125

package/dist/base/asyncModules.js

@@ -25,31 +25,45 @@ class AsyncModules extends syncModules_1.default {
      * 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');
-        // console.log(this._NO_FETCH);
+        // 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 responseData = '';
+                // 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;
+                        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);
                 });
             });
@@ -60,33 +74,50 @@ class AsyncModules extends syncModules_1.default {
      * @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();
             });
         }
@@ -96,33 +127,50 @@ class AsyncModules extends syncModules_1.default {
      * @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', () => {
                         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();
             });
         }
@@ -132,31 +180,46 @@ class AsyncModules extends syncModules_1.default {
      * @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 responseData = '';
+                // 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;
+                        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);
                 });
             });
@@ -165,33 +228,44 @@ class AsyncModules extends syncModules_1.default {
     /**
      * 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;
         }
     }
     /**
      * Creates options for HTTP requests.
-     * @param method - The HTTP method (GET, POST, etc.).
+     * @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.
      */
@@ -203,18 +277,33 @@ 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;
@@ -224,32 +313,46 @@ class AsyncModules extends syncModules_1.default {
      * @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 {
+                    // 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) : {};
-                    // return await response.json();
+                    // 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);
@@ -275,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;
                 }
@@ -284,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];
                     }

package/dist/base/syncModules.d.ts

@@ -107,4 +107,8 @@ export default abstract class SyncModules {
      * @return The instance of SyncModules for chaining.
      */
     setRefreshToken(refreshToken: string): this;
+    /**
+     * Get deviceMetadata
+     */
+    protected _getDeviceMetadata(): string;
 }

package/dist/base/syncModules.js

@@ -269,7 +269,7 @@ class SyncModules {
                 // add timeIntervals
                 if (data.attributeValues[attr].type === 'timeInterval') {
                     const schedules = data.attributeValues[attr].value;
-                    // console.log(JSON.stringify(schedules));
+                    // console.log('Schedules: ', JSON.stringify(schedules));
                     if (Array.isArray(schedules) && schedules.length > 0) {
                         const result = this._addTimeIntervalsToSchedules(schedules);
                         data.attributeValues[attr].value = result;
@@ -292,6 +292,7 @@ class SyncModules {
                 // Add time intervals
                 if (d[attr].type === 'timeInterval') {
                     // const schedules = d[attr].localizeInfos.intervals;
+                    // console.log('Schedules:: ', JSON.stringify(schedules));
                     // if (Array.isArray(schedules) && schedules.length > 0) {
                     //   const result = this._addTimeIntervalsToSchedulesForm(schedules);
                     //   d[attr].localizeInfos.intervals = result;
@@ -334,5 +335,22 @@ class SyncModules {
         this.state.refreshToken = refreshToken;
         return this;
     }
+    /**
+     * Get deviceMetadata
+     */
+    _getDeviceMetadata() {
+        const platform = navigator.platform;
+        const userAgent = navigator.userAgent;
+        const language = navigator.language;
+        const deviceMetadata = {
+            fingerprint: 'abc123-fp',
+            deviceInfo: {
+                os: platform,
+                browser: userAgent,
+                location: language,
+            },
+        };
+        return JSON.stringify(deviceMetadata);
+    }
 }
 exports.default = SyncModules;

package/dist/base/utils.d.ts

@@ -84,7 +84,7 @@ interface IAttributeValues {
 interface IAttributeValue {
     [key: string]: any;
 }
-type AttributeType = IAttributeValues | IAttributeValue;
+type AttributeType = IAttributeValue | IAttributeValues;
 type LangType = string | Array<string>;
 type LocalizeType = ILocalizeInfos | ILocalizeInfo;
 interface IError {

package/dist/blocks/blocksApi.d.ts

@@ -21,30 +21,26 @@ export default class BlocksApi extends AsyncModules implements IBlocks {
      *
      * @handleName getBlocks
      *
-     * @param {BlockType} type - Available values : product | error_page | catalog_page | product_preview | similar_products_block | product_block | form | common_page | common_block | order | none. Example: 'product'.
+     * @param {BlockType} type - Available values: "product" | "error_page" | "catalog_page" | "product_preview" | "similar_products_block" | "product_block" | "form" | "common_page" | "common_block" | "order" | "service" | "none". Example: 'product'.
      * @param {string} [langCode] - Language code. Default: "en_US".
      * @param {number} [offset] - Parameter for pagination. Default: 0.
      * @param {number} [limit] - Parameter for pagination. Default: 30.
-     *
      * @return {IBlocksResponse} Returns BlocksEntity object.
      * @throws {IError} - If there is an error during the fetch operation, it will return an error object.
-     *
      * @description This method requires user authorization. For more information about configuring the authorization module, see the documentation in the configuration settings section of the SDK.
      */
-    getBlocks(type: BlockType, langCode?: string, offset?: number, limit?: number): Promise<IBlocksResponse | IError>;
+    getBlocks(type?: BlockType, langCode?: string, offset?: number, limit?: number): Promise<IBlocksResponse | IError>;
     /**
      * Get block by marker.
      *
      * @handleName getBlockByMarker
      *
-     * @param {string} marker - Marker of Block. Example: 'product_block'.
+     * @param {string} marker - Marker of Block. Example: "product_block".
      * @param {string} [langCode] - Language code. Default: "en_US".
      * @param {number} [offset] - Parameter for pagination. Default: 0.
      * @param {number} [limit] - Parameter for pagination. Default: 30.
-     *
      * @return {IBlockEntity} - Returns a BlockEntity object.
      * @throws {IError} - If there is an error during the fetch operation, it will return an error object.
-     *
      * @description This method retrieves a block by its marker and includes additional information such as similar products or products associated with the block.
      */
     getBlockByMarker(marker: string, langCode?: string, offset?: number, limit?: number): Promise<IBlockEntity | IError>;
@@ -53,14 +49,12 @@ export default class BlocksApi extends AsyncModules implements IBlocks {
      *
      * @handleName getSimilarProducts
      *
-     * @param {string} marker - Block identifier. Example: 'similar_products_block'.
+     * @param {string} marker - Block identifier. Example: "similar_products_block".
      * @param {string} [langCode] - Language code. Default: "en_US".
      * @param {number} [offset] - Parameter for pagination. Default: 0.
      * @param {number} [limit] - Parameter for pagination. Default: 30.
-     *
      * @return {IProductsResponse} - Returns the total count and an array of product items in object by specified block marker.
      * @throws {IError} - If there is an error during the fetch operation, it will return an error object.
-     *
      * @description This method requires user authorization. For more information about configuring the authorization module, see the documentation in the configuration settings section of the SDK.
      */
     private getSimilarProducts;
@@ -69,14 +63,12 @@ export default class BlocksApi extends AsyncModules implements IBlocks {
      *
      * @handleName getProductsByBlockMarker
      *
-     * @param {string} marker - Block identifier. Example: 'product_block'.
+     * @param {string} marker - Block identifier. Example: "product_block".
      * @param {string} [langCode] - Language code. Default: "en_US".
      * @param {number} [offset] - Parameter for pagination. Default: 0.
      * @param {number} [limit] - Parameter for pagination. Default: 30.
-     *
      * @return {IProductsEntity[]} Return array of BlocksEntity object.
      * @throws {IError} - If there is an error during the fetch operation, it will return an error object.
-     *
      * @description This method requires user authorization. For more information about configuring the authorization module, see the documentation in the configuration settings section of the SDK.
      */
     private getProductsByBlockMarker;
@@ -85,13 +77,11 @@ export default class BlocksApi extends AsyncModules implements IBlocks {
      *
      * @handleName searchBlock
      *
-     * @param {string} name - Search string. Example: 'product_block'.
+     * @param {string} name - Search string. Example: "product_block".
      * @param {string} [langCode] - Language code. Default: "en_US".
-     *
      * @return {ISearchBlock[]} Returns an array of ISearchBlock objects.
      * @throws {IError} - If there is an error during the fetch operation, it will return an error object.
-     *
      * @description This method requires user authorization. For more information about configuring the authorization module, see the documentation in the configuration settings section of the SDK.
      */
-    searchBlock(name: string, langCode?: string): Promise<Array<ISearchBlock> | IError>;
+    searchBlock(name: string, langCode?: string): Promise<ISearchBlock[] | IError>;
 }