idosell 0.4.18 → 0.4.20

package/changelog.md

@@ -5,12 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.20] - 2025-12-18
+- Added indexing option for utils functions
+- Fixed typings and tests
+- Added descriptions
+
 ## [0.4.18] - 2025-12-18
 - Updated to v7.10
 - Updated utils
 - Fixed dates helper default value
 - Improved typing on empty PHP objects conversion
-- Updated axios
+- Updated axios version
 
 ## [0.4.13] - 2025-10-15
 ### Changed

package/dist/enums.d.ts

@@ -379,15 +379,16 @@ export enum PRODUCT_SIZE_COUNTABLE {
     QUANTITY_OWN = 'productSizeQuantityOwnStock',
     QUANTITY_OUTSIDE = 'productSizeQuantityOutsideStock',
     QUANTITY_ALL = 'productSizeQuantityAllStocks',
-    QUANTITY_ORDERS_UNFINISHED = 'productOrdersUnfinishedQuantities',
+    QUANTITY_UNFINISHED = 'productOrdersUnfinishedQuantities',
     DELIVERIES = 'productSizesDeliveries',
     AUCTIONS = 'productSizesDispositionsInAuctions',
+    RESERVATIONS = 'productSizeReservationOrder'
 }
 
 export enum PRODUCT_SIZE_CODES {
     NAME = 'sizePanelName',
     CODE_PRODUCER = 'productSizeCodeProducer',
-    CODE_EXTERNAL = 'productSizeCodeExternal',
+    CODE_EXTERNAL = 'productSizeCodeExternal'
 }
 
 export enum PRODUCT_SIZE_LOCATIONS {

package/dist/enums.js

@@ -380,9 +380,10 @@ var PRODUCT_SIZE_COUNTABLE;
     PRODUCT_SIZE_COUNTABLE["QUANTITY_OWN"] = "productSizeQuantityOwnStock";
     PRODUCT_SIZE_COUNTABLE["QUANTITY_OUTSIDE"] = "productSizeQuantityOutsideStock";
     PRODUCT_SIZE_COUNTABLE["QUANTITY_ALL"] = "productSizeQuantityAllStocks";
-    PRODUCT_SIZE_COUNTABLE["QUANTITY_ORDERS_UNFINISHED"] = "productOrdersUnfinishedQuantities";
+    PRODUCT_SIZE_COUNTABLE["QUANTITY_UNFINISHED"] = "productOrdersUnfinishedQuantities";
     PRODUCT_SIZE_COUNTABLE["DELIVERIES"] = "productSizesDeliveries";
     PRODUCT_SIZE_COUNTABLE["AUCTIONS"] = "productSizesDispositionsInAuctions";
+    PRODUCT_SIZE_COUNTABLE["RESERVATIONS"] = "productSizeReservationOrder";
 })(PRODUCT_SIZE_COUNTABLE || (PRODUCT_SIZE_COUNTABLE = {}));
 var PRODUCT_SIZE_CODES;
 (function (PRODUCT_SIZE_CODES) {

package/dist/gateways.d.ts

@@ -3343,7 +3343,7 @@ export interface SearchProductsRequest extends PagableGateway<SearchProductsRequ
     /** Price range for sought products. */
     productSearchPriceRange: (value: RequestParams.SearchProductsParams["productSearchPriceRange"]) => this;
     /** VAT value for sought products */
-    productVatRates: (value: Array<Number>) => this;
+    productVatRates: (value: number|number[]) => this;
     /** Is product VAT-free Allowed values "y" - yes, "n" - no. */
     productIsVatFree: (value: string) => this;
     /** Product has defined wholesale price. Available values: "y" - has wholesale price, "n" - does not have wholesale price. */
@@ -5206,4 +5206,4 @@ export interface Gateways {
 
 declare const defaultExport: (url: string, apiKey: string, version?: number | string) => Gateways;
 export default defaultExport;
-export { ENUMS, RequestParams }
+export { ENUMS, RequestParams, utils }

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { PRODUCT_SIZE_COUNTABLE, PRODUCT_SIZE_LOCATIONS, PRODUCT_SIZE_CODES } from "./enums.d";
+import type { PRODUCT_SIZE_COUNTABLE, PRODUCT_SIZE_LOCATIONS, PRODUCT_SIZE_CODES, PRODUCE_SIZE_INDEX } from "./enums.d";
 import type { SearchProductsResponse } from "./responses.d.ts"
 
 export type IdosellProduct = SearchProductsResponse['results'][0];
@@ -7,24 +7,35 @@ export type GetIaICodeFunction = (productId: number|string, sizeId: string) => s
 
 export type SumProductQuantitiesFunction = (productStocksData: IdosellProduct['productStocksData'], stockType?: PRODUCT_SIZE_COUNTABLE | `${PRODUCT_SIZE_COUNTABLE}`) => number;
 
-export type MapSizeQuantitesFunction = (product: IdosellProduct, stockType?: `${PRODUCT_SIZE_COUNTABLE}`) => Record<string,number>;
+export type MapSizeQuantitesFunction = (product: IdosellProduct, stockType?: `${PRODUCT_SIZE_COUNTABLE}`, indexBy?: `${PRODUCE_SIZE_INDEX}`) => Record<string,number>;
 
-export type MapProductCodesFunction = (product: IdosellProduct, codeType?: `${PRODUCT_SIZE_CODES}`) => Record<string,string>;
+export type MapProductCodesFunction = (product: IdosellProduct, codeType?: `${PRODUCT_SIZE_CODES}`, indexBy?: `${PRODUCE_SIZE_INDEX}`) => Record<string,string>;
 
-export type MapProductLocationsFunction = (product: IdosellProduct, stockId?: number, codeType?: `${PRODUCT_SIZE_LOCATIONS}`) => Record<string,string[]>;
+export type MapProductAllCodesFunction = (product: IdosellProduct, indexBy?: `${PRODUCE_SIZE_INDEX}`) => Record<string,string[]>;
+
+export type MapProductLocationsFunction = (product: IdosellProduct, stockId?: number, codeType?: `${PRODUCT_SIZE_LOCATIONS}`, indexBy?: `${PRODUCE_SIZE_INDEX}`) => Record<string,string[]>;
 
 export type GetLangDataFunction = <T extends { langId: string}>(array: T[], langId?: string) => T|undefined;
 
 export type ClearParametersLangDataFunction = (products: SearchProductsResponse['results'], langId: string = 'pol') => SearchProductsResponse['results'];
 
 declare namespace utils {
+    /** @description The method allows you to build an IAI code from the product ID and size ID. */
     const getIaiCode: GetIaICodeFunction;
+    /** @description The method allows you to sum up the current stock levels: warehouses, available stocks, etc. */
     const sumProductQuantities: SumProductQuantitiesFunction;
+    /** @description The method allows mapping the sum of the current stock levels (in warehouses, at disposal, etc.) divided into sizes */
     const mapSizeQuantites: MapSizeQuantitesFunction;
+    /** @description The method allows mapping the producers's or external system's codes stored in the system to SKUs */
     const mapProductCodes: MapProductCodesFunction;
+    /** @description The method allows mapping all known codes: IAI code, manufacturer code or external code as an array */
+    const mapAllProductCodes: MapProductAllCodesFunction;
+    /** @description This method allows you to map product locations stored in the system, broken down by size. You can select a specific warehouse or list all of them, both primary and secondary. */
+    const mapProductLocations: MapProductLocationsFunction;
+    /** @description Get first item (description, series, parameter name or value) with the selected langId */
     const getLangData: GetLangDataFunction;
+    /** @description Modifies product response by removing all parameter names nad values that are not in selected langId */
     const clearParametersLangData: ClearParametersLangDataFunction;
-    const mapProductLocations: MapProductLocationsFunction;
 }
 
 export default utils;

package/dist/utils.js

@@ -1,3 +1,4 @@
+import { PRODUCE_SIZE_INDEX } from "./enums.d.js";
 import ENUMS from "./enums.js";
 const getIaiCode = (productId, sizeId) => {
     if (sizeId === 'uniw')
@@ -50,7 +51,7 @@ const productSizesPathMap = {
         'productSizesDispositionsInSales',
         'array'
     ],
-    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_ORDERS_UNFINISHED]: [
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_UNFINISHED]: [
         'productStocksData',
         'productOrdersUnfinishedQuantities',
         'array',
@@ -68,6 +69,13 @@ const productSizesPathMap = {
         'productSizesDispositionsInAuctions',
         'array'
     ],
+    [ENUMS.PRODUCT_SIZE_COUNTABLE.RESERVATIONS]: [
+        'productStocksData',
+        'productStocksQuantities',
+        'array',
+        'productSizesData',
+        'array'
+    ],
     [ENUMS.PRODUCT_SIZE_CODES.NAME]: [
         'productSizes',
         'array'
@@ -126,29 +134,55 @@ const sumProductQuantities = (productStocksData, nodeName = ENUMS.PRODUCT_SIZE_C
     });
     return sum;
 };
-const mapSizeQuantites = (product, nodeName = ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OWN) => {
+const getProductIndexFunction = (type, product) => {
+    switch (type) {
+        case PRODUCE_SIZE_INDEX.ID: return (obj) => obj.sizeId;
+        case PRODUCE_SIZE_INDEX.IAI_CODE: return (obj) => getIaiCode(product.productId, obj.sizeId);
+        case PRODUCE_SIZE_INDEX.NAME: {
+            return (obj) => {
+                if (obj.sizePanelName)
+                    return obj.sizePanelName;
+                if (product.productSizes) {
+                    const nameItem = product.productSizes.find(size => size.sizeId === obj.sizeId);
+                    if (nameItem)
+                        return nameItem.sizePanelName;
+                }
+                throw new Error("Could not index by name - sizePanelName and productSizes missing");
+            };
+        }
+        default: throw new Error('Invalid indexBy');
+    }
+};
+const mapSizeQuantites = (product, nodeName = ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OWN, indexBy = ENUMS.PRODUCE_SIZE_INDEX.ID) => {
     const results = getTraversedPathElements(product, nodeName);
+    if (nodeName === 'productSizeReservationOrder') {
+        results.forEach(node => {
+            node.productSizeReservationOrder = node.productSizeReservations.productSizeReservationOrder;
+        });
+    }
     const aggregated = {};
     if (['productOrdersUnfinishedQuantities', 'productSizesDeliveries', 'productSizesDispositionsInAuctions'].includes(nodeName))
         nodeName = 'productSizeQuantity';
+    const getIndex = getProductIndexFunction(indexBy, product);
     results.forEach(item => {
         if (item?.sizeId && item[nodeName] !== undefined) {
-            const sizeId = String(item.sizeId);
+            const index = getIndex(item) ?? item.sizeId;
             const value = Number(item[nodeName]) || 0;
-            aggregated[sizeId] = (aggregated[sizeId] || 0) + value;
+            aggregated[index] = (aggregated[index] || 0) + value;
         }
     });
     return aggregated;
 };
-const mapProductCodes = (product, codeType = ENUMS.PRODUCT_SIZE_CODES.NAME) => {
+const mapProductCodes = (product, codeType = ENUMS.PRODUCT_SIZE_CODES.NAME, indexBy = ENUMS.PRODUCE_SIZE_INDEX.ID) => {
     const results = getTraversedPathElements(product, codeType);
     const mapped = {};
+    const getIndex = getProductIndexFunction(indexBy, product);
     results.forEach(item => {
         if (item?.sizeId && item[codeType] !== undefined) {
-            const sizeId = String(item.sizeId);
+            const index = getIndex(item) ?? item.sizeId;
             const value = String(item[codeType] || '');
-            if (!mapped[sizeId] || value) {
-                mapped[sizeId] = value;
+            if (!mapped[index] || value) {
+                mapped[index] = value;
             }
         }
     });
@@ -159,7 +193,24 @@ const SUB_TYPE_NODES = {
     stockLocationId: 'stockAdditionalLocationId',
     stockLocationCode: 'stockAdditionalLocationCode'
 };
-const mapProductLocations = (product, stockId, locationType = ENUMS.PRODUCT_SIZE_LOCATIONS.NAME) => {
+const mapAllProductCodes = (product, indexBy) => {
+    const results = getTraversedPathElements(product, ENUMS.PRODUCT_SIZE_CODES.CODE_PRODUCER);
+    const mapped = {};
+    const getIndex = getProductIndexFunction(indexBy, product);
+    for (const item of results) {
+        const index = getIndex(item);
+        if (!mapped[index]) {
+            mapped[index] = [];
+        }
+        mapped[index].push(getIaiCode(product.productId, item.sizeId));
+        if (item.productSizeCodeProducer?.length)
+            mapped[index].push(item.productSizeCodeProducer);
+        if (item.productSizeCodeExternal?.length)
+            mapped[index].push(item.productSizeCodeExternal);
+    }
+    return mapped;
+};
+const mapProductLocations = (product, stockId, locationType = ENUMS.PRODUCT_SIZE_LOCATIONS.NAME, indexBy = ENUMS.PRODUCE_SIZE_INDEX.ID) => {
     let results = getTraversedPathElements(product, locationType);
     if (stockId) {
         const prefix = 'M' + stockId;
@@ -167,22 +218,23 @@ const mapProductLocations = (product, stockId, locationType = ENUMS.PRODUCT_SIZE
     }
     const mapped = {};
     const subNode = SUB_TYPE_NODES[locationType];
+    const getIndex = getProductIndexFunction(indexBy, product);
     for (const item of results) {
-        const { sizeId } = item;
-        if (!mapped[sizeId]) {
-            mapped[sizeId] = [];
+        const index = getIndex(item);
+        if (!mapped[index]) {
+            mapped[index] = [];
         }
         // main location
         const mainLocation = item[locationType];
         if (mainLocation) {
-            mapped[sizeId].push(mainLocation.toString());
+            mapped[index].push(mainLocation.toString());
         }
         // additional locations
         if (item.stockAdditionalLocations?.length) {
             for (const additional of item.stockAdditionalLocations) {
                 const value = additional[subNode];
                 if (value) {
-                    mapped[sizeId].push(value.toString());
+                    mapped[index].push(value.toString());
                 }
             }
         }
@@ -212,11 +264,20 @@ const clearParametersLangData = (products, langId = 'pol') => {
     return products;
 };
 export default {
-    sumProductQuantities,
+    /** @description The method allows you to build an IAI code from the product ID and size ID. */
     getIaiCode,
+    /** @description The method allows you to sum up the current stock levels: warehouses, available stocks, etc. */
+    sumProductQuantities,
+    /** @description The method allows mapping the sum of the current stock levels (in warehouses, at disposal, etc.) divided into sizes */
     mapSizeQuantites,
+    /** @description The method allows mapping the producers's or external system's codes stored in the system to SKUs */
     mapProductCodes,
+    /** @description The method allows mapping all known codes: IAI code, manufacturer code or external code as an array */
+    mapAllProductCodes,
+    /** @description This method allows you to map product locations stored in the system, broken down by size. You can select a specific warehouse or list all of them, both primary and secondary. */
     mapProductLocations,
+    /** @description Get first item (description, series, parameter name or value) with the selected langId */
     getLangData,
+    /** @description Modifies product response by removing all parameter names nad values that are not in selected langId */
     clearParametersLangData
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idosell",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "description": "Idosell 3 REST connector",
   "main": "dist/index.js",
   "types": "dist/gateways.d.ts",

package/tests/getMenu.test.js

@@ -1,4 +1,4 @@
-import idosell from "./dist/index.ts"
+import idosell from "./dist/index"
 import { expect, test } from "vitest"
 
 test("getMenu", () => {

package/tests/getOrdersAuctionDetails.test.js

@@ -1,4 +1,4 @@
-import idosell from "./dist/index.ts"
+import idosell from "./dist/index"
 import { expect, test } from "vitest"
 
 test("getOrdersAuctionDetailsSerialNumbers", () => {

package/tests/getOrdersExportdocumentsEPP.test.js

@@ -1,4 +1,4 @@
-import idosell from "./dist/index.ts"
+import idosell from "./dist/index"
 import { expect, test } from "vitest"
 
 test("getOrdersExportdocuments", () => {

package/tests/getPayments.test.js

@@ -1,4 +1,4 @@
-import idosell from "./dist/index.ts"
+import idosell from "./dist/index"
 import { expect, test } from "vitest"
 
 test("getPayments", () => {

package/tests/putRefundsConfirmRefund.test.js

@@ -1,4 +1,4 @@
-import idosell from "./dist/index.ts"
+import idosell from "./dist/index"
 import { expect, test } from "vitest"
 
 test("putRefundsConfirmRefundPaymentId", () => {

package/tests/utilMapAllProductCodes.test.js

@@ -0,0 +1,24 @@
+import { ENUMS, utils } from '../dist/index';
+import { expect, test } from "vitest"
+import { STOCK_PRODUCT } from './utilTestData';
+
+
+const INDEX = ENUMS.PRODUCE_SIZE_INDEX;
+
+test('Utils mapAllProductCodes by ID', () => {
+    const codes = utils.mapAllProductCodes(STOCK_PRODUCT, INDEX.ID)
+    console.log(JSON.stringify(codes));
+    expect(codes).toEqual({"3":["1234-3","1234567890128","PX-ZERO-S"],"4":["1234-4","1234567890135","PX-ZERO-M"],"5":["1234-5","1234567890142","PX-ZERO-L"],"6":["1234-6","1234567890159","PX-ZERO-X"]});
+})
+
+test('Utils mapAllProductCodes by IAI code', () => {
+    const codes = utils.mapAllProductCodes(STOCK_PRODUCT, INDEX.IAI_CODE)
+    console.log(JSON.stringify(codes));
+    expect(codes).toEqual({"1234-3":["1234-3","1234567890128","PX-ZERO-S"],"1234-4":["1234-4","1234567890135","PX-ZERO-M"],"1234-5":["1234-5","1234567890142","PX-ZERO-L"],"1234-6":["1234-6","1234567890159","PX-ZERO-X"]});
+})
+
+test('Utils mapAllProductCodes by name', () => {
+    const codes = utils.mapAllProductCodes(STOCK_PRODUCT, INDEX.NAME)
+    console.log(JSON.stringify(codes));
+    expect(codes).toEqual({"S":["1234-3","1234567890128","PX-ZERO-S"],"M":["1234-4","1234567890135","PX-ZERO-M"],"L":["1234-5","1234567890142","PX-ZERO-L"],"XL":["1234-6","1234567890159","PX-ZERO-X"]});
+})

package/tests/utilMapProductCodes.test.js

@@ -1,24 +1,36 @@
-import distUtils from '$dist/utils.ts';
+import { ENUMS, utils } from '../dist/index';
 import { expect, test } from "vitest"
-import { STOCK_PRODUCT } from "./util.data";
-import ENUMS from '$dist/enums';
+import { STOCK_PRODUCT } from './utilTestData';
 
 const CODES = ENUMS.PRODUCT_SIZE_CODES;
+const INDEX = ENUMS.PRODUCE_SIZE_INDEX;
 
 test('Utils mapProductCodes on sizePanelName', () => {
     expect(CODES.NAME).toEqual('sizePanelName');
-    const codes = distUtils.mapProductCodes(STOCK_PRODUCT, CODES.NAME)
+    const codes = utils.mapProductCodes(STOCK_PRODUCT, CODES.NAME)
     expect(codes).toEqual({"3": "S","4": "M","5": "L","6": "XL"});
 })
 
 test('Utils mapProductCodes on productSizeCodeProducer', () => {
     expect(CODES.CODE_PRODUCER).toEqual('productSizeCodeProducer');
-    const codes = distUtils.mapProductCodes(STOCK_PRODUCT, CODES.CODE_PRODUCER)
+    const codes = utils.mapProductCodes(STOCK_PRODUCT, CODES.CODE_PRODUCER)
     expect(codes).toEqual({"3": "1234567890128","4": "1234567890135","5": "1234567890142","6": "1234567890159"});
 })
 
 test('Utils mapProductCodes on productSizeCodeExternal', () => {
     expect(CODES.CODE_EXTERNAL).toEqual('productSizeCodeExternal');
-    const codes = distUtils.mapProductCodes(STOCK_PRODUCT, CODES.CODE_EXTERNAL)
+    const codes = utils.mapProductCodes(STOCK_PRODUCT, CODES.CODE_EXTERNAL)
     expect(codes).toEqual({"3": "PX-ZERO-S","4": "PX-ZERO-M","5": "PX-ZERO-L","6": "PX-ZERO-X"});
+})
+
+test('Utils mapProductCodes on sizePanelName by IAI code', () => {
+    expect(CODES.NAME).toEqual('sizePanelName');
+    const codes = utils.mapProductCodes(STOCK_PRODUCT, CODES.NAME, INDEX.IAI_CODE)
+    expect(codes).toEqual({"1234-3":"S","1234-4":"M","1234-5":"L","1234-6":"XL"});
+})
+
+test('Utils mapProductCodes on productSizeCodeProducer by size name', () => {
+    expect(CODES.NAME).toEqual('sizePanelName');
+    const codes = utils.mapProductCodes(STOCK_PRODUCT, CODES.CODE_PRODUCER, INDEX.NAME)
+    expect(codes).toEqual({"S":"1234567890128","M":"1234567890135","L":"1234567890142","XL":"1234567890159"});
 })

package/tests/utilMapProductLocations.test.js

@@ -1,29 +1,47 @@
-import distUtils from '$dist/utils.ts';
+import { ENUMS, utils } from '../dist/index';
 import { expect, test } from "vitest"
-import { STOCK_PRODUCT } from "./util.data";
-import { ENUMS } from '$dist';
+import { STOCK_PRODUCT } from './utilTestData';
 
 const LOCATION = ENUMS.PRODUCT_SIZE_LOCATIONS;
+const INDEX = ENUMS.PRODUCE_SIZE_INDEX;
 
 test('Utils mapProductLocations on stockLocationCode', () => {
     expect(LOCATION.CODE).toEqual('stockLocationCode');
-    const locations = distUtils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.CODE)
+    const locations = utils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.CODE)
     expect(locations).toEqual({"3":["F","P","A"],"4":["F"],"5":["B"],"6":["B"]});
 })
 
+test('Utils mapProductLocations on stockLocationId', () => {
+    expect(LOCATION.ID).toEqual('stockLocationId');
+    const locations = utils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.ID)
+    expect(locations).toEqual({"3":["16","46","1"],"4":["16"],"5":["4"],"6":["4"]});
+})
+
 test('Utils mapProductLocations on stockLocationTextId', () => {
     expect(LOCATION.NAME).toEqual('stockLocationTextId');
-    const locations = distUtils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.NAME)
+    const locations = utils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.NAME)
     expect(locations).toEqual({"3":["M1\\A014","M1\\A015","M1\\A113"],"4":["M1\\A014"],"5":["M1\\B013"],"6":["M1\\B013"]});
 })
 
+test('Utils mapProductLocations on stockLocationTextId by IAI code', () => {
+    expect(LOCATION.NAME).toEqual('stockLocationTextId');
+    const locations = utils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.NAME, INDEX.IAI_CODE)
+    expect(locations).toEqual({"1234-3":["M1\\A014","M1\\A015","M1\\A113"],"1234-4":["M1\\A014"],"1234-5":["M1\\B013"],"1234-6":["M1\\B013"]});
+})
+
+test('Utils mapProductLocations on stockLocationTextId by size name', () => {
+    expect(LOCATION.NAME).toEqual('stockLocationTextId');
+    const locations = utils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.NAME, INDEX.NAME)
+    expect(locations).toEqual({"S":["M1\\A014","M1\\A015","M1\\A113"],"M":["M1\\A014"],"L":["M1\\B013"],"XL":["M1\\B013"]});
+})
+
 test('Utils mapProductLocations on stockLocationId', () => {
     expect(LOCATION.ID).toEqual('stockLocationId');
-    const locations = distUtils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.ID)
+    const locations = utils.mapProductLocations(STOCK_PRODUCT, 1, LOCATION.ID)
     expect(locations).toEqual({"3":["16","46","1"],"4":["16"],"5":["4"],"6":["4"]});
 })
 
 test('Utils mapProductLocations full', () => {
-    const locations = distUtils.mapProductLocations(STOCK_PRODUCT)
+    const locations = utils.mapProductLocations(STOCK_PRODUCT)
     expect(locations).toEqual({"3":["M1\\A014","M1\\A015","M1\\A113","M2\\G013","M3\\K014"],"4":["M1\\A014","M2\\G015","M3\\L013"],"5":["M1\\B013","M2\\G114","M3\\L013"],"6":["M1\\B013","M2\\G214","M3\\K014"]});
 })

package/tests/utilMapSizeQuantites.test.js

@@ -1,48 +1,60 @@
-import distUtils from '$dist/utils.ts';
+import { ENUMS, utils } from '../dist/index';
 import { expect, test } from "vitest"
-import { STOCK_PRODUCT } from "./util.data";
-import ENUMS from '$dist/enums';
+import { STOCK_PRODUCT } from './utilTestData';
 
 const COUNTABLE = ENUMS.PRODUCT_SIZE_COUNTABLE;
+const INDEX = ENUMS.PRODUCE_SIZE_INDEX;
 
 test('Utils mapSizeQuantites on productSizeQuantity', () => {
     expect(COUNTABLE.QUANTITY).toEqual('productSizeQuantity');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY)
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY)
     expect(quantities).toEqual({"3":10,"4":10,"5":0,"6":0});
 })
 
+test('Utils mapSizeQuantites on productSizeQuantity by IAI code', () => {
+    expect(COUNTABLE.QUANTITY).toEqual('productSizeQuantity');
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY, INDEX.IAI_CODE)
+    expect(quantities).toEqual({"1234-3":10,"1234-4":10,"1234-5":0,"1234-6":0});
+})
+
+test('Utils mapSizeQuantites on productSizeQuantity by size name', () => {
+    expect(COUNTABLE.QUANTITY).toEqual('productSizeQuantity');
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY, INDEX.NAME)
+    expect(quantities).toEqual({"S":10,"M":10,"L":0,"XL":0});
+})
+
 test('Utils mapSizeQuantites on productSizeQuantityOwnStock', () => {
     expect(COUNTABLE.QUANTITY_OWN).toEqual('productSizeQuantityOwnStock');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_OWN)
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_OWN)
     expect(quantities).toEqual({"3":8,"4":10,"5":0,"6":0});
 })
 
 test('Utils mapSizeQuantites on productSizeQuantityOutsideStock', () => {
     expect(COUNTABLE.QUANTITY_OUTSIDE).toEqual('productSizeQuantityOutsideStock');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_OUTSIDE)
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_OUTSIDE)
     expect(quantities).toEqual({"3":0,"4":0,"5":5,"6":0});
 })
 
 test('Utils mapSizeQuantites on productSizeQuantityAllStocks', () => {
     expect(COUNTABLE.QUANTITY_ALL).toEqual('productSizeQuantityAllStocks');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_ALL)
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_ALL)
     expect(quantities).toEqual({"3":8,"4":10,"5":5,"6":0});
 })
 
 test('Utils mapSizeQuantites on productOrdersUnfinishedQuantities', () => {
-    expect(COUNTABLE.QUANTITY_ORDERS_UNFINISHED).toEqual('productOrdersUnfinishedQuantities');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_ORDERS_UNFINISHED)
+    expect(COUNTABLE.QUANTITY_UNFINISHED).toEqual('productOrdersUnfinishedQuantities');
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.QUANTITY_UNFINISHED)
     expect(quantities).toEqual({"3":2});
 })
 
 test('Utils mapSizeQuantites on productSizesDeliveries', () => {
     expect(COUNTABLE.DELIVERIES).toEqual('productSizesDeliveries');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.DELIVERIES)
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.DELIVERIES)
     expect(quantities).toEqual({"5":3,"6":3});
 })
 
 test('Utils mapSizeQuantites on productSizesDispositionsInAuctions', () => {
     expect(COUNTABLE.AUCTIONS).toEqual('productSizesDispositionsInAuctions');
-    const quantities = distUtils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.AUCTIONS)
+    const quantities = utils.mapSizeQuantites(STOCK_PRODUCT, COUNTABLE.AUCTIONS)
     expect(quantities).toEqual({"3":1,"4":0,"5":0,"6":0});
 })

package/tests/utilSumProductQuantities.test.js

@@ -1,48 +1,47 @@
-import distUtils from '$dist/utils.ts';
+import { ENUMS, utils } from '../dist/index';
 import { expect, test } from "vitest"
-import { STOCK_PRODUCT } from "./util.data";
-import ENUMS from '$dist/enums';
+import { STOCK_PRODUCT } from './utilTestData';
 
 const COUNTABLE = ENUMS.PRODUCT_SIZE_COUNTABLE;
 
 test('Utils sumProductQuantities on productSizeQuantity', () => {
     expect(ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY).toEqual('productSizeQuantity');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY)
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY)
     expect(sum).toEqual(20);
 })
 
 test('Utils sumProductQuantities on productSizeQuantityOwnStock', () => {
     expect(ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OWN).toEqual('productSizeQuantityOwnStock');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_OWN)
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_OWN)
     expect(sum).toEqual(18);
 })
 
 test('Utils sumProductQuantities on productSizeQuantityOutsideStock', () => {
     expect(ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_OUTSIDE).toEqual('productSizeQuantityOutsideStock');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_OUTSIDE)
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_OUTSIDE)
     expect(sum).toEqual(5);
 })
 
 test('Utils sumProductQuantities on productSizeQuantityAllStocks', () => {
     expect(ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_ALL).toEqual('productSizeQuantityAllStocks');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_ALL)
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_ALL)
     expect(sum).toEqual(23);
 })
 
 test('Utils sumProductQuantities on productOrdersUnfinishedQuantities', () => {
-    expect(ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_ORDERS_UNFINISHED).toEqual('productOrdersUnfinishedQuantities');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_ORDERS_UNFINISHED)
+    expect(ENUMS.PRODUCT_SIZE_COUNTABLE.QUANTITY_UNFINISHED).toEqual('productOrdersUnfinishedQuantities');
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.QUANTITY_UNFINISHED)
     expect(sum).toEqual(2);
 })
 
 test('Utils sumProductQuantities on productSizesDeliveries', () => {
     expect(ENUMS.PRODUCT_SIZE_COUNTABLE.DELIVERIES).toEqual('productSizesDeliveries');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.DELIVERIES)
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.DELIVERIES)
     expect(sum).toEqual(6);
 })
 
 test('Utils sumProductQuantities on productSizesDispositionsInAuctions', () => {
     expect(ENUMS.PRODUCT_SIZE_COUNTABLE.AUCTIONS).toEqual('productSizesDispositionsInAuctions');
-    const sum = distUtils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.AUCTIONS)
+    const sum = utils.sumProductQuantities(STOCK_PRODUCT.productStocksData, COUNTABLE.AUCTIONS)
     expect(sum).toEqual(1);
 })

package/tests/{util.data.ts → utilTestData.ts}

@@ -1,7 +1,8 @@
-import type { SearchProductsResponse } from "$dist/responses";
+import type { SearchProductsResponse } from "../dist/responses";
 
 export const STOCK_PRODUCT: SearchProductsResponse['results'][number] = {
-    "productId": 541321313,
+    "productId": 1234,
+    "productDisplayedCode": 'ZERO',
     "productStocksData": {
         "productSizesDeliveries": [
             {