@companix/utils-js 0.0.1 → 0.0.12

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@companix/utils-js",
-  "version": "0.0.1",
+  "version": "0.0.12",
   "main": "dist/bundle.cjs.js",
   "module": "dist/bundle.esm.js",
   "types": "./src/index.ts",
   "author": "Pavel Victorov",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "rm -rf dist && rollup --config rollup.config.ts --configPlugin @rollup/plugin-typescript --bundleConfigAsCjs"
   },

package/rollup.config.ts

@@ -1,40 +0,0 @@
-import resolve from '@rollup/plugin-node-resolve'
-import typescript from '@rollup/plugin-typescript'
-import terser from '@rollup/plugin-terser'
-import strip from '@rollup/plugin-strip'
-import autoExternal from 'rollup-plugin-auto-external'
-
-export default [
-  // EcmaScript Module (esm) build
-  {
-    input: './src/index.ts',
-    output: {
-      file: 'dist/bundle.esm.js',
-      format: 'esm'
-    },
-    external: ['react', 'react-dom'],
-    plugins: [
-      typescript({ tsconfig: './tsconfig.json', noEmitOnError: true }),
-      autoExternal(),
-      resolve(),
-      strip(),
-      terser()
-    ]
-  },
-  // CommonJS (cjs) build
-  {
-    input: './src/index.ts',
-    output: {
-      file: 'dist/bundle.cjs.js',
-      format: 'cjs'
-    },
-    external: ['react', 'react-dom'],
-    plugins: [
-      typescript({ tsconfig: './tsconfig.json', noEmitOnError: true }),
-      autoExternal(),
-      resolve(),
-      strip(),
-      terser()
-    ]
-  }
-]

package/src/array.ts

@@ -1,55 +0,0 @@
-/**
- * Генерирует массив с диапазоном чисел. Взято с VKUI
- */
-export const range = (from: number, to: number, step = 1) => {
-  const direction = from < to ? 1 : -1
-  const distance = Math.abs(from - to) + 1
-  const arrayLength = Math.ceil(distance / step)
-
-  const arr = Array<number>(arrayLength)
-  for (let index = 0; index < arr.length; index++) {
-    arr[index] = from + index * step * direction
-  }
-
-  return arr
-}
-
-export const splitByChunks = <T>(items: T[], chunkSize: number): T[][] => {
-  const result: T[][] = []
-
-  for (let i = 0; i < items.length; i += chunkSize) {
-    result.push(items.slice(i, i + chunkSize))
-  }
-
-  return result
-}
-
-export const separateArray = <T>(array: T[], parts: number): T[][] => {
-  if (parts <= 0) throw new Error('Number of parts must be greater than 0')
-
-  const result: T[][] = []
-  const partSize = Math.floor(array.length / parts)
-  let remainder = array.length % parts
-  let start = 0
-
-  for (let i = 0; i < parts; i++) {
-    // Распределяем остаток по первым частям
-    const extra = remainder > 0 ? 1 : 0
-    const end = start + partSize + extra
-    const data = array.slice(start, end)
-
-    if (data.length > 0) {
-      result.push(data)
-    }
-
-    start = end
-    remainder--
-  }
-
-  return result
-}
-
-export const roundSeparateArray = <T>(array: T[], size: number): T[][] => {
-  const n = Math.round(array.length / size)
-  return n > 1 ? separateArray(array, n) : [array]
-}

package/src/bytes.ts

@@ -1,13 +0,0 @@
-export const formatBytes = (bytes: number) => {
-  const KB = bytes / 1024
-
-  if (KB > 1024) {
-    return +(KB / 1024).toFixed(1) + ' MB'
-  }
-
-  if (KB < 1) {
-    return bytes + ' B'
-  }
-
-  return Math.trunc(+KB.toFixed(2)) + ' KB'
-}

package/src/candle.ts

@@ -1,20 +0,0 @@
-export type Interval = '1s' | '1m' | '3m' | '5m'
-
-export const intervals = {
-  '1s': 1000,
-  '1m': 1000 * 60,
-  '3m': 1000 * 60 * 3,
-  '5m': 1000 * 60 * 5
-}
-
-export const getLastClosedCandleTime = (timestamp: number, interval: Interval) => {
-  return getCurrentCandleTime(timestamp, interval) - intervals[interval]
-}
-
-export const getCurrentCandleTime = (timestamp: number, interval: Interval) => {
-  return Math.floor(timestamp / intervals[interval]) * intervals[interval]
-}
-
-export const getNextCandleTime = (timestamp: number, interval: Interval) => {
-  return getCurrentCandleTime(timestamp, interval) + intervals[interval]
-}

package/src/colors.ts

@@ -1,32 +0,0 @@
-export const applyAlphaToHex = (hex: string, opacity: number) => {
-  if (hex.startsWith('#')) {
-    hex = hex.slice(1)
-  }
-
-  const r = parseInt(hex.slice(0, 2), 16)
-  const g = parseInt(hex.slice(2, 4), 16)
-  const b = parseInt(hex.slice(4, 6), 16)
-  const alpha = Math.max(0, Math.min(100, opacity)) / 100
-
-  return `rgba(${r}, ${g}, ${b}, ${alpha})`
-}
-
-export const rgbaToHex = (rgba: string) => {
-  // Извлекаем значения с помощью регулярного выражения
-  const match = rgba.match(/rgba?\s*\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*([\d.]+)\s*\)/)
-
-  if (!match) {
-    throw new Error('Некорректный формат RGBA')
-  }
-
-  const [, r, g, b, a] = match
-
-  const toHex = (n: string) => {
-    const hex = parseInt(n).toString(16)
-    return hex.padStart(2, '0')
-  }
-
-  const alpha = Math.round(parseFloat(a) * 255)
-
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}${toHex(alpha.toString())}`
-}

package/src/emiters.ts

@@ -1,83 +0,0 @@
-export class EventDispatcher<T> {
-  private store: Record<string, (data: T) => void> = {}
-
-  emit(event: string, data: T) {
-    if (this.store[event]) {
-      this.store[event](data)
-    }
-  }
-
-  on(event: string, callback: (data: T) => void) {
-    this.store[event] = callback
-
-    return () => {
-      this.rm(event)
-    }
-  }
-
-  rm(event: string) {
-    delete this.store[event]
-  }
-}
-
-export class EventEmmiter<T> {
-  private store: Record<string, ((data: T) => void)[]> = {}
-
-  emit(event: string, data: T) {
-    if (this.store[event]) {
-      this.store[event].forEach((callback) => callback(data))
-    }
-  }
-
-  subscribe(event: string, callback: (data: T) => void) {
-    if (!this.store[event]) {
-      this.store[event] = []
-    }
-
-    this.store[event].push(callback)
-
-    return () => {
-      this.unsubscribe(event, callback)
-    }
-  }
-
-  unsubscribe(event: string, callback: (data: T) => void) {
-    if (this.store[event]) {
-      const index = this.store[event].findIndex((u) => u === callback)
-
-      if (index !== -1) {
-        this.store[event].splice(index, 1)
-
-        if (this.store[event].length === 0) {
-          delete this.store[event]
-        }
-      }
-    }
-  }
-}
-
-export class EventBroadcaster<T> {
-  public subscribers: ((data: T) => void)[] = []
-
-  emit(data: T) {
-    this.subscribers.forEach((callback) => {
-      callback(data)
-    })
-  }
-
-  subscribe(callback: (data: T) => void) {
-    this.subscribers.push(callback)
-
-    return () => {
-      this.unsubscribe(callback)
-    }
-  }
-
-  unsubscribe(callback: (data: T) => void) {
-    const index = this.subscribers.findIndex((u) => u === callback)
-
-    if (index !== -1) {
-      this.subscribers.splice(index, 1)
-    }
-  }
-}

package/src/http-api.ts

@@ -1,43 +0,0 @@
-import axios, { AxiosInstance, AxiosRequestConfig, CreateAxiosDefaults } from 'axios'
-
-export type IOpattern<T extends IOpattern<T>> = {
-  [key in keyof T]: {
-    params: T[key]['params']
-    answer: T[key]['answer']
-  }
-}
-
-enum HttpVerb {
-  Get = 'GET',
-  Post = 'POST'
-}
-
-interface RequestInterface {
-  url: string
-  body?: any
-  config?: AxiosRequestConfig
-  method: HttpVerb
-}
-
-export class HttpAPI<T extends IOpattern<T>> {
-  public http: AxiosInstance
-
-  constructor(config: CreateAxiosDefaults) {
-    this.http = axios.create(config)
-  }
-
-  private async request<T>(props: RequestInterface): Promise<T> {
-    const { url, body = {}, method, config = {} } = props
-    const dataAtt = method === HttpVerb.Get ? 'params' : 'data'
-
-    return this.http({ url, method, [dataAtt]: body, ...config }).then(({ data }) => data)
-  }
-
-  post<K extends keyof T>(url: K, body: T[K]['params'], config?: AxiosRequestConfig) {
-    return this.request<T[K]['answer']>({ method: HttpVerb.Post, url: url as string, config, body })
-  }
-
-  get<K extends keyof T>(url: K, body: T[K]['params'], config?: AxiosRequestConfig) {
-    return this.request<T[K]['answer']>({ method: HttpVerb.Get, url: url as string, config, body })
-  }
-}

package/src/http-headers.ts

@@ -1,34 +0,0 @@
-interface Headers {
-  Authorization?: string
-  'Content-Type': string
-}
-
-interface Options {
-  multipart?: boolean
-  token?: string
-  tokenStore?: string
-}
-
-export const getHeaders = ({ token, tokenStore, multipart }: Options = {}): Headers => {
-  const Authorization = getAuthToken(token, tokenStore)
-
-  const headers: Headers = {
-    'Content-Type': multipart ? 'multipart/form-data; charset=utf-8' : 'application/json'
-  }
-
-  if (Authorization) {
-    headers.Authorization = Authorization
-  }
-
-  return headers
-}
-
-export const getAuthToken = (token?: string, tokenStore: string = 'token') => {
-  const value = token ?? localStorage.getItem(tokenStore)
-
-  if (value) {
-    return `Bearer ${value}`
-  }
-
-  return ''
-}

package/src/http-upload.ts

@@ -1,23 +0,0 @@
-export const transport = (file: Blob) => {
-  const data = new FormData()
-
-  data.append('file', file)
-  data.append('type', 'file')
-
-  return data
-}
-
-export const generatePreview = (file: File) => {
-  const url = URL.createObjectURL(file)
-
-  return {
-    url,
-    destroy: () => {
-      URL.revokeObjectURL(url)
-    }
-  }
-}
-
-export const getFiles = (files: FileList) => {
-  return Array.from(files)
-}

package/src/index.ts

@@ -1,17 +0,0 @@
-export * from './array'
-export * from './colors'
-export * from './emiters'
-export * from './number'
-export * from './object'
-export * from './queue'
-export * from './random'
-export * from './utils'
-export * from './http-api'
-export * from './http-headers'
-export * from './http-upload'
-export * from './money'
-export * from './nouns'
-export * from './regex'
-export * from './bytes'
-export * from './time'
-export * from './candle'

package/src/money.ts

@@ -1,31 +0,0 @@
-export const bigMoneyAmount = (amount: number) => {
-  const thousand = amount / 1000
-
-  if (thousand >= 1000) {
-    const million = thousand / 1000
-
-    if (million >= 1000) {
-      return `${million / 1000} МЛРД. ₽`
-    }
-
-    return `${million} МЛН. ₽`
-  }
-
-  return `${thousand} ТЫС. ₽`
-}
-
-interface CurrencyOptions {
-  noPennies?: boolean
-}
-
-export const rubles = (num: number, options?: CurrencyOptions) => {
-  return num.toLocaleString('ru-RU', {
-    style: 'currency',
-    currency: 'RUB',
-    ...(options?.noPennies ? { minimumFractionDigits: 0, maximumFractionDigits: 0 } : {})
-  })
-}
-
-export const dollars = (value: number, options?: CurrencyOptions) => {
-  return value.toLocaleString('us-US', { style: 'currency', currency: 'USD' })
-}

package/src/nouns.ts

@@ -1,16 +0,0 @@
-// https://gist.github.com/tomfun/830fa6d8030d16007bbab50a5b21ef97
-export const getNoun = (number: number, one: string, two: string, five: string) => {
-  let n = Math.abs(number)
-  n %= 100
-  if (n >= 5 && n <= 20) {
-    return five
-  }
-  n %= 10
-  if (n === 1) {
-    return one
-  }
-  if (n >= 2 && n <= 4) {
-    return two
-  }
-  return five
-}

package/src/number.ts

@@ -1,81 +0,0 @@
-export const getFloatDigits = (value: string) => {
-  if (value.includes('e')) {
-    const [int, exp] = value.split('e')
-    return Math.max((int.split('.')[1]?.length || 0) - +exp, 0)
-  }
-
-  return value.split('.')[1]?.length || 0
-}
-
-/**
- * не используйте normalize для округления, когда требуемая точность меньше точности входного значения
- *
- * ❌ normalize(0.000020025, 8) -> 0.00002002
- * ❌ normalize(0.000022025, 8) -> 0.00002203 (!)
- *
- * использование normalize безопасно в случаях нормализации значения: normalize(a + b, precision), если a и b с точностью precision
- *
- * ✅ normalize(0.000020025, 9) -> 0.000020025
- * ✅ normalize(0.000022025, 9) -> 0.000022025
- *
- * 0.1 + 0.2 -> 0.30000000000000004 (10^1) -> 3.0000000000000004 -> (round) 3
- * 0.0001 + 0.0003 -> 0.00039999999999999996 -> (10^4) -> 3.9999999999999996 -> (round) 4
- *
- *  работает корректно до precision <= 22. После: 123 / (10 ** 23) -> 1.2300000000000002e-21
- */
-
-export const normalize = (value: number, precision: number) => {
-  const factor = Math.pow(10, precision)
-  return Math.round(value * factor) / factor // 0.000020025 * 10^8 -> 2002.4999999999998
-}
-
-export const cutNumber = (value: number, precision: number) => {
-  const factor = Math.pow(10, precision)
-  return Math.floor(value * factor) / factor
-}
-
-export const roundUp2 = (value: number, precision: number) => {
-  const result = value.toFixed(precision)
-
-  if (value > +result) {
-    return normalize(+result + +getPrecisionStep(precision), precision)
-  }
-
-  return +result
-}
-
-export const truncateNumber = (value: number, precision: number) => {
-  const result = value.toFixed(precision)
-
-  if (+result > value) {
-    return (+result - Math.sign(value) * Math.pow(0.1, precision)).toFixed(precision)
-  }
-
-  return result
-}
-
-export const getPrecisionStep = (precision: number, digit: number = 1) => {
-  if (precision > 0) {
-    return [0, '.', ...new Array(precision - 1).fill(0), digit].join('')
-  }
-
-  return `${digit}`
-}
-
-export const isValidPrecision = (value: number, precision: number) => {
-  const num = value.toString()
-
-  if (num.includes('.')) {
-    if (precision === 0) {
-      return false
-    }
-
-    return num.split('.')[1].length <= precision
-  }
-
-  return true
-}
-
-export const getNum = (value: string) => {
-  return isNaN(Number(value)) ? null : +value
-}

package/src/object.ts

@@ -1,32 +0,0 @@
-export const keys = (object: object) => {
-  return Object.keys(object)
-}
-
-export const keysLength = (object: object) => {
-  return keys(object).length
-}
-
-export const isEmpty = (obj: object) => {
-  for (const _ in obj) {
-    return false
-  }
-
-  return true
-}
-
-export const omit = <T extends object>(object: T, key: keyof T) => {
-  delete object[key]
-  return object
-}
-
-export const partial = <T extends object>(object: T): T => {
-  const response = {} as T
-
-  for (const key in object) {
-    if (object[key]) {
-      response[key] = object[key]
-    }
-  }
-
-  return response
-}

package/src/queue.ts

@@ -1,38 +0,0 @@
-interface Subject {
-  resolve: (value: any) => void
-  reject: (reason?: any) => void
-  target: () => Promise<any>
-}
-
-export class QueueManager {
-  private active: boolean = false
-  private queue: Subject[] = []
-
-  add<T>(target: () => Promise<T>): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      this.queue.push({ resolve, reject, target })
-
-      if (!this.active) {
-        this.next()
-      }
-    })
-  }
-
-  private async next() {
-    const subject = this.queue[0]
-
-    if (subject) {
-      this.active = true
-
-      await subject
-        .target()
-        .then((data) => subject.resolve(data))
-        .catch((e) => subject.reject(e))
-        .finally(() => this.queue.shift())
-
-      await this.next()
-    } else {
-      this.active = false
-    }
-  }
-}

package/src/random.ts

@@ -1,49 +0,0 @@
-export const generateCode = (size: number) => {
-  const characters = 'A0B1C2D3E4F5G6H7W89K0L1M2N34P5Q6R7S8T9U0V3XYZ' // 33 uniq symbols
-  const result: string[] = []
-
-  for (let i = 0; i < size; i++) {
-    const randomIndex = Math.floor(Math.random() * characters.length)
-    result.push(characters[randomIndex])
-  }
-
-  return result.join('')
-}
-
-export const getRandomInt = (min: number, max: number) => {
-  return Math.floor(Math.random() * (max - min + 1)) + min
-}
-
-export const getRandomIntString = (n: number) => {
-  return new Array(n)
-    .fill(0)
-    .map(() => getRandomInt(0, 9))
-    .join('')
-}
-
-export const hash = () => {
-  const d = typeof performance === 'undefined' ? Date.now() : performance.now() * 1000
-
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16 + d) % 16 | 0
-
-    return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16)
-  })
-}
-
-interface ArrItemOptions<T> {
-  exceptions: T[]
-  isEqual: (a: T, b: T) => boolean
-}
-
-export const getRandomItemFromArray = <T>(values: T[], exception?: ArrItemOptions<T>) => {
-  const items = (() => {
-    if (exception && exception.exceptions.length < values.length) {
-      return values.filter((a) => !exception.exceptions.some((b) => exception.isEqual(a, b)))
-    }
-
-    return values
-  })()
-
-  return items[(items.length * Math.random()) << 0] as T
-}

package/src/regex.ts

@@ -1,6 +0,0 @@
-// prettier-ignore
-
-export const regex = {
-  email: /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
-  phone_number: /^[0-9]+$/
-}

package/src/time.ts

@@ -1,70 +0,0 @@
-export const formatTime = (value: number) => {
-  return value.toString().padStart(2, '0')
-}
-
-export const getTimes = (ms: number) => {
-  if (ms < 0) {
-    ms = 0
-  }
-
-  const totalSeconds = Math.floor(ms / 1000)
-
-  const hours = Math.floor(totalSeconds / 3600)
-  const minutes = Math.floor((totalSeconds % 3600) / 60)
-  const seconds = totalSeconds % 60
-
-  return { hours, minutes, seconds }
-}
-
-export const getTime = (timestamp: number, utc: boolean = true) => {
-  const date = new Date(timestamp)
-  const prefix = utc ? 'UTC' : ''
-
-  const times = [
-    formatTime(date[`get${prefix}Hours`]()),
-    formatTime(date[`get${prefix}Minutes`]()),
-    formatTime(date[`get${prefix}Seconds`]())
-  ]
-
-  return times.join(':')
-}
-
-export const getDate = (timestamp: number, utc: boolean = true) => {
-  const date = new Date(timestamp)
-  const prefix = utc ? 'UTC' : ''
-
-  const times = [
-    formatTime(date[`get${prefix}Date`]()),
-    formatTime(date[`get${prefix}Month`]() + 1),
-    formatTime(date[`get${prefix}FullYear`]())
-  ]
-
-  return times.join(':')
-}
-
-// export const timeDuration = (ms: number) => {
-//   const hours = Math.floor(ms / (1000 * 60 * 60))
-//   const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60))
-//   const seconds = Math.floor((ms % (1000 * 60)) / 1000)
-//   const milliseconds = ms % 1000
-
-//   const parts: string[] = []
-
-//   if (hours > 0) {
-//     parts.push(`${hours} h.`)
-//   }
-
-//   if (minutes > 0) {
-//     parts.push(`${minutes} m.`)
-//   }
-
-//   if (parts.length !== 2 && seconds > 0) {
-//     parts.push(`${seconds} s.`)
-//   }
-
-//   if (parts.length === 0) {
-//     parts.push(`${milliseconds} ms`)
-//   }
-
-//   return parts.join(' ')
-// }

package/src/utils.ts

@@ -1,15 +0,0 @@
-export const sleep = (time: number) => {
-  return new Promise<void>((resolve) => setTimeout(resolve, time))
-}
-
-export const stringify = (...ars: any[]) => {
-  return ars.map((value) => JSON.stringify(value)).join(' ')
-}
-
-export const contain = <T>(items: T[][]): T[] => {
-  return items.reduce((prev, curr) => [...prev, ...curr], [])
-}
-
-export const nonNullable = <T>(value: T): value is NonNullable<T> => {
-  return value !== null && value !== undefined
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "strictPropertyInitialization": false,
-    "module": "esnext",
-    "declaration": true,
-    "removeComments": true,
-    "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": false,
-    "noFallthroughCasesInSwitch": false,
-    "moduleResolution": "node",
-    "outDir": "./dist",
-    "baseUrl": "./"
-  },
-  "include": ["./src"],
-  "exclude": ["node_modules", "dist"]
-}