@softwear/latestcollectioncore 1.0.152 → 1.0.158

package/dist/buildPropertyMappingFn.js

@@ -41,7 +41,7 @@ function default_1(brands, strategy) {
     });
     if (strategy == 'clean')
         return function (sku) {
-            const brand = sku.BRANDHASH || (0, index_1.hashBrand)(sku.brand);
+            const brand = sku.brandhash || (0, index_1.hashBrand)(sku.brand);
             const mapping = indexedByBrandPropertyMapping[brand];
             mappingPairs.forEach((pair) => {
                 var _a;
@@ -56,7 +56,7 @@ function default_1(brands, strategy) {
         };
     if (strategy == 'markMissingMapping')
         return function (sku) {
-            const brand = sku.BRANDHASH || (0, index_1.hashBrand)(sku.brand);
+            const brand = sku.brandhash || (0, index_1.hashBrand)(sku.brand);
             const mapping = indexedByBrandPropertyMapping[brand];
             mappingPairs.forEach((pair) => {
                 var _a, _b, _c, _d, _e;
@@ -70,7 +70,7 @@ function default_1(brands, strategy) {
             return sku;
         };
     return function (sku) {
-        const brand = sku.BRANDHASH || (0, index_1.hashBrand)(sku.brand);
+        const brand = sku.brandhash || (0, index_1.hashBrand)(sku.brand);
         const mapping = indexedByBrandPropertyMapping[brand];
         mappingPairs.forEach((pair) => {
             var _a, _b, _c, _d, _e, _f;

package/dist/cryptography.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { Buffer } from 'buffer';
 export declare function encrypt(plain: string, KEY: Buffer): string;
 export declare function decrypt(enc: string, KEY: Buffer): string;

package/dist/cryptography.js

@@ -1,31 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decrypt = exports.encrypt = void 0;
-const buffer_1 = require("buffer");
+/**
+ * Node-only AES-GCM. Import from `@softwear/latestcollectioncore/cryptography` (not the main package).
+ * Uses global `Buffer` and bare `crypto` so bundlers need not resolve `node:` URLs.
+ */
 const crypto_1 = require("crypto");
+function assertNodeOnly() {
+    var _a;
+    if (typeof process === 'undefined' || !((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node)) {
+        throw new Error('@softwear/latestcollectioncore/cryptography is Node-only');
+    }
+}
 function encrypt(plain, KEY) {
+    assertNodeOnly();
     const iv = (0, crypto_1.randomBytes)(12);
     const cipher = (0, crypto_1.createCipheriv)('aes-256-gcm', KEY, iv);
-    const ciphertext = buffer_1.Buffer.concat([cipher.update(plain, 'utf8'), cipher.final()]);
+    const ciphertext = Buffer.concat([cipher.update(plain, 'utf8'), cipher.final()]);
     const tag = cipher.getAuthTag();
     const b64 = (b) => b.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
     return `v1:${b64(iv)}:${b64(ciphertext)}:${b64(tag)}`;
 }
 exports.encrypt = encrypt;
 function decrypt(enc, KEY) {
+    assertNodeOnly();
     const [version, ivB64, ctB64, tagB64] = enc.split(':');
     if (version !== 'v1')
         throw new Error('Unsupported version');
     const fromB64 = (s) => {
         const pad = s.length % 4 ? '='.repeat(4 - (s.length % 4)) : '';
-        return buffer_1.Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/') + pad, 'base64');
+        return Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/') + pad, 'base64');
     };
     const iv = fromB64(ivB64);
     const ct = fromB64(ctB64);
     const tag = fromB64(tagB64);
     const decipher = (0, crypto_1.createDecipheriv)('aes-256-gcm', KEY, iv);
     decipher.setAuthTag(tag);
-    const plain = buffer_1.Buffer.concat([decipher.update(ct), decipher.final()]);
+    const plain = Buffer.concat([decipher.update(ct), decipher.final()]);
     return plain.toString('utf8');
 }
 exports.decrypt = decrypt;

package/dist/imageBinder.js

@@ -80,7 +80,7 @@ function prepFilterSkusImages(filteredSkus, merge = true, fileNames) {
             return;
         }
         for (const fieldName in sku) {
-            if (fieldName == '__created' || fieldName == '__modified' || fieldName == 'images' || fieldName == 'BRANDHASH' || (merge == true && fieldName == 'colorFamily'))
+            if (fieldName == '__created' || fieldName == '__modified' || fieldName == 'images' || fieldName == 'brandhash' || (merge == true && fieldName == 'colorFamily'))
                 continue;
             let fieldVal = sku[fieldName];
             if (fieldVal == '')
@@ -505,7 +505,7 @@ function testBatch(brand) {
         const [skusModule, imagesModule, matchedModule] = yield Promise.all([
             (_a = `../test/imageBinderTestData/brandSkus/${brand}.json`, Promise.resolve().then(() => __importStar(require(_a)))),
             (_b = `../test/imageBinderTestData/brandImages/${brand}.json`, Promise.resolve().then(() => __importStar(require(_b)))),
-            (_c = `../test/imageBinderTestData/brandDataMatched/${brand}.json`, Promise.resolve().then(() => __importStar(require(_c))))
+            (_c = `../test/imageBinderTestData/brandDataMatched/${brand}.json`, Promise.resolve().then(() => __importStar(require(_c)))),
         ]);
         const fileNames = imagesModule.default;
         const filteredSkus = skusModule.default;
@@ -536,14 +536,14 @@ function testBatch(brand) {
             }
         }
         return {
-            'Brand': brand,
-            'Files': fileNames.length,
-            'Skus': filteredSkus.length,
-            'Mismatches': mismatchCount,
-            'Time': Number(((t1 - t0) / 1000).toFixed(3)),
-            'QuickSearch': imageBinderResult.quickCount,
-            'FallbackSearch': imageBinderResult.fallbackCount,
-            'Patterns': imageBinderResult.patternCounter,
+            Brand: brand,
+            Files: fileNames.length,
+            Skus: filteredSkus.length,
+            Mismatches: mismatchCount,
+            Time: Number(((t1 - t0) / 1000).toFixed(3)),
+            QuickSearch: imageBinderResult.quickCount,
+            FallbackSearch: imageBinderResult.fallbackCount,
+            Patterns: imageBinderResult.patternCounter,
         };
     });
 }

package/dist/index.d.ts

@@ -17,4 +17,5 @@ export { default as sizeToMap } from './sizeToMap';
 export { default as transaction } from './transaction';
 export * from './types';
 export * from './consts';
-export * from './cryptography';
+export { default as lcAxios, createAxiosInstance, axiosRetry, exponentialDelay, isAxiosError, } from './lcAxios';
+export type { AxiosRequestConfig, AxiosResponse, AxiosPromise, AxiosError, AxiosTransformer, AxiosRetryOptions, AxiosRequestConfigAny, } from './lcAxios';

package/dist/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transaction = exports.sizeToMap = exports.round2 = exports.pivotTable = exports.isean13 = exports.imageBinder = exports.hasOnlyDigits = exports.hashBrand = exports.getPreferedPropertyMappings = exports.getBrandName = exports.findSkuByBarcode = exports.ensureArray = exports.edifact = exports.ean13 = exports.deepCopy = exports.buildPropertyMappingFn = exports.articleStatus = void 0;
+exports.isAxiosError = exports.exponentialDelay = exports.axiosRetry = exports.createAxiosInstance = exports.lcAxios = exports.transaction = exports.sizeToMap = exports.round2 = exports.pivotTable = exports.isean13 = exports.imageBinder = exports.hasOnlyDigits = exports.hashBrand = exports.getPreferedPropertyMappings = exports.getBrandName = exports.findSkuByBarcode = exports.ensureArray = exports.edifact = exports.ean13 = exports.deepCopy = exports.buildPropertyMappingFn = exports.articleStatus = void 0;
 var articleStatus_1 = require("./articleStatus");
 Object.defineProperty(exports, "articleStatus", { enumerable: true, get: function () { return __importDefault(articleStatus_1).default; } });
 var buildPropertyMappingFn_1 = require("./buildPropertyMappingFn");
@@ -54,4 +54,9 @@ var transaction_1 = require("./transaction");
 Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return __importDefault(transaction_1).default; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./consts"), exports);
-__exportStar(require("./cryptography"), exports);
+var lcAxios_1 = require("./lcAxios");
+Object.defineProperty(exports, "lcAxios", { enumerable: true, get: function () { return __importDefault(lcAxios_1).default; } });
+Object.defineProperty(exports, "createAxiosInstance", { enumerable: true, get: function () { return lcAxios_1.createAxiosInstance; } });
+Object.defineProperty(exports, "axiosRetry", { enumerable: true, get: function () { return lcAxios_1.axiosRetry; } });
+Object.defineProperty(exports, "exponentialDelay", { enumerable: true, get: function () { return lcAxios_1.exponentialDelay; } });
+Object.defineProperty(exports, "isAxiosError", { enumerable: true, get: function () { return lcAxios_1.isAxiosError; } });

package/dist/lcAxios.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Fetch-based axios-compatible client (minimal surface used by apps).
+ * Zero extra npm deps: uses global fetch, URL, Headers, AbortController.
+ *
+ * `decompress` on the request config is accepted for axios API compatibility only;
+ * it is ignored at runtime — fetch already returns decompressed response bodies for typical reads.
+ */
+export interface AxiosRequestConfig<D = any> {
+    url?: string;
+    baseURL?: string;
+    method?: string;
+    data?: D;
+    params?: Record<string, any>;
+    headers?: Record<string, string | undefined> | any;
+    timeout?: number;
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    validateStatus?: (status: number) => boolean;
+    transformRequest?: AxiosTransformer | AxiosTransformer[];
+    transformResponse?: AxiosTransformer | AxiosTransformer[];
+    withCredentials?: boolean;
+    /** Axios-only; ignored — fetch handles Content-Encoding when reading the body */
+    decompress?: boolean;
+}
+export type AxiosTransformer = (data: any, headers?: any) => any | Promise<any>;
+export interface AxiosResponse<T = any, D = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: AxiosRequestConfig<D>;
+}
+export type AxiosPromise<T = any> = Promise<AxiosResponse<T>>;
+export interface AxiosError<T = any, D = any> extends Error {
+    isAxiosError: true;
+    config?: AxiosRequestConfig<D>;
+    response?: AxiosResponse<T, D>;
+    request?: any;
+}
+export type AxiosRequestConfigAny = AxiosRequestConfig;
+declare function isAxiosError(payload: any): payload is AxiosError;
+export declare function exponentialDelay(retryNumber?: number): number;
+export interface AxiosRetryOptions {
+    retries?: number;
+    retryDelay?: (retryCount: number) => number;
+    retryCondition?: (error: any) => boolean;
+}
+export declare function axiosRetry(instance: any, options?: AxiosRetryOptions): any;
+export declare function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any;
+declare const lcAxios: any;
+export default lcAxios;
+export { lcAxios, isAxiosError };

package/dist/lcAxios.js

@@ -0,0 +1,330 @@
+"use strict";
+/**
+ * Fetch-based axios-compatible client (minimal surface used by apps).
+ * Zero extra npm deps: uses global fetch, URL, Headers, AbortController.
+ *
+ * `decompress` on the request config is accepted for axios API compatibility only;
+ * it is ignored at runtime — fetch already returns decompressed response bodies for typical reads.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAxiosError = exports.lcAxios = exports.createAxiosInstance = exports.axiosRetry = exports.exponentialDelay = void 0;
+function isAxiosError(payload) {
+    return payload && payload.isAxiosError === true;
+}
+exports.isAxiosError = isAxiosError;
+function mergeDeep(base, patch) {
+    if (patch === undefined || patch === null)
+        return base;
+    if (base === undefined || base === null) {
+        if (typeof patch === 'object' && patch !== null && !Array.isArray(patch)) {
+            return mergeDeep({}, patch);
+        }
+        return patch;
+    }
+    if (Array.isArray(patch))
+        return patch.slice();
+    const out = Object.assign({}, base);
+    for (const k of Object.keys(patch)) {
+        const pv = patch[k];
+        const bv = base[k];
+        if (pv && typeof pv === 'object' && !Array.isArray(pv) && pv.constructor === Object && bv && typeof bv === 'object' && !Array.isArray(bv)) {
+            out[k] = mergeDeep(bv, pv);
+        }
+        else if (pv !== undefined) {
+            out[k] = pv;
+        }
+    }
+    return out;
+}
+/** Like axios mergeConfig: concat transformRequest / transformResponse arrays */
+function mergeRequestConfig(defaults, config) {
+    const m = mergeDeep(mergeDeep({}, defaults), config);
+    const dt = defaults.transformRequest;
+    const ct = config.transformRequest;
+    if (dt && ct) {
+        m.transformRequest = [].concat(Array.isArray(dt) ? dt : [dt]).concat(Array.isArray(ct) ? ct : [ct]);
+    }
+    const dtr = defaults.transformResponse;
+    const ctr = config.transformResponse;
+    if (dtr && ctr) {
+        m.transformResponse = [].concat(Array.isArray(dtr) ? dtr : [dtr]).concat(Array.isArray(ctr) ? ctr : [ctr]);
+    }
+    return m;
+}
+function buildURL(baseURL, url, params) {
+    const path = joinURL(baseURL, url || '');
+    if (!params || !Object.keys(params).length)
+        return path;
+    let u;
+    if (/^https?:\/\//i.test(path)) {
+        u = new URL(path);
+    }
+    else if (typeof window !== 'undefined' && window.location) {
+        u = new URL(path, window.location.href);
+    }
+    else {
+        u = new URL(path, 'http://127.0.0.1');
+    }
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined || v === null)
+            continue;
+        if (Array.isArray(v))
+            v.forEach((item) => u.searchParams.append(k, String(item)));
+        else
+            u.searchParams.set(k, String(v));
+    }
+    if (/^https?:\/\//i.test(path))
+        return u.toString();
+    return `${u.pathname}${u.search}${u.hash}`;
+}
+function joinURL(baseURL, url) {
+    if (!baseURL)
+        return url;
+    if (!url)
+        return baseURL.replace(/\/$/, '');
+    const b = baseURL.replace(/\/$/, '');
+    const p = url.startsWith('/') ? url : `/${url}`;
+    return `${b}${p}`;
+}
+function flattenHeaders(h, method) {
+    const out = {};
+    if (!h)
+        return out;
+    const common = h.common || {};
+    const byMethod = (h[method.toLowerCase()] || h[method] || {});
+    for (const s of [common, byMethod, h]) {
+        if (!s || typeof s !== 'object')
+            continue;
+        for (const [k, v] of Object.entries(s)) {
+            if (['common', 'get', 'post', 'put', 'patch', 'delete', 'head'].includes(k))
+                continue;
+            if (v != null && v !== '')
+                out[k] = String(v);
+        }
+    }
+    return out;
+}
+function applyTransformRequest(fns, data, headers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!fns)
+            return data;
+        const list = Array.isArray(fns) ? fns : [fns];
+        let d = data;
+        for (const fn of list) {
+            d = yield Promise.resolve(fn(d, headers));
+        }
+        return d;
+    });
+}
+function applyTransformResponse(fns, data, headers) {
+    if (!fns)
+        return data;
+    const list = Array.isArray(fns) ? fns : [fns];
+    let d = data;
+    for (const fn of list) {
+        d = fn(d, headers);
+    }
+    return d;
+}
+function headersFromFetch(h) {
+    const o = {};
+    h.forEach((v, k) => {
+        o[k] = v;
+    });
+    return o;
+}
+function exponentialDelay(retryNumber = 0) {
+    const delay = Math.pow(2, retryNumber) * 1000;
+    const randomSum = delay * 0.2 * Math.random() * 2 - 1;
+    return delay + randomSum;
+}
+exports.exponentialDelay = exponentialDelay;
+function axiosRetry(instance, options = {}) {
+    var _a, _b, _c;
+    const retries = (_a = options.retries) !== null && _a !== void 0 ? _a : 3;
+    const retryDelay = (_b = options.retryDelay) !== null && _b !== void 0 ? _b : exponentialDelay;
+    const retryCondition = (_c = options.retryCondition) !== null && _c !== void 0 ? _c : (() => false);
+    const original = instance.request.bind(instance);
+    instance.request = function axiosRetryRequest(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let attempt = 0;
+            while (true) {
+                try {
+                    return yield original(req);
+                }
+                catch (err) {
+                    if (attempt >= retries || !retryCondition(err))
+                        throw err;
+                    yield new Promise((r) => setTimeout(r, retryDelay(attempt)));
+                    attempt++;
+                }
+            }
+        });
+    };
+    return instance;
+}
+exports.axiosRetry = axiosRetry;
+const defaultValidateStatus = (status) => status >= 200 && status < 300;
+function getDefaultDefaults() {
+    return {
+        headers: { common: {} },
+        transformRequest: [
+            function defaultTransformRequest(data, headers) {
+                var _a, _b;
+                if (data == null)
+                    return data;
+                if (typeof data === 'string')
+                    return data;
+                if (typeof FormData !== 'undefined' && data instanceof FormData)
+                    return data;
+                if (typeof Blob !== 'undefined' && data instanceof Blob)
+                    return data;
+                if (typeof Buffer !== 'undefined' && ((_b = (_a = Buffer).isBuffer) === null || _b === void 0 ? void 0 : _b.call(_a, data)))
+                    return data;
+                // JSON.stringify on Uint8Array produces {"0":byte,...} — never do that; binary must pass through
+                if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer)
+                    return data;
+                if (typeof Uint8Array !== 'undefined' && data instanceof Uint8Array)
+                    return data;
+                if (typeof data === 'object') {
+                    if (!headers['Content-Type'] && !headers['content-type']) {
+                        headers['Content-Type'] = 'application/json';
+                    }
+                    return JSON.stringify(data);
+                }
+                return data;
+            },
+        ],
+        transformResponse: [
+            function defaultTransformResponse(data) {
+                return data;
+            },
+        ],
+    };
+}
+function createAxiosInstance(initialDefaults) {
+    const defaults = initialDefaults
+        ? mergeRequestConfig(mergeDeep({}, getDefaultDefaults()), initialDefaults)
+        : mergeDeep({}, getDefaultDefaults());
+    function dispatchRequest(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const merged = mergeRequestConfig(defaults, config);
+            const method = (merged.method || 'get').toUpperCase();
+            const url = buildURL(merged.baseURL, merged.url, merged.params);
+            const headers = Object.assign({}, flattenHeaders(merged.headers, method));
+            let data = merged.data;
+            data = yield applyTransformRequest(merged.transformRequest, data, headers);
+            const validateStatus = merged.validateStatus || defaultValidateStatus;
+            const controller = new AbortController();
+            const t = merged.timeout;
+            let timer;
+            if (t != null && t > 0) {
+                timer = setTimeout(() => controller.abort(), t);
+            }
+            const init = {
+                method,
+                headers,
+                signal: controller.signal,
+            };
+            if (merged.withCredentials) {
+                init.credentials = 'include';
+            }
+            if (method !== 'GET' && method !== 'HEAD' && data !== undefined) {
+                init.body = data;
+            }
+            let res;
+            try {
+                res = yield fetch(url, init);
+            }
+            catch (e) {
+                if (timer)
+                    clearTimeout(timer);
+                const err = new Error((e === null || e === void 0 ? void 0 : e.name) === 'AbortError' ? 'timeout of ' + t + 'ms exceeded' : 'Network Error');
+                err.isAxiosError = true;
+                err.config = merged;
+                err.request = { aborted: (e === null || e === void 0 ? void 0 : e.name) === 'AbortError' };
+                throw err;
+            }
+            if (timer)
+                clearTimeout(timer);
+            const resHeaders = headersFromFetch(res.headers);
+            const ct = res.headers.get('content-type') || '';
+            const rt = merged.responseType || 'json';
+            let parsed;
+            if (rt === 'blob') {
+                parsed = yield res.blob();
+            }
+            else if (rt === 'arraybuffer') {
+                parsed = yield res.arrayBuffer();
+            }
+            else if (rt === 'text') {
+                parsed = yield res.text();
+            }
+            else if (ct.includes('application/json')) {
+                // Declared JSON: empty body → null; invalid JSON → raw string (axios-like)
+                const text = yield res.text();
+                try {
+                    parsed = text ? JSON.parse(text) : null;
+                }
+                catch (_a) {
+                    parsed = text;
+                }
+            }
+            else {
+                // Other content-types: still try JSON.parse so mislabeled JSON works; empty body → '' (not null)
+                const text = yield res.text();
+                try {
+                    parsed = text ? JSON.parse(text) : text;
+                }
+                catch (_b) {
+                    parsed = text;
+                }
+            }
+            parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders);
+            const response = {
+                data: parsed,
+                status: res.status,
+                statusText: res.statusText,
+                headers: resHeaders,
+                config: merged,
+            };
+            if (!validateStatus(res.status)) {
+                const err = new Error('Request failed with status code ' + res.status);
+                err.isAxiosError = true;
+                err.config = merged;
+                err.response = response;
+                throw err;
+            }
+            return response;
+        });
+    }
+    const instance = function request(configOrUrl, maybe) {
+        if (typeof configOrUrl === 'string') {
+            return instance.request(Object.assign(Object.assign({}, (maybe || {})), { url: configOrUrl }));
+        }
+        return instance.request(configOrUrl);
+    };
+    instance.defaults = defaults;
+    instance.request = (c) => dispatchRequest(mergeRequestConfig(defaults, c));
+    instance.get = (url, c) => instance.request(Object.assign(Object.assign({}, (c || {})), { url, method: 'GET' }));
+    instance.delete = (url, c) => instance.request(Object.assign(Object.assign({}, (c || {})), { url, method: 'DELETE' }));
+    instance.head = (url, c) => instance.request(Object.assign(Object.assign({}, (c || {})), { url, method: 'HEAD' }));
+    instance.post = (url, data, c) => instance.request(Object.assign(Object.assign({}, (c || {})), { url, method: 'POST', data }));
+    instance.put = (url, data, c) => instance.request(Object.assign(Object.assign({}, (c || {})), { url, method: 'PUT', data }));
+    instance.patch = (url, data, c) => instance.request(Object.assign(Object.assign({}, (c || {})), { url, method: 'PATCH', data }));
+    instance.create = (cfg) => createAxiosInstance(mergeRequestConfig(mergeDeep({}, defaults), cfg || {}));
+    return instance;
+}
+exports.createAxiosInstance = createAxiosInstance;
+const lcAxios = createAxiosInstance();
+exports.lcAxios = lcAxios;
+exports.default = lcAxios;

package/dist/types.d.ts

@@ -126,7 +126,7 @@ interface SkuI {
     tagType?: tagTypeE;
     directDelivery?: boolean;
     care?: CareI;
-    BRANDHASH?: string;
+    brandhash?: string;
     ATTRIBUTES?: object;
     IMAGES?: Array<ImageI>;
     SIZES?: unknown;

package/package.json

@@ -1,35 +1,44 @@
 {
-	"name": "@softwear/latestcollectioncore",
-	"version": "1.0.152",
-	"description": "Core functions for LatestCollections applications",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"scripts": {
-		"build": "tsc -p tsconfig.json",
-		"build:watch": "tsc -p tsconfig.json --watch",
-		"test": "vitest run",
-		"test:watch": "vitest",
-		"dev": "concurrently \"npm:build:watch\" \"npm:test:watch\""
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+ssh://git@gitlab.com/softwearconnect/latestcollectioncore.git"
-	},
-	"author": "Jeroen de Vries",
-	"license": "ISC",
-	"bugs": {
-		"url": "https://gitlab.com/softwearconnect/latestcollectioncore/issues"
-	},
-	"homepage": "https://gitlab.com/softwearconnect/latestcollectioncore#readme",
-	"devDependencies": {
-		"@types/node": "^18.11.17",
-		"concurrently": "^9.2.1",
-		"typescript": "^4.9.4",
-		"vitest": "^1.0.0"
-	},
+  "name": "@softwear/latestcollectioncore",
+	"version": "1.0.158",
+  "description": "Core functions for LatestCollections applications",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./cryptography": {
+      "types": "./dist/cryptography.d.ts",
+      "default": "./dist/cryptography.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:watch": "tsc -p tsconfig.json --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "concurrently \"npm:build:watch\" \"npm:test:watch\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/softwearconnect/latestcollectioncore.git"
+  },
+  "author": "Jeroen de Vries",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/softwearconnect/latestcollectioncore/issues"
+  },
+  "homepage": "https://gitlab.com/softwearconnect/latestcollectioncore#readme",
+  "devDependencies": {
+    "@types/node": "^18.11.17",
+    "concurrently": "^9.2.1",
+    "typescript": "^4.9.4",
+    "vitest": "^1.0.0"
+  },
 	"dependencies": {
-		"buffer": "^6.0.3",
 		"date-fns": "^2.29.3",
-		"filtrex": "^2.2.3"
-	}
-}
+    "filtrex": "^2.2.3"
+  }
+}

package/src/buildPropertyMappingFn.ts

@@ -47,7 +47,7 @@ export default function (brands: Array<BrandSettingI>, strategy: mappingStrategy
   })
   if (strategy == 'clean')
     return function (sku: SkuI): SkuI {
-      const brand = sku.BRANDHASH || hashBrand(sku.brand)
+      const brand = sku.brandhash || hashBrand(sku.brand)
       const mapping = indexedByBrandPropertyMapping[brand]
       mappingPairs.forEach((pair) => {
         const from = evaluateFromExpr(sku, pair.from) || ''
@@ -59,7 +59,7 @@ export default function (brands: Array<BrandSettingI>, strategy: mappingStrategy
     }
   if (strategy == 'markMissingMapping')
     return function (sku: SkuI): SkuI {
-      const brand = sku.BRANDHASH || hashBrand(sku.brand)
+      const brand = sku.brandhash || hashBrand(sku.brand)
       const mapping = indexedByBrandPropertyMapping[brand]
       mappingPairs.forEach((pair) => {
         const from = evaluateFromExpr(sku, pair.from) || ''
@@ -72,7 +72,7 @@ export default function (brands: Array<BrandSettingI>, strategy: mappingStrategy
       return sku
     }
   return function (sku: SkuI): SkuI {
-    const brand = sku.BRANDHASH || hashBrand(sku.brand)
+    const brand = sku.brandhash || hashBrand(sku.brand)
     const mapping = indexedByBrandPropertyMapping[brand]
     mappingPairs.forEach((pair) => {
       if (sku[pair.to]) return // Do not replace sku-level-user-supplied values