oneentry 1.0.122 → 1.0.123

package/dist/admins/adminsApi.js

@@ -11,7 +11,7 @@ const asyncModules_1 = __importDefault(require("../base/asyncModules"));
 class AdminsApi extends asyncModules_1.default {
     constructor(state) {
         super(state);
-        this._url = state.url + '/api/content/admins';
+        this._url = state.url + '/api/content/admins/all';
     }
     /**
      * Get all user objects - admins.

package/dist/base/asyncModules.js

@@ -208,10 +208,9 @@ class AsyncModules extends syncModules_1.default {
             if (response.ok) {
                 try {
                     return await response.json();
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 }
                 catch (e) {
-                    return;
+                    return e;
                 }
             }
             else {

package/dist/pages/pagesApi.d.ts

@@ -13,7 +13,7 @@ export default class PageApi extends AsyncModules implements IPageApi {
     /**
      * Get all top-level page objects.
      *
-     * @param {string} [langCode] - lang code
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all created pages without parents as an array of PageEntity objects or an empty array [] (if there is no data)
      */
@@ -21,7 +21,7 @@ export default class PageApi extends AsyncModules implements IPageApi {
     /**
      * Get all page objects with product information as an array.
      *
-     * @param {string} [langCode] - lang code
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all created pages as an array of PageEntity objects or an empty array [] (if there is no data)
      */
@@ -29,8 +29,8 @@ export default class PageApi extends AsyncModules implements IPageApi {
     /**
      * Get page object with information about forms, blocks, menus, linked to the page.
      *
-     * @param {number} [id] - Page object identifier
-     * @param {string} [langCode] - lang code
+     * @param {number} [id] - The unique identifier of the page to be fetched
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns PageEntity object
      */
@@ -47,8 +47,8 @@ export default class PageApi extends AsyncModules implements IPageApi {
     /**
      * Get child pages object with information as an array.
      *
-     * @param {string} [url] - Parent page URL
-     * @param {string} [langCode] - Required parameter lang code
+     * @param {string} [url] - The URL of the parent page for which child pages are to be fetched
+     * @param {string} [langCode] - Required parameter langCode. Default language code, using the current state if not provided
      *
      * @returns Returns all created pages as an array of PageEntity objects or an empty array [] (if there is no data) for the selected parent
      */
@@ -65,8 +65,8 @@ export default class PageApi extends AsyncModules implements IPageApi {
     /**
      * Get all forms by page url.
      *
-     * @param {string} [url] - Page URL
-     * @param {string} [langCode] - lang code
+     * @param {string} [url] - The URL of the page for which forms are to be fetched
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all forms as an array of PositionForm objects or an empty array [] (if there is no data) for the selected parent
      */
@@ -83,19 +83,19 @@ export default class PageApi extends AsyncModules implements IPageApi {
      * Quick search for page objects with limited output.
      *
      * @param {string} [name] - Text for searching page objects (search is performed on the title field of the localizeInfos object with the language taken into account)
-     * @param {string} [langCode] - lang code
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all created pages as an array of PageEntity objects or an empty array [] (if there is no data)
      */
     searchPage(name: string, langCode?: string): Promise<Array<IPagesEntity> | IError>;
     /**
-     * addTemplateToPages
+     * Add template data to pages
      * @param data
      * @returns
      */
     protected addTemplateToPages(data: IPagesEntity[]): Promise<IPagesEntity[]>;
     /**
-     * addTemplateToPage by page templateIdentifier
+     * Add template data to page by page templateIdentifier
      * @param data - page object
      * @returns
      */

package/dist/pages/pagesApi.js

@@ -18,39 +18,48 @@ class PageApi extends asyncModules_1.default {
     /**
      * Get all top-level page objects.
      *
-     * @param {string} [langCode] - lang code
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all created pages without parents as an array of PageEntity objects or an empty array [] (if there is no data)
      */
     async getRootPages(langCode = this.state.lang) {
+        // Fetch data from the server using a GET request to retrieve root pages for the specified language code
         const data = await this._fetchGet(`/root?langCode=${langCode}`);
-        const result = await this.addTemplateToPages(data);
-        return this._normalizeData(result, langCode);
+        // Add template information to each page in the fetched root pages data
+        const withTemplate = await this.addTemplateToPages(data);
+        // Normalize the data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
      * Get all page objects with product information as an array.
      *
-     * @param {string} [langCode] - lang code
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all created pages as an array of PageEntity objects or an empty array [] (if there is no data)
      */
     async getPages(langCode = this.state.lang) {
+        // Fetch data from the server using a GET request to retrieve all pages for the specified language code
         const data = await this._fetchGet(`?langCode=${langCode}`);
-        const result = await this.addTemplateToPages(data);
-        return this._normalizeData(result, langCode);
+        // Add template information to each page in the fetched data
+        const withTemplate = await this.addTemplateToPages(data);
+        // Normalize the data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
      * Get page object with information about forms, blocks, menus, linked to the page.
      *
-     * @param {number} [id] - Page object identifier
-     * @param {string} [langCode] - lang code
+     * @param {number} [id] - The unique identifier of the page to be fetched
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns PageEntity object
      */
     async getPageById(id, langCode = this.state.lang) {
+        // Fetch data from the server using a GET request to retrieve page details by ID and language code
         const data = await this._fetchGet(`/${id}?langCode=${langCode}`);
-        const result = await this.addTemplateToPage(data);
-        return this._normalizeData(result, langCode);
+        // Add template information to the fetched page data
+        const withTemplate = await this.addTemplateToPage(data);
+        // Normalize the data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
      * Get page object with information about forms, blocks, menus, linked to the page by URL.
@@ -61,22 +70,28 @@ class PageApi extends asyncModules_1.default {
      * @returns Returns PageEntity object
      */
     async getPageByUrl(url, langCode = this.state.lang) {
+        // Fetch data from the server using a GET request with the specified URL and language code
         const data = await this._fetchGet(`/url/${url}?langCode=${langCode}`);
-        const result = await this.addTemplateToPage(data);
-        return this._normalizeData(result, langCode);
+        // Add template information to the fetched page data
+        const withTemplate = await this.addTemplateToPage(data);
+        // Normalize the result data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
      * Get child pages object with information as an array.
      *
-     * @param {string} [url] - Parent page URL
-     * @param {string} [langCode] - Required parameter lang code
+     * @param {string} [url] - The URL of the parent page for which child pages are to be fetched
+     * @param {string} [langCode] - Required parameter langCode. Default language code, using the current state if not provided
      *
      * @returns Returns all created pages as an array of PageEntity objects or an empty array [] (if there is no data) for the selected parent
      */
     async getChildPagesByParentUrl(url, langCode = this.state.lang) {
+        // Fetch data from the server using a GET request to retrieve child pages for the specified parent URL and language code
         const data = await this._fetchGet(`/${url}/children?langCode=${langCode}`);
-        const result = await this.addTemplateToPages(data);
-        return this._normalizeData(result, langCode);
+        // Add template information to each of the fetched child pages
+        const withTemplate = await this.addTemplateToPages(data);
+        // Normalize the result data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
      * Get all blocks by page url.
@@ -88,37 +103,52 @@ class PageApi extends asyncModules_1.default {
      */
     async getBlocksByPageUrl(url, langCode = this.state.lang) {
         const response = await this._fetchGet(`/${url}/blocks?langCode=${langCode}`);
+        // Normalize the fetched response data
         const normalizeResponse = this._normalizeData(response);
+        // Iterate over each item in the normalized response
         normalizeResponse.map((item) => {
             const customSettings = item.customSettings;
+            // Check if customSettings contains 'productConfig' property
             // eslint-disable-next-line no-prototype-builtins
             if (customSettings && customSettings.hasOwnProperty('productConfig')) {
+                // If 'countElementsPerRow' exists, set it on the item
                 if (customSettings.productConfig.countElementsPerRow)
                     item.countElementsPerRow =
                         +customSettings.productConfig.countElementsPerRow;
+                // If 'quantity' exists, set it on the item
                 if (customSettings.productConfig.quantity)
                     item.quantity = +customSettings.productConfig.quantity;
             }
+            // Remove unnecessary properties from the item
             delete item.customSettings;
             delete item.attributesSetIdentifier;
+            // Return the modified item
             return item;
         });
+        // Check if traffic limit is not set
         if (!this.state.traficLimit) {
+            // Define a class 'StaffModule' extending 'AsyncModules'
             class StaffModule extends asyncModules_1.default {
                 constructor(state) {
-                    super(state);
-                    this._url = state.url + '/api/content/blocks';
+                    super(state); // Call parent constructor
+                    this._url = state.url + '/api/content/blocks'; // Set URL for content blocks
                 }
+                // Method to fetch similar products by marker
                 async getSimilarProducts(marker, langCode = this.state.lang, offset = 0, limit = 30) {
+                    // Fetch similar products from the server
                     const result = await this._fetchGet(`/${marker}/similar-products?langCode=${langCode}&offset=${offset}&limit=${limit}`);
                     return this._normalizeData(result.items);
                 }
+                // Method to fetch products by block marker
                 async getProductsByBlockMarker(marker, langCode = this.state.lang, offset = 0, limit = 30) {
+                    // Fetch products from the server
                     const result = await this._fetchGet(`/${marker}/products?langCode=${langCode}&offset=${offset}&limit=${limit}`);
                     return this._normalizeData(result.items);
                 }
             }
+            // Create an instance of 'StaffModule' with the current state
             const staffModule = new StaffModule(this.state);
+            // If the block type is 'similar_products_block', fetch similar products
             if (normalizeResponse.type === 'similar_products_block') {
                 try {
                     await staffModule
@@ -128,8 +158,10 @@ class PageApi extends asyncModules_1.default {
                     });
                 }
                 catch {
+                    // Handle errors by setting an empty array
                     normalizeResponse.similarProducts = [];
                 }
+                // If the block type is 'product_block', fetch products
             }
             else if (normalizeResponse.type === 'product_block') {
                 try {
@@ -140,23 +172,27 @@ class PageApi extends asyncModules_1.default {
                     });
                 }
                 catch {
+                    // Handle errors by setting an empty array
                     normalizeResponse.products = [];
                 }
             }
         }
+        // Return the final normalized response
         return this._normalizeData(normalizeResponse);
     }
     /**
      * Get all forms by page url.
      *
-     * @param {string} [url] - Page URL
-     * @param {string} [langCode] - lang code
+     * @param {string} [url] - The URL of the page for which forms are to be fetched
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all forms as an array of PositionForm objects or an empty array [] (if there is no data) for the selected parent
      */
     async getFormsByPageUrl(url, langCode = this.state.lang) {
-        const result = await this._fetchGet(`/${url}/forms?langCode=${langCode}`);
-        return this._normalizeData(result, langCode);
+        // Fetch data from the server using a GET request to retrieve forms for the specified page URL and language code
+        const withTemplate = await this._fetchGet(`/${url}/forms?langCode=${langCode}`);
+        // Normalize the fetched result data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
      * Get settings for the page.
@@ -166,60 +202,89 @@ class PageApi extends asyncModules_1.default {
      * @returns Returns a ConfigPage object with page display settings
      */
     async getConfigPageByUrl(url) {
+        // Fetch data from the server using a GET request to retrieve forms for the specified page URL and language code
         const result = await this._fetchGet(`/${url}/config`);
+        // return fetched data
         return result;
     }
     /**
      * Quick search for page objects with limited output.
      *
      * @param {string} [name] - Text for searching page objects (search is performed on the title field of the localizeInfos object with the language taken into account)
-     * @param {string} [langCode] - lang code
+     * @param {string} [langCode] - Default language code, using the current state if not provided
      *
      * @returns Returns all created pages as an array of PageEntity objects or an empty array [] (if there is no data)
      */
     async searchPage(name, langCode = this.state.lang) {
+        // Fetch data from the server using a GET request to perform a quick search by page name and language code
         const data = await this._fetchGet(`/quick/search?lang=${langCode}&name=${name}`);
+        // Check if there is no traffic limit set in the state
         if (!this.state.traficLimit) {
+            // Initialize an empty array to store detailed page information
             const pageList = [];
+            // Use Promise.all to fetch detailed information for each page concurrently
             await Promise.all(data.map(async (page) => {
+                // Fetch detailed page information by page ID and push it to pageList
                 await this.getPageById(page.id, langCode).then((result) => {
                     pageList.push(result);
                 });
             }));
-            const result = await this.addTemplateToPages(pageList);
-            return this._dataPostProcess(result, langCode);
+            // Add templates to the fetched pages
+            const withTemplate = await this.addTemplateToPages(pageList);
+            // Post-process the data and return it; ensures consistent structure or handles errors
+            return this._dataPostProcess(withTemplate, langCode);
         }
-        const result = await this.addTemplateToPages(data);
-        return this._normalizeData(result, langCode);
+        // If there is a traffic limit, add templates to the initially fetched data without fetching detailed information
+        const withTemplate = await this.addTemplateToPages(data);
+        // Normalize the data and return it; ensures consistent structure or handles errors
+        return this._normalizeData(withTemplate, langCode);
     }
     /**
-     * addTemplateToPages
+     * Add template data to pages
      * @param data
      * @returns
      */
     async addTemplateToPages(data) {
+        // Use Promise.all to handle an array of promises returned by mapping over 'data'
         return Promise.all(data.map(async (d) => {
+            // For each element 'd' in the 'data' array, call 'addTemplateToPage'
             const result = await this.addTemplateToPage(d);
+            // Return the result of 'addTemplateToPage' for the current element
             return result;
         }));
     }
     /**
-     * addTemplateToPage by page templateIdentifier
+     * Add template data to page by page templateIdentifier
      * @param data - page object
      * @returns
      */
     async addTemplateToPage(data) {
-        if ('templateIdentifier' in data && data.templateIdentifier) {
-            // Create an instance of templatesApi with the current state
-            const Templates = new templatesApi_1.default(this.state);
-            // get template by marker
-            const result = await Templates.getTemplateByMarker('template');
-            return {
-                ...data,
-                template: result,
-            };
+        // Check if 'templateIdentifier' exists in 'data' and is not null or an empty string
+        if ('templateIdentifier' in data &&
+            data.templateIdentifier !== null &&
+            data.templateIdentifier !== '') {
+            // Destructure 'templateIdentifier' from 'data'
+            const { templateIdentifier } = data;
+            try {
+                // Create a new instance of templatesApi with the current state
+                const Templates = new templatesApi_1.default(this.state);
+                // Fetch the template using the 'templateIdentifier'
+                const result = await Templates.getTemplateByMarker(templateIdentifier);
+                // Return the original data object with the fetched template added
+                return {
+                    ...data,
+                    template: result,
+                };
+            }
+            catch (error) {
+                // Log any errors that occur during the template fetching process
+                console.error('Template fetch error: ', error);
+                // Return the original data object unchanged if an error occurs
+                return data;
+            }
         }
         else {
+            // If 'templateIdentifier' doesn't exist or is invalid, return the original data
             return data;
         }
     }

package/dist/templates-preview/templatesPreviewInterfaces.d.ts

@@ -30,7 +30,7 @@ interface ITemplatesPreviewEntity {
     identifier: string;
     attributeValues: AttributeType;
     attributeSetIdentifier?: string | null;
-    proportion: {
+    proportions: {
         horizontal: IProportion | null;
         vertical: IProportion | null;
         square: ISquare;
@@ -47,8 +47,8 @@ interface ITemplatesPreviewEntity {
  * @property {string} alignmentType -
  */
 interface IProportion {
-    width: string | number | null;
-    height: string | number | null;
+    width: number | null;
+    height: number | null;
     marker: string;
     alignmentType: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oneentry",
-  "version": "1.0.122",
+  "version": "1.0.123",
   "description": "OneEntry NPM package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,19 +45,19 @@
     "@jest/globals": "^29.7.0",
     "@types/eslint-config-prettier": "^6.11.3",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.15.17",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
+    "@types/node": "^22.15.29",
+    "@typescript-eslint/eslint-plugin": "^8.33.1",
+    "@typescript-eslint/parser": "^8.33.1",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jest": "^28.11.0",
-    "eslint-plugin-prettier": "^5.4.0",
+    "eslint-plugin-jest": "^28.12.0",
+    "eslint-plugin-prettier": "^5.4.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "jest": "^29.7.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.5.3",
-    "ts-jest": "^29.3.2",
+    "ts-jest": "^29.3.4",
     "typescript": "^5.8.3"
   }
 }