feat(utils): added basic string and array utils

packages/utils/src/arrays/filterArray/filterArray.ts

@@ -0,0 +1,18 @@
+function filterArray<T, R extends T>(
+    arrayToFilter: ReadonlyArray<T>,
+    predicate: (value: T, index: number) => value is R
+): Array<R> {
+    const result: R[] = []
+
+    for (let index = 0, length = arrayToFilter.length; index < length; index += 1) {
+        const value = arrayToFilter[index]
+
+        if (predicate(value, index)) {
+            result.push(value)
+        }
+    }
+
+    return result
+}
+
+export { filterArray }

packages/utils/src/arrays/filterArray/index.ts

@@ -0,0 +1 @@
+export * from './filterArray'

packages/utils/src/arrays/filterArrayReverse/filterArrayReverse.ts

@@ -0,0 +1,18 @@
+function filterArrayReverse<T, R extends T>(
+    arrayToIterate: ReadonlyArray<T>,
+    predicate: (value: T, index: number) => value is R
+): Array<R> {
+    const result: R[] = []
+
+    for (let index = arrayToIterate.length; index--; ) {
+        const value = arrayToIterate[index]
+
+        if (predicate(value, index)) {
+            result.push(value)
+        }
+    }
+
+    return result
+}
+
+export { filterArrayReverse }

packages/utils/src/arrays/filterArrayReverse/index.ts

@@ -0,0 +1 @@
+export * from './filterArrayReverse'

packages/utils/src/arrays/findInArray/findInArray.ts

@@ -0,0 +1,19 @@
+function findInArray<T, R extends T>(
+    arrayToIterate: ReadonlyArray<T>,
+    predicate: (value: T, index: number) => value is R
+): R | undefined {
+    let result: R | undefined
+
+    for (let index = 0, length = arrayToIterate.length; index < length; index += 1) {
+        const value = arrayToIterate[index]
+
+        if (predicate(value, index)) {
+            result = value
+            break
+        }
+    }
+
+    return result
+}
+
+export { findInArray }

packages/utils/src/arrays/findInArray/index.ts

@@ -0,0 +1 @@
+export * from './findInArray'

packages/utils/src/arrays/findInArrayReverse/findInArrayReverse.ts

@@ -0,0 +1,19 @@
+function findInArrayReverse<T, R extends T>(
+    arrayToIterate: ReadonlyArray<T>,
+    predicate: (value: T, index: number) => value is R
+): R | undefined {
+    let result: R | undefined
+
+    for (let index = arrayToIterate.length; index--; ) {
+        const value = arrayToIterate[index]
+
+        if (predicate(value, index)) {
+            result = value
+            break
+        }
+    }
+
+    return result
+}
+
+export { findInArrayReverse }

packages/utils/src/arrays/findInArrayReverse/index.ts

@@ -0,0 +1 @@
+export * from './findInArrayReverse'

packages/utils/src/arrays/forEachInArray/forEachInArray.ts

@@ -0,0 +1,7 @@
+function forEachInArray<T>(arrayToIterate: ReadonlyArray<T>, callback: (value: T, index: number) => void): void {
+    for (let index = 0, length = arrayToIterate.length; index < length; index += 1) {
+        callback(arrayToIterate[index], index)
+    }
+}
+
+export { forEachInArray }

packages/utils/src/arrays/forEachInArray/index.ts

@@ -0,0 +1 @@
+export * from './forEachInArray'

packages/utils/src/arrays/forEachInArrayReverse/forEachInArrayReverse.ts

@@ -0,0 +1,7 @@
+function forEachInArrayReverse<T>(arrayToIterate: ReadonlyArray<T>, callback: (value: T, index: number) => void): void {
+    for (let index = arrayToIterate.length; index--; ) {
+        callback(arrayToIterate[index], index)
+    }
+}
+
+export { forEachInArrayReverse }

packages/utils/src/arrays/forEachInArrayReverse/index.ts

@@ -0,0 +1 @@
+export * from './forEachInArrayReverse'

packages/utils/src/arrays/getFirstInArray/getFirstInArray.ts

@@ -0,0 +1,7 @@
+import type { FirstInList, List } from '../../types'
+
+function getFirstInArray<T extends List<unknown>>(array: T): FirstInList<T> {
+    return array[0] as FirstInList<T>
+}
+
+export { getFirstInArray }

packages/utils/src/arrays/getFirstInArray/index.ts

@@ -0,0 +1 @@
+export * from './getFirstInArray'

packages/utils/src/arrays/getLastInArray/getLastInArray.ts

@@ -0,0 +1,7 @@
+import type { LastInList, List } from '../../types'
+
+function lastInArray<T extends List<unknown>>(array: T): LastInList<T> {
+    return array[array.length - 1] as LastInList<T>
+}
+
+export { lastInArray }

packages/utils/src/arrays/getLastInArray/index.ts

@@ -0,0 +1 @@
+export * from './getLastInArray'

packages/utils/src/arrays/groupArray/groupArray.ts

@@ -0,0 +1,21 @@
+function groupArray<T, K extends string>(
+    arrayToGroup: ReadonlyArray<T>,
+    getGroupKey: (value: T, index: number) => K
+): Record<K, Array<T>> {
+    const result = {} as Record<K, Array<T>>
+
+    for (let index = 0, length = arrayToGroup.length; index < length; index += 1) {
+        const value = arrayToGroup[index]
+        const key = getGroupKey(value, index)
+
+        if (result[key]) {
+            result[key].push(value)
+        } else {
+            result[key] = [value]
+        }
+    }
+
+    return result
+}
+
+export { groupArray }

packages/utils/src/arrays/groupArray/index.ts

@@ -0,0 +1 @@
+export * from './groupArray'

packages/utils/src/arrays/groupToMapArray/groupToMapArray.ts

@@ -0,0 +1,19 @@
+function groupToMapArray<T, K>(arrayToGroup: ReadonlyArray<T>, getGroupKey: (value: T, index: number) => K) {
+    const result = new Map<K, T[]>()
+
+    for (let index = 0, length = arrayToGroup.length; index < length; index += 1) {
+        const value = arrayToGroup[index]
+        const key = getGroupKey(value, index)
+        const valueFromResult = result.get(key)
+
+        if (valueFromResult) {
+            valueFromResult.push(value)
+        } else {
+            result.set(key, [value])
+        }
+    }
+
+    return result
+}
+
+export { groupToMapArray }

packages/utils/src/arrays/groupToMapArray/index.ts

@@ -0,0 +1 @@
+export * from './groupToMapArray'

packages/utils/src/arrays/index.ts

@@ -0,0 +1,11 @@
+export * from './filterArray'
+export * from './filterArrayReverse'
+export * from './findInArray'
+export * from './findInArrayReverse'
+export * from './forEachInArray'
+export * from './forEachInArrayReverse'
+export * from './getFirstInArray'
+export * from './getLastInArray'
+export * from './groupArray'
+export * from './groupToMapArray'
+export * from './reverseArray'

packages/utils/src/arrays/reverseArray/index.ts

@@ -0,0 +1 @@
+export * from './reverseArray'

packages/utils/src/arrays/reverseArray/reverseArray.ts

@@ -0,0 +1,5 @@
+function reverseArray<T>(arrayToReverse: ReadonlyArray<T>): Array<T> {
+    return [...arrayToReverse].reverse()
+}
+
+export { reverseArray }

packages/utils/src/index.ts

@@ -1,4 +1,6 @@
+export * from './arrays'
 export * from './functions'
 export * from './guards'
 export * from './misc'
+export * from './strings'
 export * from './types'

packages/utils/src/strings/capitalizeString/capitalizeString.test.ts

@@ -0,0 +1,11 @@
+import { capitalizeString } from './capitalizeString'
+
+describe('capitalizeString', () => {
+    it('should capitalize string', () => {
+        expect(capitalizeString('')).toBe('')
+
+        expect(capitalizeString('string')).toBe('String')
+
+        expect(capitalizeString('string with spaces')).toBe('String with spaces')
+    })
+})

packages/utils/src/strings/capitalizeString/capitalizeString.ts

@@ -0,0 +1,5 @@
+function capitalizeString<T extends string>(stringToCapitalize: T): Capitalize<T> {
+    return (stringToCapitalize.charAt(0).toUpperCase() + stringToCapitalize.slice(1)) as Capitalize<T>
+}
+
+export { capitalizeString }

packages/utils/src/strings/capitalizeString/index.ts

@@ -0,0 +1 @@
+export * from './capitalizeString'

packages/utils/src/strings/index.ts

@@ -0,0 +1,7 @@
+export * from './capitalizeString'
+export * from './lowercaseString'
+export * from './snakeCaseToCamelCaseString'
+export * from './splitString'
+export * from './transformString'
+export * from './uncapitalizeString'
+export * from './uppercaseString'

packages/utils/src/strings/lowercaseString/index.ts

@@ -0,0 +1 @@
+export * from './lowercaseString'

packages/utils/src/strings/lowercaseString/lowercaseString.test.ts

@@ -0,0 +1,11 @@
+import { lowercaseString } from './lowercaseString'
+
+describe('lowercaseString', () => {
+    it('should convert string to lowercase', () => {
+        expect(lowercaseString('')).toBe('')
+
+        expect(lowercaseString('strIng')).toBe('string')
+
+        expect(lowercaseString('STRING WITH SPACES')).toBe('string with spaces')
+    })
+})

packages/utils/src/strings/lowercaseString/lowercaseString.ts

@@ -0,0 +1,5 @@
+function lowercaseString<T extends string>(stringToLowercase: T): Lowercase<T> {
+    return stringToLowercase.toLowerCase() as Lowercase<T>
+}
+
+export { lowercaseString }

packages/utils/src/strings/snakeCaseToCamelCaseString/index.ts

@@ -0,0 +1 @@
+export * from './snakeCaseToCamelCaseString'

packages/utils/src/strings/snakeCaseToCamelCaseString/snakeCaseToCamelCaseString.test.ts

@@ -0,0 +1,13 @@
+import { snakeCaseToCamelCaseString } from './snakeCaseToCamelCaseString'
+
+describe('snakeCaseToCamelCaseString', () => {
+    it('should convert snake_case to camelCase', () => {
+        expect(snakeCaseToCamelCaseString('')).toBe('')
+
+        expect(snakeCaseToCamelCaseString('snake')).toBe('snake')
+
+        expect(snakeCaseToCamelCaseString('snake_case')).toBe('snakeCase')
+
+        expect(snakeCaseToCamelCaseString('snake_case_string')).toBe('snakeCaseString')
+    })
+})

packages/utils/src/strings/snakeCaseToCamelCaseString/snakeCaseToCamelCaseString.ts

@@ -0,0 +1,13 @@
+import type { SnakeCaseToCamelCase } from '../../types'
+import { capitalizeString } from '../capitalizeString'
+import { transformString } from '../transformString'
+
+function snakeCaseToCamelCaseString<T extends string>(stringToToTransform: T): SnakeCaseToCamelCase<T> {
+    return transformString(stringToToTransform, {
+        separator: '_',
+        joiner: '',
+        transformer: (stringPartToTransform, index) =>
+            index === 0 ? stringPartToTransform : capitalizeString(stringPartToTransform)
+    }) as SnakeCaseToCamelCase<T>
+}
+export { snakeCaseToCamelCaseString }

packages/utils/src/strings/snakeCaseToConstantCaseString/index.ts

@@ -0,0 +1 @@
+export * from './snakeCaseToConstantCaseString'

packages/utils/src/strings/snakeCaseToConstantCaseString/snakeCaseToConstantCaseString.ts

@@ -0,0 +1,13 @@
+import type { SnakeCaseToConstantCase } from '../../types'
+import { transformString } from '../transformString'
+import { uppercaseString } from '../uppercaseString'
+
+function snakeCaseToConstantCaseString<T extends string>(stringToTransform: T): SnakeCaseToConstantCase<T> {
+    return transformString(stringToTransform, {
+        separator: '_',
+        joiner: '_',
+        transformer: uppercaseString
+    }) as SnakeCaseToConstantCase<T>
+}
+
+export { snakeCaseToConstantCaseString }

packages/utils/src/strings/snakeCaseToKebabCaseString/index.ts

@@ -0,0 +1 @@
+export * from './snakeCaseToKebabCaseString'

packages/utils/src/strings/snakeCaseToKebabCaseString/snakeCaseToKebabCaseString.ts

@@ -0,0 +1,13 @@
+import type { SnakeCaseToKebabCase } from '../../types'
+import { lowercaseString } from '../lowercaseString'
+import { transformString } from '../transformString'
+
+function snakeCaseToKebabCaseString<T extends string>(stringToTransform: T): SnakeCaseToKebabCase<T> {
+    return transformString(stringToTransform, {
+        separator: '_',
+        joiner: '-',
+        transformer: lowercaseString
+    }) as SnakeCaseToKebabCase<T>
+}
+
+export { snakeCaseToKebabCaseString }

packages/utils/src/strings/snakeCaseToPascalCaseString/index.ts

@@ -0,0 +1 @@
+export * from './snakeCaseToPascalCaseString'

packages/utils/src/strings/snakeCaseToPascalCaseString/snakeCaseToPascalCaseString.ts

@@ -0,0 +1,13 @@
+import type { SnakeCaseToPascalCase } from '../../types'
+import { capitalizeString } from '../capitalizeString'
+import { transformString } from '../transformString'
+
+function snakeCaseToPascalCaseString<T extends string>(stringToTransform: T): SnakeCaseToPascalCase<T> {
+    return transformString(stringToTransform, {
+        separator: '_',
+        joiner: '',
+        transformer: capitalizeString
+    }) as SnakeCaseToPascalCase<T>
+}
+
+export { snakeCaseToPascalCaseString }

packages/utils/src/strings/splitString/index.ts

@@ -0,0 +1 @@
+export * from './splitString'

packages/utils/src/strings/splitString/splitString.ts

@@ -0,0 +1,7 @@
+import type { SplitString } from '../../types'
+
+function splitString<T extends string, D extends string>(stringToSplit: T, delimiter: D): SplitString<T, D> {
+    return stringToSplit.split(delimiter) as SplitString<T, D>
+}
+
+export { splitString }

packages/utils/src/strings/transformString/index.ts

@@ -0,0 +1 @@
+export * from './transformString'

packages/utils/src/strings/transformString/transformString.ts

@@ -0,0 +1,27 @@
+import { forEachInArray } from '../../arrays'
+import { splitString } from '../splitString'
+
+type TransformStringOptions = {
+    separator?: string
+    joiner?: string
+    transformer: (stringPartToTransform: string, index: number) => string
+}
+
+const DEFAULT_TRANSFORM_STRING_OPTIONS: Required<Pick<TransformStringOptions, 'separator' | 'joiner'>> = {
+    separator: '',
+    joiner: ''
+}
+
+function transformString<T extends string>(stringToTransform: T, options: TransformStringOptions) {
+    const { separator, joiner, transformer } = { ...DEFAULT_TRANSFORM_STRING_OPTIONS, ...options }
+
+    const stringParts = splitString(stringToTransform, separator)
+
+    forEachInArray(stringParts, (stringPart, index) => {
+        stringParts[index] = transformer(stringPart, index)
+    })
+
+    return stringParts.join(joiner)
+}
+
+export { transformString }

packages/utils/src/strings/uncapitalizeString/index.ts

@@ -0,0 +1 @@
+export * from './uncapitalizeString'

packages/utils/src/strings/uncapitalizeString/uncapitalizeString.test.ts

@@ -0,0 +1,11 @@
+import { uncapitalizeString } from './uncapitalizeString'
+
+describe('uncapitalizeString', () => {
+    it('should uncapitalize string', () => {
+        expect(uncapitalizeString('')).toBe('')
+
+        expect(uncapitalizeString('String')).toBe('string')
+
+        expect(uncapitalizeString('STRING WITH SPACES')).toBe('sTRING WITH SPACES')
+    })
+})

packages/utils/src/strings/uncapitalizeString/uncapitalizeString.ts

@@ -0,0 +1,5 @@
+function uncapitalizeString<T extends string>(stringToLowerize: T): Uncapitalize<T> {
+    return (stringToLowerize.charAt(0).toLowerCase() + stringToLowerize.slice(1)) as Uncapitalize<T>
+}
+
+export { uncapitalizeString }

packages/utils/src/strings/uppercaseString/index.ts

@@ -0,0 +1 @@
+export * from './uppercaseString'

packages/utils/src/strings/uppercaseString/uppercaseString.test.ts

@@ -0,0 +1,11 @@
+import { uppercaseString } from './uppercaseString'
+
+describe('uppercaseString', () => {
+    it('should convert string to uppercase', () => {
+        expect(uppercaseString('')).toBe('')
+
+        expect(uppercaseString('string')).toBe('STRING')
+
+        expect(uppercaseString('string with spaces')).toBe('STRING WITH SPACES')
+    })
+})