@dxtmisha/functional-basic 0.1.0 → 0.1.1

package/src/functions/intersectKey.ts

@@ -0,0 +1,34 @@
+import { forEach } from './forEach'
+import { isObject } from './isObject'
+
+/**
+ * Computes the intersection of arrays using keys for comparison.
+ *
+ * Вычислить пересечение массивов, сравнивая ключи.
+ * @param data the array with master keys to check/ основной проверяемый массив
+ * @param comparison arrays to compare keys against/ массивы, с которыми идёт сравнение
+ */
+export function intersectKey<
+  T,
+  KT extends keyof T,
+  C,
+  KC extends keyof C
+>(
+  data?: T,
+  comparison?: C
+): Record<KT & KC, T[KT]> {
+  const values = {} as Record<KT & KC, T[KT]>
+
+  if (
+    isObject(data)
+    && isObject(comparison)
+  ) {
+    forEach<T[KT], void>(data, (item, index) => {
+      if (index in comparison) {
+        values[index as (KT & KC)] = item
+      }
+    })
+  }
+
+  return values
+}

package/src/functions/isArray.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the values are arrays.
+ *
+ * Проверяет, являются ли значения массивами.
+ * @param value input value/ входное значение
+ */
+export function isArray<T, R>(value: T): value is Extract<T, R[]> {
+  return Array.isArray(value)
+}

package/src/functions/isDifferent.ts

@@ -0,0 +1,27 @@
+import { forEach } from './forEach'
+
+import { type ObjectItem } from '../types/basicTypes'
+
+/**
+ * Checks if the values of two objects are different.
+ *
+ * Проверяет, различаются ли значения двух объектов.
+ * @param value current values/ текущие значения
+ * @param old old values/ старые значения
+ */
+export function isDifferent<T>(
+  value: ObjectItem<T>,
+  old: ObjectItem<T>
+): boolean {
+  let different = Object.keys(value).length !== Object.keys(old).length
+
+  if (!different) {
+    forEach(value, (item, key) => {
+      if (item !== old?.[key]) {
+        different = true
+      }
+    })
+  }
+
+  return different
+}

package/src/functions/isDomRuntime.ts

@@ -0,0 +1,12 @@
+/**
+ * Проверяет, выполняется ли код в браузере, где доступен объект `window`.
+ * Возвращает `true`, если `window` доступен, что означает, что код выполняется в браузере.
+ *
+ * Checks if the code is running in a browser where the `window` object is available.
+ * Returns `true` if `window` is defined, indicating the code is running in a browser.
+ *
+ * @returns `true`, если выполняется в браузере, иначе `false`/ `true` if running in a browser, otherwise `false`
+ */
+export function isDomRuntime(): boolean {
+  return typeof window !== 'undefined' && Boolean(window.document)
+}

package/src/functions/isFilled.ts

@@ -0,0 +1,49 @@
+import { isNull } from './isNull'
+
+import { type EmptyValue } from '../types/basicTypes'
+
+/**
+ * Checks if the field is filled.
+ *
+ * Проверяет, заполнено ли поле.
+ * @param value input value/ входное значение
+ * @param zeroTrue if true, '0' is considered filled/ если true, то '0' считается заполненным
+ */
+export function isFilled<T>(
+  value: T,
+  zeroTrue?: boolean
+): value is Exclude<T, EmptyValue> {
+  if (value) {
+    if (
+      zeroTrue
+      && value === '0'
+    ) {
+      return true
+    }
+
+    switch (typeof value) {
+      case 'bigint':
+      case 'number':
+        return value !== 0
+      case 'boolean':
+        return value
+      case 'function':
+      case 'symbol':
+        return true
+      case 'object':
+        if (Array.isArray(value)) {
+          return value.length > 0
+        }
+
+        return Object.values(value).some(item => !isNull(item))
+      case 'string':
+        return !['', 'undefined', 'null', '0', 'false', '[]'].includes(value)
+      case 'undefined':
+        return false
+      default:
+        return Boolean(value)
+    }
+  }
+
+  return false
+}

package/src/functions/isFloat.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if the value is an integer or a floating-point number.
+ *
+ * Проверяет, является ли значение числом или дробным числом.
+ * @param value values for checking/ значения для проверки
+ */
+export function isFloat(value: any): boolean {
+  switch (typeof value) {
+    case 'number':
+      return true
+    case 'string':
+      return Boolean(value.match(/^([0-9]+|[0-9]+\.[0-9]+)$/))
+    default:
+      return false
+  }
+}

package/src/functions/isFunction.ts

@@ -0,0 +1,11 @@
+import { type FunctionArgs } from '../types/basicTypes'
+
+/**
+ * Checks if the function is a callback function.
+ *
+ * Проверяет, является ли функция обратного вызова.
+ * @param callback the value being checked/ проверяемое значение
+ */
+export function isFunction<T>(callback: T): callback is Extract<T, FunctionArgs<any, any>> {
+  return callback instanceof Function || typeof callback === 'function'
+}

package/src/functions/isInDom.ts

@@ -0,0 +1,15 @@
+import { getElement } from './getElement'
+import {
+  type ElementOrString,
+  type ElementOrWindow
+} from '../types/basicTypes'
+
+/**
+ * Checks if an element is still in the DOM tree.
+ *
+ * Проверяет, находится ли еще элемент в дереве DOM.
+ * @param element selectors for matching or an Element/ селекторов для сопоставления или Element
+ */
+export function isInDom<E extends ElementOrWindow>(element?: ElementOrString<E>): boolean {
+  return Boolean(getElement(element)?.closest('html'))
+}

package/src/functions/isIntegerBetween.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if the value is between integers.
+ *
+ * Проверяет, лежит ли значение между целыми числами.
+ * @param value input value/ входное значение
+ * @param between value for rounding/ значение для округления
+ */
+export function isIntegerBetween(value: number, between: number): boolean {
+  const floor = Math.floor(between)
+  return value >= floor && value < floor + 1
+}

package/src/functions/isNull.ts

@@ -0,0 +1,11 @@
+import { type Undefined } from '../types/basicTypes'
+
+/**
+ * Is the variable equal to null or undefined.
+ *
+ * Является ли переменная равной null или undefined.
+ * @param value input value/ входное значение
+ */
+export function isNull<T>(value: T): value is Extract<T, Undefined> {
+  return value === null || value === undefined
+}

package/src/functions/isNumber.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if the value is a number.
+ *
+ * Проверяет, является ли значение числом.
+ * @param value values for checking/ значения для проверки
+ */
+export function isNumber(value: any): boolean {
+  switch (typeof value) {
+    case 'number':
+      return true
+    case 'string':
+      return Boolean(value.match(/^[0-9]+$/))
+    default:
+      return false
+  }
+}

package/src/functions/isObject.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if a value is an object.
+ *
+ * Проверяет, является ли значение объектом.
+ * @param value input value/ входное значение
+ */
+export function isObject<T>(value: T): value is Extract<T, Record<any, any>> {
+  return Boolean(value && typeof value === 'object')
+}

package/src/functions/isObjectNotArray.ts

@@ -0,0 +1,11 @@
+import { isObject } from './isObject'
+
+/**
+ * Checks if the value is an object or not an array.
+ *
+ * Проверяет, является ли значение объектом и не является массивом.
+ * @param value input value/ входное значение
+ */
+export function isObjectNotArray<T>(value: T): value is Exclude<Extract<T, Record<any, any>>, any[] | undefined | null> {
+  return isObject(value) && !Array.isArray(value)
+}

package/src/functions/isSelected.ts

@@ -0,0 +1,32 @@
+import { isNull } from './isNull'
+import { isNumber } from './isNumber'
+import { toNumber } from './toNumber'
+
+/**
+ * Checks if value is in the array selected or if value equals selected, if selected is a string.
+ *
+ * Проверяет, есть ли value в массиве selected или равен ли value selected, если selected - строка.
+ * @param value input value/ входное значение
+ * @param selected array or string for comparison/ массив или строка для сравнения
+ */
+export function isSelected<T, S>(
+  value: T,
+  selected: T | T[] | S
+): boolean {
+  if (isNull(value)) {
+    return false
+  }
+
+  if (Array.isArray(selected)) {
+    return selected.includes(value)
+  }
+
+  if (
+    isNumber(value)
+    && isNumber(selected)
+  ) {
+    return toNumber(value as number) === toNumber(selected as number)
+  }
+
+  return value === selected
+}

package/src/functions/isSelectedByList.ts

@@ -0,0 +1,19 @@
+import { isSelected } from './isSelected'
+
+/**
+ * Testing isSelected property for the entire list of values.
+ *
+ * Проверка свойства isSelected для всех значений списка.
+ * @param values list of values for comparison/ список значений для сравнения
+ * @param selected array or string for comparison/ массив или строка для сравнения
+ */
+export function isSelectedByList<T>(
+  values: T | T[],
+  selected: T | T[]
+): boolean {
+  if (Array.isArray(values)) {
+    return values.every(item => isSelected(item, selected))
+  }
+
+  return isSelected(values, selected)
+}

package/src/functions/isString.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the value is of type string.
+ *
+ * Проверяет, является ли значение типом строки.
+ * @param value input value/ входное значение
+ */
+export function isString<T>(value: T): value is Extract<T, string> {
+  return typeof value === 'string'
+}

package/src/functions/isWindow.ts

@@ -0,0 +1,11 @@
+import { isDomRuntime } from './isDomRuntime'
+
+/**
+ * Checks if object is Window.
+ *
+ * Проверяет, является ли объект Window.
+ * @param element selectors for matching or an Element/ селекторов для сопоставления или Element
+ */
+export function isWindow<E>(element: E): element is Extract<E, Window> {
+  return isDomRuntime() && element === window
+}

package/src/functions/random.ts

@@ -0,0 +1,10 @@
+/**
+ * Generate a random integer.
+ *
+ * Генерирует случайное число.
+ * @param min the lowest value to return/ наименьшее значение
+ * @param max the highest value to return/ наибольшее значение
+ */
+export function random(min: number, max: number): number {
+  return Math.floor((Math.random() * (max - min + 1)) + min)
+}

package/src/functions/replaceRecursive.ts

@@ -0,0 +1,60 @@
+import { copyObject } from './copyObject'
+import { forEach } from './forEach'
+import { isObject } from './isObject'
+import { uniqueArray } from './uniqueArray'
+
+import {
+  type ObjectItem,
+  type ObjectOrArray
+} from '../types/basicTypes'
+
+/**
+ * Merge one or more arrays recursively.
+ *
+ * Рекурсивное слияние одного или более массивов.
+ * @param array the array in which elements are replaced/ массив, элементы которого будут заменены
+ * @param replacement arrays from which elements will be extracted/ массивы, из которых будут браться элементы для замены
+ * @param isMerge merge one or more arrays/ сливает один или большее количество массивов
+ */
+export function replaceRecursive<I>(
+  array: ObjectItem<I>,
+  replacement?: ObjectOrArray<I>,
+  isMerge = true
+): ObjectItem<I> {
+  const returnData: ObjectItem<I> = copyObject(array)
+
+  if (
+    isObject(array)
+    && isObject(replacement)
+  ) {
+    forEach<I, void>(
+      replacement,
+      (item, index) => {
+        const data = array?.[index]
+
+        if (
+          isObject(data)
+          && isObject(item)
+        ) {
+          if (
+            isMerge
+            && Array.isArray(data)
+            && Array.isArray(item)
+          ) {
+            returnData[index] = copyObject(uniqueArray([...data, ...item])) as I
+          } else {
+            returnData[index] = replaceRecursive<I>(
+              (Array.isArray(data) ? { ...data } : data) as ObjectItem<I>,
+              item as ObjectOrArray<I>,
+              isMerge
+            ) as I
+          }
+        } else {
+          returnData[index] = isObject(item) ? copyObject(item) : item
+        }
+      }
+    )
+  }
+
+  return returnData
+}

package/src/functions/replaceTemplate.ts

@@ -0,0 +1,22 @@
+import { executeFunction } from './executeFunction'
+import { forEach } from './forEach'
+import { getExp } from './getExp'
+
+import { type FunctionReturn } from '../types/basicTypes'
+
+/**
+ * Replacing the value from replaces in value.
+ *
+ * Замена значения из replaces в value.
+ * @param value template string/ строка шаблона
+ * @param replaces object with data for replacement/ объект с данными для замены
+ */
+export function replaceTemplate(value: string, replaces: Record<string, string | FunctionReturn<string>>): string {
+  let data = value
+
+  forEach(replaces, (replacement, pattern) => {
+    data = data.replace(getExp(`[${pattern}]`), executeFunction(replacement))
+  })
+
+  return data
+}

package/src/functions/secondToTime.ts

@@ -0,0 +1,20 @@
+import { toNumber } from './toNumber'
+
+/**
+ * Converts seconds into a time string.
+ *
+ * Преобразовывает секунды в строку с временем.
+ * @param second specified seconds/ указанные секунды
+ */
+export function secondToTime(second: number | string | undefined): string {
+  const time = toNumber(second)
+
+  if (time > 0) {
+    const minutes = String(Math.floor(time / 60)).padStart(2, '0')
+    const seconds = String(time % 60).padStart(2, '0')
+
+    return `${minutes}:${seconds}`
+  }
+
+  return '00:00'
+}

package/src/functions/setElementItem.ts

@@ -0,0 +1,56 @@
+import { executeFunction } from './executeFunction'
+import { forEach } from './forEach'
+import { getElement } from './getElement'
+import { getElementItem } from './getElementItem'
+import { isObject } from './isObject'
+
+import {
+  type ElementOrString,
+  type ElementOrWindow
+} from '../types/basicTypes'
+
+/**
+ * Modifies the value of an element identified by its key.
+ *
+ * Изменяет значение элемента, определенного ключом.
+ * @param element checked element/ проверяемый элемент
+ * @param index index at which we retrieve values/ индекс, по которому получаем значения
+ * @param value new value/ новое значение
+ */
+export function setElementItem<
+  E extends ElementOrWindow,
+  K extends keyof E,
+  V extends E[K] = E[K]
+>(
+  element: ElementOrString<E>,
+  index: K,
+  value: V | Record<string, V>
+): E | undefined {
+  const item = getElement(element)
+
+  if (item) {
+    const data: any = getElementItem(item, index)
+
+    if (
+      isObject(data)
+      && isObject(value)
+    ) {
+      forEach(value as any, (item, key) => {
+        data[key] = executeFunction(item)
+      })
+    } else {
+      const newValue = executeFunction(value)
+
+      if (
+        !(index in item)
+        && typeof newValue === 'string'
+      ) {
+        item.setAttribute(index.toString(), newValue)
+      } else {
+        (item as any)[index] = executeFunction(value)
+      }
+    }
+  }
+
+  return item
+}

package/src/functions/setValues.ts

@@ -0,0 +1,59 @@
+import { isArray } from './isArray'
+
+/**
+ * Modifies data according to its type and settings.
+ *
+ * Изменяет данные в соответствии с их типом и настройками.
+ * @param selected base values/ базовые значения
+ * @param value new values/ новые значения
+ * @param multiple support for multiple values/ поддержка нескольких значений
+ * @param maxlength maximum values/ максимальные значения
+ * @param alwaysChange updating values in any case/ обновление значений при любом случае
+ * @param notEmpty do not make the values empty/ не делать значения пустыми
+ */
+export function setValues<T>(
+  selected: T | T[] | undefined,
+  value: any,
+  {
+    multiple = false,
+    maxlength = 0,
+    alwaysChange = true,
+    notEmpty = false
+  }
+): T | T[] | undefined {
+  if (multiple) {
+    if (isArray(selected)) {
+      const key = selected.indexOf(value)
+      const data: any[] = [...selected]
+
+      if (key !== -1) {
+        if (!notEmpty || data.length > 1) {
+          data.splice(key, 1)
+        }
+      } else if (!maxlength || selected.length < maxlength) {
+        data.push(value)
+      }
+
+      return data
+    }
+
+    if (selected === value) {
+      return []
+    }
+
+    if (selected) {
+      return [selected, value]
+    }
+
+    return [value]
+  }
+
+  if (
+    alwaysChange
+    || selected !== value
+  ) {
+    return value
+  }
+
+  return selected
+}

package/src/functions/splice.ts

@@ -0,0 +1,59 @@
+import { copyObject } from './copyObject'
+import { forEach } from './forEach'
+import { isObject } from './isObject'
+import { replaceRecursive } from './replaceRecursive'
+
+import {
+  type ObjectItem,
+  type ObjectOrArray
+} from '../types/basicTypes'
+
+/**
+ * This method is used to copy the values of all enumerable own properties from one source object to a target object.
+ * In priority according to the processing list.
+ *
+ * Метод используется для копирования значений всех перечисляемых свойств одного объекта в другой.
+ * В приоритете по списку обработки.
+ * @param array the target object/ целевой объект
+ * @param replacement the source object/ исходные объекты
+ * @param indexStart index at which to start changing the array/ индекс, по которому начинает изменять массив
+ */
+export function splice<I>(
+  array: ObjectItem<I>,
+  replacement?: ObjectItem<I> | I,
+  indexStart?: string
+): ObjectItem<I> {
+  if (
+    isObject(array)
+    && isObject(replacement)
+  ) {
+    if (indexStart) {
+      let returnData: ObjectItem<I> = {}
+      let init = false
+
+      forEach<I, void>(array, (item, index) => {
+        if (
+          !init && (
+            indexStart === index
+            || indexStart === item
+          )
+        ) {
+          init = true
+          returnData = replaceRecursive(returnData, replacement as ObjectOrArray)
+        } else if (init) {
+          returnData = replaceRecursive(returnData, { [index]: item })
+        } else {
+          returnData[index] = isObject(item) ? copyObject(item) : item
+        }
+      })
+
+      return init ? returnData : replaceRecursive(array, replacement as ObjectOrArray)
+    }
+
+    if (isObject(replacement)) {
+      return replaceRecursive(array, replacement as ObjectOrArray)
+    }
+  }
+
+  return copyObject(array)
+}

package/src/functions/strFill.ts

@@ -0,0 +1,12 @@
+import { arrFill } from './arrFill'
+
+/**
+ * The method creates a string of length count, consisting of the characters value.
+ *
+ * Метод создает строку длиной count, состоящую из символов value.
+ * @param value character for filling/ символ для заполнения
+ * @param count length of the string/ длина строки
+ */
+export function strFill(value: string, count: number): string {
+  return arrFill(value, count).join('')
+}

package/src/functions/toArray.ts

@@ -0,0 +1,19 @@
+/**
+ * Преобразует значение в массив.
+ * Если переданное значение уже является массивом, возвращается оно само.
+ * В противном случае значение оборачивается в массив.
+ *
+ * Converts a value to an array.
+ * If the value is already an array, it returns it as is.
+ * Otherwise, it wraps the value in an array.
+ *
+ * @param value - Значение, которое необходимо преобразовать в массив.
+ *
+ * The value to be converted into an array.
+ * @returns Массив, содержащий переданное значение.
+ *
+ * An array containing the provided value.
+ */
+export function toArray<T>(value: T): T extends any[] ? T : [T] {
+  return (Array.isArray(value) ? value : [value]) as T extends any[] ? T : [T]
+}

package/src/functions/toCamelCase.ts

@@ -0,0 +1,16 @@
+/**
+ * Convert a String to Camel Case (upper).
+ *
+ * Преобразование строки в Camel Case (upper).
+ * @param value input value/ входное значение
+ */
+export function toCamelCase(value: string): string {
+  return value
+    .toString()
+    .trim()
+    .replace(/[^\w- ]+/g, '')
+    .replace(/ +/g, '-')
+    .replace(/(?<=[A-Z])([A-Z])/g, char => `${char.toLowerCase()}`)
+    .replace(/-+([a-zA-Z0-9])/g, (...char: string[]) => `${String(char[1]).toUpperCase()}`)
+    .replace(/^([A-Z])/, char => `${char.toLowerCase()}`)
+}