@softwear/latestcollectioncore 1.0.151 → 1.0.153

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

package/src/cryptography.ts

@@ -1,5 +1,5 @@
-import { Buffer } from 'buffer'
-import { createCipheriv, createDecipheriv, randomBytes } from 'crypto'
+import { Buffer } from 'node:buffer'
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
 
 export function encrypt(plain: string, KEY: Buffer): string {
   const iv = randomBytes(12)

package/src/imageBinder.ts

@@ -30,8 +30,8 @@ const GLOBAL_PATTERNS = [
 
 function prepFilterSkusImages(filteredSkus: SkuI[], merge = true, fileNames: Array<string>) {
   const skusCopy = deepCopy(filteredSkus)
-  const preppedSkus : Array<Record<string, any>> = []
-  const fileNames2skip : Array<string> = []
+  const preppedSkus: Array<Record<string, any>> = []
+  const fileNames2skip: Array<string> = []
   let idx = 0
   skusCopy.forEach((sku) => {
     const fieldsToBeMerged = {}
@@ -45,7 +45,7 @@ function prepFilterSkusImages(filteredSkus: SkuI[], merge = true, fileNames: Arr
     }
 
     for (const fieldName in sku) {
-      if (fieldName == '__created' || fieldName == '__modified' || fieldName == 'images' || fieldName == 'BRANDHASH' || (merge == true && fieldName == 'colorFamily')) continue
+      if (fieldName == '__created' || fieldName == '__modified' || fieldName == 'images' || fieldName == 'brandhash' || (merge == true && fieldName == 'colorFamily')) continue
       let fieldVal = sku[fieldName]
       if (fieldVal == '') continue
 
@@ -81,7 +81,6 @@ function prepFilterSkusImages(filteredSkus: SkuI[], merge = true, fileNames: Arr
       }
       preppedSkus.push(newSku)
     }
-
   })
   const fileNames2Match = fileNames.filter((fileName) => {
     return fileNames2skip.includes(fileName) == false
@@ -156,8 +155,8 @@ function testQuickSearch(
   filteredSkus: {},
   quickSearchOrder: Array<string>
 ) {
-  const indicesToReturn : Array<number> = []
-  const indicesWithoutLast : Array<number> = []
+  const indicesToReturn: Array<number> = []
+  const indicesWithoutLast: Array<number> = []
   let patternStringFound = ''
   quickSearchOrder.every((quickSearchPattern) => {
     if (quickSearchPattern in quickSearch) {
@@ -184,7 +183,7 @@ function testQuickSearch(
 
 function prepQuickSearch(preppedSkus: any): Record<string, Array<any>> {
   const quickSearch = {}
-  const patternStrings : Array<string> = []
+  const patternStrings: Array<string> = []
   GLOBAL_PATTERNS.forEach((pattern) => {
     patternStrings.push(pattern.join('-'))
   })
@@ -204,7 +203,7 @@ function prepQuickSearch(preppedSkus: any): Record<string, Array<any>> {
 }
 
 function addNewPatternToQuickSearch(preppedSkus: any, pattern: Array<string>, quickSearch: Record<string, Array<Array<any>>>): Record<string, Array<any>> {
-  const newQuickSearchArray : Array<Array<any>> = []
+  const newQuickSearchArray: Array<Array<any>> = []
   let idx = 0
   preppedSkus.forEach((sku) => {
     const proposedFilename = pattern.reduce((out, field) => out + (field in sku ? sku[field] : ''), '')
@@ -219,8 +218,8 @@ function fallbackSearch(cleanedFileName: string, fileNameWithoutLast: string, pr
   // This function looks for new patterns based on substring matches between filenames and skus
   // If a new pattern is found, it is sent to the outbox for human check and added to the global patterns
 
-  let pattern_found : Array<string> = []
-  let exactMatches : Array<number> = []
+  let pattern_found: Array<string> = []
+  let exactMatches: Array<number> = []
   let currentBestSubstringPatterns: Record<string, Array<number>> = {}
   let maxPatternlength = 0
   preppedSkus.forEach((sku, idx) => {
@@ -232,8 +231,8 @@ function fallbackSearch(cleanedFileName: string, fileNameWithoutLast: string, pr
       }
       return
     }
-    const substrings : Array<string> = []
-    const substringPattern : Array<string> = []
+    const substrings: Array<string> = []
+    const substringPattern: Array<string> = []
     for (const fieldName in sku) {
       const fieldVal = sku[fieldName]
       // Check if any fields are 100% match, then we've discovered a new pattern
@@ -311,7 +310,7 @@ function fallbackSearch(cleanedFileName: string, fileNameWithoutLast: string, pr
   else {
     let matchFound = false
     Object.keys(currentBestSubstringPatterns).every((patternString) => {
-      const uniqueFieldVals : Array<string> = []
+      const uniqueFieldVals: Array<string> = []
       const pattern = patternString.split('-')
       const indexArray = currentBestSubstringPatterns[patternString]
       indexArray.forEach((idx) => {
@@ -390,7 +389,7 @@ function imageBinder(fileNames: Array<string>, filteredSkus: SkuI[], brand: stri
       let matchFound = false
       const cleanedFileName = cleanFilename(fileName)
       const fileNameWithoutLast = checkWithoutLast(fileName)
-      let indicesForFileName : Array<number> = []
+      let indicesForFileName: Array<number> = []
       // Method #1: try quicksearch, an object with patterns as keys and arrays of [proposedFilename, sku] as values
       // based on existing patterns in GLOBAL_PATTERNS
       const quickSearchReturn = testQuickSearch(cleanedFileName, fileName, fileNameWithoutLast, quickSearch, filteredSkus, quickSearchOrder)
@@ -453,17 +452,16 @@ function onlySaveIDFromSkus(matchDict: {}): Record<string, number[]> {
 }
 
 async function testBatch(brand: string) {
-
   const [skusModule, imagesModule, matchedModule] = await Promise.all([
     import(`../test/imageBinderTestData/brandSkus/${brand}.json`),
     import(`../test/imageBinderTestData/brandImages/${brand}.json`),
-    import(`../test/imageBinderTestData/brandDataMatched/${brand}.json`)
+    import(`../test/imageBinderTestData/brandDataMatched/${brand}.json`),
   ])
 
   const fileNames = imagesModule.default
   const filteredSkus = skusModule.default
   const expectedRaw = matchedModule.default
-  
+
   // 1) Call imageBinder
   const t0 = Date.now()
   const imageBinderResult = imageBinder(fileNames, filteredSkus, brand, ['auto'], true)
@@ -493,16 +491,15 @@ async function testBatch(brand: string) {
   }
 
   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,
   }
-
 }
 
 export default { imageBinder, testBatch }

package/src/index.ts

@@ -18,3 +18,19 @@ 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/src/lcAxios.ts

@@ -0,0 +1,349 @@
+/**
+ * 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
+
+function isAxiosError(payload: any): payload is AxiosError {
+  return payload && payload.isAxiosError === true
+}
+
+function mergeDeep(base: any, patch: any): any {
+  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: any = { ...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: AxiosRequestConfig, config: AxiosRequestConfig): AxiosRequestConfig {
+  const m = mergeDeep(mergeDeep({}, defaults), config)
+  const dt = defaults.transformRequest
+  const ct = config.transformRequest
+  if (dt && ct) {
+    m.transformRequest = ([] as any[]).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 = ([] as any[]).concat(Array.isArray(dtr) ? dtr : [dtr]).concat(Array.isArray(ctr) ? ctr : [ctr])
+  }
+  return m
+}
+
+function buildURL(baseURL: string | undefined, url: string | undefined, params?: Record<string, any>): string {
+  const path = joinURL(baseURL, url || '')
+  if (!params || !Object.keys(params).length) return path
+  let u: URL
+  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: string | undefined, url: string): string {
+  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: any, method: string): Record<string, string> {
+  const out: Record<string, string> = {}
+  if (!h) return out
+  const common = h.common || {}
+  const byMethod = (h[method.toLowerCase()] || h[method] || {}) as Record<string, string>
+  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
+}
+
+async function applyTransformRequest(fns: AxiosTransformer | AxiosTransformer[] | undefined, data: any, headers: any): Promise<any> {
+  if (!fns) return data
+  const list = Array.isArray(fns) ? fns : [fns]
+  let d = data
+  for (const fn of list) {
+    d = await Promise.resolve(fn(d, headers))
+  }
+  return d
+}
+
+function applyTransformResponse(fns: AxiosTransformer | AxiosTransformer[] | undefined, data: any, headers: any): any {
+  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: Headers): Record<string, string> {
+  const o: Record<string, string> = {}
+  h.forEach((v, k) => {
+    o[k] = v
+  })
+  return o
+}
+
+export function exponentialDelay(retryNumber = 0): number {
+  const delay = Math.pow(2, retryNumber) * 1000
+  const randomSum = delay * 0.2 * Math.random() * 2 - 1
+  return delay + randomSum
+}
+
+export interface AxiosRetryOptions {
+  retries?: number
+  retryDelay?: (retryCount: number) => number
+  retryCondition?: (error: any) => boolean
+}
+
+export function axiosRetry(instance: any, options: AxiosRetryOptions = {}) {
+  const retries = options.retries ?? 3
+  const retryDelay = options.retryDelay ?? exponentialDelay
+  const retryCondition = options.retryCondition ?? (() => false)
+  const original = instance.request.bind(instance)
+  instance.request = async function axiosRetryRequest(req: AxiosRequestConfig) {
+    let attempt = 0
+    while (true) {
+      try {
+        return await original(req)
+      } catch (err: any) {
+        if (attempt >= retries || !retryCondition(err)) throw err
+        await new Promise((r) => setTimeout(r, retryDelay(attempt)))
+        attempt++
+      }
+    }
+  }
+  return instance
+}
+
+const defaultValidateStatus = (status: number) => status >= 200 && status < 300
+
+function getDefaultDefaults(): AxiosRequestConfig {
+  return {
+    headers: { common: {} },
+    transformRequest: [
+      function defaultTransformRequest(data: any, headers: any) {
+        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' && (Buffer as any).isBuffer?.(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: any) {
+        return data
+      },
+    ],
+  }
+}
+
+export function createAxiosInstance(initialDefaults?: AxiosRequestConfig): any {
+  const defaults: AxiosRequestConfig = initialDefaults
+    ? mergeRequestConfig(mergeDeep({}, getDefaultDefaults()), initialDefaults)
+    : mergeDeep({}, getDefaultDefaults())
+
+  async function dispatchRequest(config: AxiosRequestConfig): Promise<AxiosResponse> {
+    const merged = mergeRequestConfig(defaults, config)
+    const method = (merged.method || 'get').toUpperCase()
+    const url = buildURL(merged.baseURL, merged.url, merged.params)
+    const headers: any = { ...flattenHeaders(merged.headers, method) }
+
+    let data = merged.data
+    data = await applyTransformRequest(merged.transformRequest, data, headers)
+
+    const validateStatus = merged.validateStatus || defaultValidateStatus
+
+    const controller = new AbortController()
+    const t = merged.timeout
+    let timer: any
+    if (t != null && t > 0) {
+      timer = setTimeout(() => controller.abort(), t)
+    }
+
+    const init: RequestInit = {
+      method,
+      headers,
+      signal: controller.signal,
+    }
+    if (merged.withCredentials) {
+      init.credentials = 'include'
+    }
+
+    if (method !== 'GET' && method !== 'HEAD' && data !== undefined) {
+      init.body = data as any
+    }
+
+    let res: Response
+    try {
+      res = await fetch(url, init)
+    } catch (e: any) {
+      if (timer) clearTimeout(timer)
+      const err = new Error(e?.name === 'AbortError' ? 'timeout of ' + t + 'ms exceeded' : 'Network Error') as AxiosError
+      err.isAxiosError = true
+      err.config = merged
+      err.request = { aborted: 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: any
+    if (rt === 'blob') {
+      parsed = await res.blob()
+    } else if (rt === 'arraybuffer') {
+      parsed = await res.arrayBuffer()
+    } else if (rt === 'text') {
+      parsed = await res.text()
+    } else if (ct.includes('application/json')) {
+      // Declared JSON: empty body → null; invalid JSON → raw string (axios-like)
+      const text = await res.text()
+      try {
+        parsed = text ? JSON.parse(text) : null
+      } catch {
+        parsed = text
+      }
+    } else {
+      // Other content-types: still try JSON.parse so mislabeled JSON works; empty body → '' (not null)
+      const text = await res.text()
+      try {
+        parsed = text ? JSON.parse(text) : text
+      } catch {
+        parsed = text
+      }
+    }
+
+    parsed = applyTransformResponse(merged.transformResponse, parsed, resHeaders)
+
+    const response: AxiosResponse = {
+      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) as AxiosError
+      err.isAxiosError = true
+      err.config = merged
+      err.response = response
+      throw err
+    }
+
+    return response
+  }
+
+  const instance: any = function request(configOrUrl: string | AxiosRequestConfig, maybe?: AxiosRequestConfig): Promise<AxiosResponse> {
+    if (typeof configOrUrl === 'string') {
+      return instance.request({ ...(maybe || {}), url: configOrUrl })
+    }
+    return instance.request(configOrUrl)
+  }
+
+  instance.defaults = defaults
+  instance.request = (c: AxiosRequestConfig) => dispatchRequest(mergeRequestConfig(defaults, c))
+  instance.get = (url: string, c?: AxiosRequestConfig) => instance.request({ ...(c || {}), url, method: 'GET' })
+  instance.delete = (url: string, c?: AxiosRequestConfig) => instance.request({ ...(c || {}), url, method: 'DELETE' })
+  instance.head = (url: string, c?: AxiosRequestConfig) => instance.request({ ...(c || {}), url, method: 'HEAD' })
+  instance.post = (url: string, data?: any, c?: AxiosRequestConfig) =>
+    instance.request({ ...(c || {}), url, method: 'POST', data })
+  instance.put = (url: string, data?: any, c?: AxiosRequestConfig) =>
+    instance.request({ ...(c || {}), url, method: 'PUT', data })
+  instance.patch = (url: string, data?: any, c?: AxiosRequestConfig) =>
+    instance.request({ ...(c || {}), url, method: 'PATCH', data })
+  instance.create = (cfg?: AxiosRequestConfig) => createAxiosInstance(mergeRequestConfig(mergeDeep({}, defaults), cfg || {}))
+
+  return instance
+}
+
+const lcAxios = createAxiosInstance()
+
+export default lcAxios
+export { lcAxios, isAxiosError }

package/src/types.ts

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