@codeleap/utils 4.3.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@codeleap/utils",
+  "version": "4.3.0",
+  "main": "src/index.ts",
+  "license": "UNLICENSED",
+  "repository": {
+    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
+    "type": "git",
+    "directory": "packages/utils"
+  },
+  "devDependencies": {
+    "@codeleap/config": "4.3.0",
+    "@codeleap/types": "4.3.0",
+    "ts-node-dev": "1.1.8"
+  },
+  "scripts": {
+    "build": "echo 'No build needed'"
+  },
+  "peerDependencies": {
+    "@codeleap/types": "4.3.0",
+    "axios": "^1.7.9",
+    "typescript": "5.0.4",
+    "react": "18.1.0",
+    "@tanstack/react-query": "5.60.6"
+  },
+  "dependencies": {
+    "tinycolor2": "^1.4.2",
+    "deep-equal": "^2.0.5"
+  }
+}

package/package.json.bak

@@ -0,0 +1,30 @@
+{
+  "name": "@codeleap/utils",
+  "version": "4.3.0",
+  "main": "src/index.ts",
+  "license": "UNLICENSED",
+  "repository": {
+    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
+    "type": "git",
+    "directory": "packages/utils"
+  },
+  "devDependencies": {
+    "@codeleap/config": "workspace:*",
+    "@codeleap/types": "workspace:*",
+    "ts-node-dev": "1.1.8"
+  },
+  "scripts": {
+    "build": "echo 'No build needed'"
+  },
+  "peerDependencies": {
+    "@codeleap/types": "workspace:*",
+    "axios": "^1.7.9",
+    "typescript": "5.0.4",
+    "react": "18.1.0",
+    "@tanstack/react-query": "5.60.6"
+  },
+  "dependencies": {
+    "tinycolor2": "^1.4.2",
+    "deep-equal": "^2.0.5"
+  }
+}

package/src/array.ts

@@ -0,0 +1,51 @@
+import { FunctionType } from '@codeleap/types'
+
+type GetterFunction<T> = FunctionType<[T, number], string | number> | keyof T
+
+export function objectFromArray<T, Getter extends GetterFunction<T>>(
+  arr: T[],
+  keyAccessor?: Getter,
+): Record<string, T> {
+  let getObjectKey = (_, idx) => idx
+
+  if (keyAccessor) {
+    switch (typeof keyAccessor) {
+      case 'string':
+        getObjectKey = (value) => value[keyAccessor]
+        break
+      case 'function':
+        getObjectKey = keyAccessor
+        break
+    }
+  }
+
+  const indexedMap = arr.map((value, idx) => [getObjectKey(value, idx), value])
+
+  return Object.fromEntries(indexedMap)
+}
+
+export function uniqueArrayByProperty<T, G extends GetterFunction<T>>(
+  array: T[],
+  getProperty: G,
+) {
+  return Object.values(objectFromArray(array, getProperty))
+}
+
+export function flatten<T extends unknown>(arr: T[]) {
+  let newArr = [] as T[]
+
+  arr.forEach((item) => {
+    if (Array.isArray(item)) {
+      newArr = [...newArr, ...flatten(item)]
+    } else {
+      newArr.push(item)
+    }
+  })
+
+  return newArr
+}
+
+export function range(start: number, end: number) {
+  const length = end - start + 1
+  return Array.from({ length }, (_, index) => index + start)
+}

package/src/cloneDeep.ts

@@ -0,0 +1,43 @@
+export function cloneDeep(value) {
+  if (value === null || typeof value !== 'object') {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(cloneDeep)
+  }
+
+  if (value instanceof Date) {
+    return new Date(value.getTime())
+  }
+
+  if (value instanceof Map) {
+    const clonedMap = new Map()
+    value.forEach((v, k) => {
+      clonedMap.set(k, cloneDeep(v))
+    })
+    return clonedMap
+  }
+
+  if (value instanceof Set) {
+    const clonedSet = new Set()
+    value.forEach((v) => {
+      clonedSet.add(cloneDeep(v))
+    })
+    return clonedSet
+  }
+
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags)
+  }
+
+  const clonedObj = {}
+
+  for (const key in value) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      clonedObj[key] = cloneDeep(value[key])
+    }
+  }
+
+  return clonedObj
+}

package/src/colors.ts

@@ -0,0 +1,47 @@
+import tinycolor from 'tinycolor2'
+import { TypeGuards } from '@codeleap/types'
+
+export function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
+  return result
+    ? {
+      r: parseInt(result[1], 16),
+      g: parseInt(result[2], 16),
+      b: parseInt(result[3], 16),
+    }
+    : null
+}
+
+const shadeColorCache = {}
+export function shadeColor(color: string, percent = 0, opacity = null) {
+  const _color = color.trim()
+  const serialParams = [_color, percent.toString()]
+  if (TypeGuards.isNumber(opacity)) {
+    serialParams.push(opacity.toString())
+  }
+  const cacheKey = serialParams.join('/')
+
+  if (!!shadeColorCache[cacheKey]) {
+    return shadeColorCache[cacheKey]
+  }
+  const cl = tinycolor(_color)
+  if (percent !== 0) {
+
+    const shouldDarken = percent < 0
+
+    if (shouldDarken) {
+      cl.darken(-percent)
+    } else {
+      cl.lighten(percent)
+    }
+  }
+  if (TypeGuards.isNumber(opacity)) {
+    cl.setAlpha(opacity)
+
+  }
+
+  const rgbObj = cl.toRgb()
+  const rgbStr = `rgba(${rgbObj.r},${rgbObj.g},${rgbObj.b},${rgbObj.a})`
+  shadeColorCache[cacheKey] = rgbStr
+  return rgbStr
+}

package/src/faker.ts

@@ -0,0 +1,34 @@
+const names = [
+  'James', 'John', 'Robert', 'Michael', 'William', 'David', 'Richard', 'Joseph', 'Thomas',
+  'Charles', 'Christopher', 'Daniel', 'Matthew', 'Anthony', 'Donald', 'Mark', 'Paul', 'Steven',
+  'Andrew', 'Kenneth', 'Joshua', 'Kevin', 'Brian', 'George', 'Edward', 'Ronald', 'Timothy',
+  'Jason', 'Jeffrey', 'Ryan', 'Gary', 'Jacob'
+]
+
+const surnames = [
+  'Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis',
+  'Lopez', 'Wilson', 'Anderson', 'Thomas', 'Taylor', 'Moore',
+  'Jackson', 'Martin', 'Lee', 'Perez', 'Thompson', 'White', 'Harris', 'Sanchez', 'Clark',
+  'Ramirez', 'Lewis', 'Robinson', 'Walker', 'Young', 'Allen', 'King', 'Wright', 'Scott', 'Torres',
+]
+
+const animals = [
+  'lion', 'tiger', 'zebra', 'panda', 'koala', 'bear',
+  'wolf', 'fox', 'rabbit', 'bat', 'spider', 'frog', 'shark'
+]
+
+function getRandom(list: Array<string>) {
+  return list[Math.floor(Math.random() * list.length)]
+}
+
+function number(min: number = 0, max: number = 100) {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+export const faker = {
+  lastName: () => getRandom(surnames),
+  firstName: () => getRandom(names),
+  animal: () => getRandom(animals),
+  number,
+  name: () => `${getRandom(names)} ${getRandom(surnames)}`
+}

package/src/file.ts

@@ -0,0 +1,23 @@
+const separators = /[\\\/]+/
+
+export function parseFilePathData(path: string) {
+  const parts = path.split(separators)
+
+  const lastPart = parts[parts.length - 1]
+
+  let fileName = lastPart
+  let ext = ''
+
+  if (lastPart.includes('.')) {
+    const dotIdx = fileName.lastIndexOf('.')
+    fileName = fileName.substring(0, dotIdx)
+
+    ext = lastPart.substring(dotIdx + 1)
+  }
+
+  return {
+    path: parts.slice(0, -1).join('/'),
+    extension: ext,
+    name: fileName,
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './array'
+export * from './colors'
+export * from './misc'
+export * from './object'
+export * from './react'
+export * from './file'
+export * from './string'
+export * from './faker'
+export * from './cloneDeep'

package/src/misc.ts

@@ -0,0 +1,134 @@
+import { capitalize } from './string'
+import { StylesOf } from '@codeleap/types'
+
+export function imagePathToFileObject(imagePath: string | null) {
+  const parts = imagePath ? imagePath.split('.') : ''
+
+  const ext = imagePath ? parts[parts.length - 1].toLowerCase() : ''
+
+  const fileValue = imagePath
+    ? {
+      uri: imagePath,
+      name: 'image_' + imagePath,
+      type: `image/${ext}`,
+    }
+    : null
+
+  return fileValue
+}
+
+const letterToColorMap = {
+  a: '#7CB9E8',
+  b: '#3a9e77',
+  c: '#A3C1AD',
+  d: '#E1BD27',
+  e: '#badc58',
+  f: '#db5970',
+  g: '#9b8ef1',
+  h: '#ffe169',
+  i: '#3ea9d1',
+  j: '#8aa341',
+  k: '#baf2f5',
+  l: '#ffa02d',
+  m: '#d46830',
+  n: '#62ecaa',
+  o: '#ffbe50',
+  p: '#0078D7',
+  q: '#8764B8',
+  r: '#52dd64',
+  s: '#7edce9',
+  t: '#dadd5d',
+  u: '#e9b55d',
+  v: '#99d669',
+  w: '#a3c83a',
+  x: '#f28d67',
+  y: '#ea82ec',
+  z: '#ff8295',
+}
+
+export function matchInitialToColor(anyString?: string) {
+  if (!anyString) return '#999999'
+  return letterToColorMap[anyString.toLowerCase().charAt(0)] || '#999999'
+}
+
+export function waitFor(ms) {
+  return new Promise<void>((resolve) => {
+    setTimeout(() => {
+      resolve()
+    }, ms)
+  })
+}
+
+type ParseSourceUrlArg = {
+  source?: string
+  src?: string
+}
+
+export function parseSourceUrl(args: string, Settings?: any): string
+export function parseSourceUrl(
+  args: ParseSourceUrlArg,
+  Settings?: any
+): string
+export function parseSourceUrl(
+  args: ParseSourceUrlArg | string,
+  Settings?: any,
+): string {
+  if (!args) return null
+
+  let res = ''
+  let address = ''
+  if (typeof args === 'string') {
+    address = args
+  } else {
+    address = args.source || args.src || ''
+  }
+
+  if (address && address.startsWith('/media/')) {
+    const tmp = address.substr(1, address.length)
+    res = `${Settings.BaseURL}${tmp}`
+  } else if (address) {
+    res = address
+  } else {
+    res = `https://picsum.photos/600?random=${Math.random() * 100}`
+  }
+  return res
+}
+
+export function getNestedStylesByKey<T extends StylesOf<any>>(match:string, variantStyles: T) {
+  const styles = {}
+
+  for (const [key, value] of Object.entries(variantStyles)) {
+
+    if (key.startsWith(match)) {
+      const partName = capitalize(key.replace(match, ''), true)
+      styles[partName] = value
+    }
+  }
+
+  return styles
+}
+
+export function hasFastRefreshed(Settings: any) {
+  if (Settings?.Environment?.InitTime) {
+    const timeFromStartup = (new Date()).getTime() - Settings.Environment.InitTime.getTime()
+    // It usually takes less than a seconds (~300ms) from app launch to running this, so if's been more than that we've probably fast refreshed
+    const fastRefreshed = Settings.Environment.IsDev && timeFromStartup > 1000
+    return fastRefreshed
+  } else {
+    console.log('hasFreshRefreshed() => Missing datetime from settings, please include to make this work')
+    return undefined
+  }
+}
+
+const throttleTimerId = []
+
+export function throttle(func, ref, delay) {
+  if (throttleTimerId[ref]) {
+    return
+  }
+
+  throttleTimerId[ref] = setTimeout(function () {
+    func()
+    throttleTimerId[ref] = undefined
+  }, delay)
+}

package/src/object.ts

@@ -0,0 +1,162 @@
+import { FunctionType, AppSettings } from '@codeleap/types'
+
+export function deepMerge(base = {}, changes = {}): any {
+  const obj = {
+    ...base,
+  }
+  let changeEntries = []
+  try {
+    changeEntries = Object.entries(changes)
+  } catch (e) {
+    return changes
+  }
+
+  for (const [key, value] of changeEntries) {
+    obj[key] =
+      typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)
+        ? deepMerge(obj[key], changes[key])
+        : value
+  }
+
+  return obj
+}
+
+export function mapObject<T>(
+  obj: T,
+  callback: FunctionType<[[keyof T, T[keyof T]]], any>,
+) {
+  return Object.entries(obj).map((args) => callback(args as [keyof T, T[keyof T]]),
+  )
+}
+
+export const deepSet = ([path, value]) => {
+  const parts = path.split('.')
+  const newObj = Array.isArray(value) ? [] : {}
+
+  if (parts.length === 1) {
+    newObj[parts[0]] = value
+  } else {
+    newObj[parts[0]] = deepSet([parts.slice(1).join('.'), value])
+  }
+
+  return newObj
+}
+
+export const deepGet = (path, obj) => {
+  const parts = path.split('.')
+  let newObj = { ...obj }
+
+  for (const prop of parts) {
+    newObj = newObj[prop]
+  }
+
+  return newObj
+}
+
+export function objectPaths(obj) {
+  let paths = []
+
+  Object.entries(obj).forEach(([key, value]) => {
+    if (!Array.isArray(value) && typeof value === 'object') {
+      paths = [...paths, ...objectPaths(value).map((k) => `${key}.${k}`)]
+    } else {
+      paths.push(key)
+    }
+  })
+
+  return paths
+}
+
+export function isValuePrimitive(a:any) {
+  return ['string', 'number', 'boolean'].includes(typeof a)
+}
+
+export function optionalObject(condition: boolean, ifTrue: any, ifFalse: any) {
+  return condition ? ifTrue : ifFalse
+}
+
+type TraverseRecArgs = {path:string[]; value: any; depth: number; key: string; type: string; primitive: boolean}
+
+type TraverseCallback = (args?: TraverseRecArgs) => {stop?: boolean } | void
+
+export function traverse(obj = {}, callback:TraverseCallback, args?: TraverseRecArgs) {
+  const isPrimitive = isValuePrimitive(obj)
+
+  const info = {
+    path: [],
+    depth: 0,
+    key: '',
+    type: typeof obj,
+    value: obj,
+    primitive: isPrimitive,
+    ...args,
+  }
+
+  if (isPrimitive) {
+    callback({
+      ...info,
+      depth: info.depth,
+
+    })
+  } else {
+    for (const [key, value] of Object.entries(obj || {})) {
+      const isPrimitive = isValuePrimitive(value)
+
+      if (!isPrimitive) {
+
+        callback({
+          ...info,
+          key,
+          value,
+          type: typeof value,
+          primitive: isPrimitive,
+          path: [...info.path, key],
+        })
+      }
+
+      traverse(value, callback, {
+        ...info,
+        key,
+        value,
+        type: typeof value,
+        primitive: isValuePrimitive(value),
+        path: [...info.path, key],
+        depth: info.depth + 1,
+      })
+    }
+  }
+}
+
+export function createSettings<T extends AppSettings>(a:T): T {
+  return a
+}
+
+export function extractKey(obj:any) {
+  if (obj.id) {
+    return obj.id
+  }
+}
+
+export function objectPickBy<K extends string = string, P = any>(obj: Record<K, P>, predicate: (valueKey: P, key: K) => boolean) {
+  const result = {} as Record<K, P>
+
+  for (const key in obj) {
+    if (obj?.hasOwnProperty?.(key) && predicate?.(obj?.[key], key)) {
+      result[key] = obj?.[key]
+    }
+  }
+
+  return result
+}
+
+export function transformObject<K extends string = string, T extends string = string>(obj: Record<K, T>, predicate: (value: T, key: K) => [K, T]): Record<string, any> {
+  const result = {}
+
+  for (const key in obj) {
+    const [newKey, newValue] = predicate?.(obj?.[key], key)
+
+    result[newKey as string] = newValue
+  }
+
+  return result
+}

package/src/react.tsx

@@ -0,0 +1,107 @@
+import equals from 'deep-equal'
+import React from 'react'
+import { TypeGuards } from '@codeleap/types'
+
+export const deepEqual = equals
+
+type ArePropsEqualOptions<MergedObject> = {
+  check: (keyof MergedObject)[]
+  excludeKeys?: string[]
+}
+
+export function arePropsEqual<A, B>(
+  previous: A,
+  next: B,
+  options: ArePropsEqualOptions<A & B>,
+) {
+  const { check, excludeKeys = [] } = options
+
+  for (const c of check) {
+    const nextItem = next[c as string]
+    const prevItem = previous[c as string]
+
+    for (const key of excludeKeys) {
+      if (nextItem?.[key]) delete nextItem[key]
+      if (prevItem?.[key]) delete prevItem[key]
+    }
+
+    const propsAreEqual = equals(nextItem, prevItem)
+
+    if (!propsAreEqual) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export const flattenChildren = (children, flat = []) => {
+  flat = [...flat, ...React.Children.toArray(children)]
+
+  if (children.props && children.props.children) {
+    return flattenChildren(children.props.children, flat)
+  }
+
+  return flat
+}
+
+export const simplifyChildren = children => {
+  const flat = flattenChildren(children)
+
+  return flat.map(
+    ({
+      key,
+      ref,
+      type,
+      props: {
+        children,
+        ...props
+      },
+    }) => ({
+      key, ref, type, props,
+    }),
+  )
+}
+
+export function getRenderedComponent<P = any>(
+  ComponentOrProps: React.ComponentType<P> | P | React.ReactNode | null | undefined,
+  DefaultComponent: React.ComponentType<P>,
+  props?: P,
+): React.ReactNode {
+  if (TypeGuards.isNil(ComponentOrProps) || Object.keys(ComponentOrProps).length === 0) {
+    return null
+  }
+
+  if (TypeGuards.isFunction(ComponentOrProps)) {
+    return <ComponentOrProps {...props} />
+  }
+
+  if (React.isValidElement(ComponentOrProps)) {
+    return ComponentOrProps
+  }
+
+  const _props = ComponentOrProps as P
+
+  return <DefaultComponent {...props} {..._props} />
+}
+
+export function memoize<P extends object>(ComponentToMemoize: React.FunctionComponent<P>): React.NamedExoticComponent<P> {
+  return React.memo(ComponentToMemoize, () => true)
+}
+
+export function memoChecker<P>(prop: keyof P, prevProps: P, nextProps: P): boolean {
+  const nextItem = nextProps[prop]
+  const prevItem = prevProps[prop]
+
+  return equals(nextItem, prevItem)
+}
+
+export function memoBy<P extends object>(
+  ComponentToMemoize: React.FunctionComponent<P>,
+  check: keyof P | Array<keyof P>
+): React.NamedExoticComponent<P> {
+  return React.memo(ComponentToMemoize, (prevProps, nextProps) => {
+    const checks = Array.isArray(check) ? check : [check]
+    return checks.every((key) => memoChecker(key, prevProps, nextProps))
+  })
+}

package/src/string.ts

@@ -0,0 +1,49 @@
+export function singleLine(text: string) {
+  return text?.replace(/\n/g, ' ')
+}
+
+export function stringiparse(string) {
+  return JSON.parse(JSON.stringify(string))
+}
+
+export function capitalize(str: string, reverse = false) {
+  if (!str.length) return str
+  const firstChar = reverse ? str[0].toLowerCase() : str[0].toUpperCase()
+  return firstChar + str.substring(1)
+}
+
+export function isUppercase(char: string) {
+  return /[A-Z]|[\u0080-\u024F]/.test(char) && char.toUpperCase() === char
+}
+
+export function isLowercase(char: string) {
+  return !isUppercase(char)
+}
+
+export function humanizeCamelCase(str: string) {
+  const characters = []
+  let previousCharacter = ''
+  str.split('').forEach((char, idx) => {
+    if (idx === 0) {
+      characters.push(char.toUpperCase())
+    } else {
+      if (isUppercase(char) && isLowercase(previousCharacter)) {
+        characters.push(` ${char}`)
+      } else {
+        characters.push(char)
+      }
+    }
+
+    previousCharacter = char
+  })
+
+  return characters.join('')
+}
+
+export function ellipsis(str: string, maxLen: number) {
+  if (str.length - 3 > maxLen) {
+    return str.slice(0, maxLen - 3) + '...'
+  }
+
+  return str
+}