moderndash 0.0.5

package/src/array/unzipWith.ts

@@ -0,0 +1,26 @@
+/**
+ * This method is like `unzip` except that it accepts `iteratee` to specify
+ * how regrouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @category Array
+ * @param iteratee - The function to combine regrouped values.
+ * @param array - The array of grouped elements to process.
+ * @returns Returns the new array of regrouped elements.
+ * @example
+ * const zipped = zip([1, 2], [10, 20], [100, 200])
+ * // => [[1, 10, 100], [2, 20, 200]]
+ *
+ * unzipWith(add, zipped)
+ * // => [3, 30, 300]
+ */
+
+export function unzipWith<TInput extends unknown[], TOutput>(iteratee: (...t: TInput) => TOutput, array: TInput[]): TOutput[] {
+    const result: TOutput[] = [];
+
+    for (const elements of array) {
+        result.push(iteratee(...elements));
+    }
+
+    return result;
+}

package/src/array/zip.ts

@@ -0,0 +1,17 @@
+import { zipWith } from '@array/zipWith';
+
+/**
+ * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
+ * the second of which contains the second elements of the given arrays, and so on.
+ *
+ * @category Array
+ * @param arrays - The arrays to process.
+ * @returns Returns the new array of grouped elements.
+ * @example
+ * zip(['a', 'b'], [1, 2], [true, false])
+ * // => [['a', 1, true], ['b', 2, false]]
+ */
+
+export function zip<TInput>(...arrays: TInput[][]): TInput[][] {
+    return zipWith((...t) => t, ...arrays);
+}

package/src/array/zipWith.ts

@@ -0,0 +1,28 @@
+// Types from https://gist.github.com/briancavalier/c4af1538ae9b2e4ab97caf14306625ab
+type UnZip<A extends readonly unknown[]> = {
+    [K in keyof A]: readonly A[K][]
+};
+
+/**
+ * This method is like `zip` except that it accepts `iteratee` to specify
+ * how grouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @category Array
+ * @param combineFunc - The function to combine grouped values.
+ * @param arrays - The arrays to process.
+ * @returns Returns the new array of grouped elements.
+ * @example
+ * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c)
+ * // => [111, 222]
+ */
+
+export function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args: Args) => TOutput, ...arrays: UnZip<Args>): TOutput[] {
+    const len = Math.min(...arrays.map(a => a.length));
+    const zipped: TOutput[] = [];
+    for (let i = 0; i < len; i++) {
+        // Typescript needs the Args hint, or it infers any[]
+        zipped[i] = combineFunc(...arrays.map(a => a[i]) as Args);
+    }
+    return zipped;
+}

package/src/collection/countBy.ts

@@ -0,0 +1,38 @@
+import type { Collection, RecordKey } from '../types';
+
+import { getValuesFromCollection } from '@helpers/collections';
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the number of times the key was returned by `iteratee`.
+ *
+ * @category Collection
+ * @param iteratee - The iteratee to transform keys.
+ * @param collection - The array or object to iterate over.
+ * @returns Returns the composed aggregate object.
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'active': true },
+ *   { 'user': 'betty', 'active': true },
+ *   { 'user': 'fred', 'active': false }
+ * ]
+ *
+ * countBy(value => value.active, users);
+ * // => { 'true': 2, 'false': 1 }
+ */
+
+export function countBy<TInput, TKey extends RecordKey>(iteratee: (value: TInput) => TKey, collection: Collection<TInput>): Record<TKey, number> {
+    const result = {} as Record<TKey, number>;
+    const values = getValuesFromCollection(collection);
+    for (const value of values) {
+        const key = iteratee(value);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result[key] === undefined) {
+            result[key] = 1;
+        } else {
+            result[key] += 1;
+        }
+    }
+    return result;
+}

package/src/collection/groupBy.ts

@@ -0,0 +1,33 @@
+import type { RecordKey, Collection } from '../types';
+
+import { getValuesFromCollection } from '@helpers/collections';
+
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The order of grouped values
+ * is determined by the order they occur in `collection`. The corresponding
+ * value of each key is an array of elements responsible for generating the
+ * key.
+ *
+ * @category Collection
+ * @param collection The array or object to iterate over.
+ * @param iteratee The iteratee to transform keys.
+ * @returns Returns the composed aggregate object.
+ * @example
+ *
+ * groupBy(Math.floor, [6.1, 4.2, 6.3])
+ * // => { '4': [4.2], '6': [6.1, 6.3] }
+ */
+
+export function groupBy<T, U extends RecordKey>(iteratee: (value: T) => U, collection: Collection<T>): Record<U, T[]> {
+    const result = {} as Record<U, T[]>;
+    const values = getValuesFromCollection(collection);
+    for (const value of values) {
+        const key = iteratee(value);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        result[key] = result[key] ?? [];
+        result[key].push(value);
+    }
+    return result;
+}

package/src/collection/index.ts

@@ -0,0 +1,3 @@
+export * from './countBy';
+export * from './groupBy';
+export * from './sortBy';

package/src/collection/sortBy.ts

@@ -0,0 +1,15 @@
+import type { NoUnion } from '../types';
+
+export function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[] {
+    return array.sort((a, b) => {
+        const aValue = iteratee(a);
+        const bValue = iteratee(b);
+        if (aValue < bValue) {
+            return -1;
+        }
+        if (aValue > bValue) {
+            return 1;
+        }
+        return 0;
+    });
+}

package/src/function/after.ts

@@ -0,0 +1,23 @@
+/**
+ * The opposite of `before`. This method creates a function that invokes `func` once it's called `n` or more times.
+ *
+ * @category Function
+ * @param n The number of calls before `func` is invoked.
+ * @param func The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const caution = () => alert("Caution!");
+ *
+ * // Display alert only after it has been called 5 times
+ * after(5, caution)
+ */
+
+export function after<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc) {
+    let count = 1;
+    return (...args: Parameters<TFunc>): ReturnType<TFunc> | undefined => {
+        if (count >= n) {
+            return func(...args);
+        }
+        count += 1;
+    };
+}

package/src/function/before.ts

@@ -0,0 +1,27 @@
+/**
+ * Creates a function that invokes `func`, with the `this` binding and arguments
+ * of the created function, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @category Function
+ * @param n - The number of calls at which `func` is no longer invoked.
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const caution = () => alert("Caution!");
+ *
+ * // Only call caution two times
+ * before(2, caution)
+ */
+
+export function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc {
+    let count = 0;
+    let result: ReturnType<TFunc>;
+    return ((...args: Parameters<TFunc>): ReturnType<TFunc> => {
+        if (count < n) {
+            count += 1;
+            result = func(...args);
+        }
+        return result;
+    }) as TFunc;
+}

package/src/function/debounce.ts

@@ -0,0 +1,124 @@
+
+// TODO this is a port from lodash, it probably can be improved and shortened, also fix TS errors
+export function debounce<T extends (...args: Parameters<T>) => ReturnType<T>>(
+    fn: T, wait = 0, options: { leading?: boolean, maxWait?: number, trailing?: boolean } = {}
+): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T> {
+    let lastArgs: Parameters<T> | undefined;
+    let lastThis: ThisParameterType<T> | undefined;
+    let result: ReturnType<T>;
+    let timerId: ReturnType<typeof setTimeout> | undefined;
+    let lastCallTime: number | undefined;
+    let lastInvokeTime = 0;
+    const maxing = options.maxWait ?? false;
+    const leading = options.leading ?? false;
+    const trailing = options.trailing ?? true;
+    const maxWait = options.maxWait ?? 0;
+
+    function invokeFunc(time: number) {
+        const args: Parameters<T> | undefined = lastArgs;
+        const thisArg: ThisParameterType<T> | undefined = lastThis;
+
+        lastArgs = lastThis = undefined;
+        lastInvokeTime = time;
+        // @ts-ignore
+        result = fn.apply(thisArg, args);
+        return result;
+    }
+
+    function leadingEdge(time: number) {
+        // Reset any `maxWait` timer.
+        lastInvokeTime = time;
+        // Start the timer for the trailing edge.
+        timerId = setTimeout(timerExpired, wait);
+        // Invoke the leading edge.
+        return leading ? invokeFunc(time) : result;
+    }
+
+    function remainingWait(time: number) {
+        // @ts-ignore
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        const timeWaiting = wait - timeSinceLastCall;
+
+        return maxing
+            ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
+            : timeWaiting;
+    }
+
+    function shouldInvoke(time: number) {
+        if (lastCallTime === undefined)
+            return true;
+
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+
+        // Either this is the first call, activity has stopped and we're at the
+        // trailing edge, the system time has gone backwards and we're treating
+        // it as the trailing edge, or we've hit the `maxWait` limit.
+        return timeSinceLastCall >= wait || timeSinceLastCall < 0 || (maxing && timeSinceLastInvoke >= maxWait);
+    }
+
+    function timerExpired() {
+        const time = Date.now();
+        if (shouldInvoke(time)) {
+            return trailingEdge(time);
+        }
+        // Restart the timer.
+        timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+
+    function trailingEdge(time: number) {
+        timerId = undefined;
+
+        // Only invoke if we have `lastArgs` which means `fn` has been
+        // debounced at least once.
+        if (trailing && lastArgs) {
+            return invokeFunc(time);
+        }
+        lastArgs = lastThis = undefined;
+        return result;
+    }
+
+    function cancel() {
+        if (timerId !== undefined) {
+            clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+
+    function flush() {
+        return timerId === undefined ? result : trailingEdge(Date.now());
+    }
+
+    function debounced(this: ThisParameterType<T>, ...args: Parameters<T>): ReturnType<T> {
+        const time = Date.now();
+        const isInvoking = shouldInvoke(time);
+
+        lastArgs = args;
+        // TODO Fix this assignment
+        // eslint-disable-next-line @typescript-eslint/no-this-alias,unicorn/no-this-assignment
+        lastThis = this;
+        lastCallTime = time;
+
+        if (isInvoking) {
+            if (timerId === undefined) {
+                return leadingEdge(lastCallTime);
+            }
+            if (maxing) {
+                // Handle invocations in a tight loop.
+                clearTimeout(timerId);
+                timerId = setTimeout(timerExpired, wait);
+                return invokeFunc(lastCallTime);
+            }
+        }
+        if (timerId === undefined) {
+            timerId = setTimeout(timerExpired, wait);
+        }
+        return result;
+    }
+
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+}

package/src/function/index.ts

@@ -0,0 +1,6 @@
+export * from './after';
+export * from './before';
+export * from './debounce';
+export * from './memoize';
+export * from './once';
+export * from './throttle';

package/src/function/memoize.ts

@@ -0,0 +1,59 @@
+const defaultResolver = (...args: unknown[]) => JSON.stringify(args);
+type Cache = Map<string | symbol, unknown>;
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, all arguments
+ * provided to the memoized function are used as the map cache key.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @category Function
+ * @param func - The function to have its output memoized.
+ * @param resolver - The function to resolve the cache key.
+ * @returns  Returns the new memoized function.
+ * @example
+ * const object = \{ 'a': 1, 'b': 2 \}
+ *
+ * const values = memoize(values)
+ * values(object)
+ * // => [1, 2]
+ *
+ * values(object)
+ * // => [1, 2]
+ *
+ * object.a = 2
+ * values(object)
+ * // => [2, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b'])
+ * values(object)
+ * // => ['a', 'b']
+ *
+ * // Replace `memoize.Cache`.
+ * memoize.Cache = WeakMap
+ */
+
+export function memoize<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(
+    func: TFunc, resolver: ((...args: Parameters<TFunc>) => string | symbol) = defaultResolver
+): TFunc & { cache: Cache } {
+    const cache: Cache = new Map();
+    const memoizedFunc = (...args: Parameters<TFunc>): ReturnType<TFunc> => {
+        const key = resolver(...args);
+        if (cache.has(key)) {
+            // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+            return cache.get(key) as ReturnType<TFunc>;
+        }
+        const result = func(...args);
+        cache.set(key, result);
+        return result;
+    };
+    memoizedFunc.cache = cache;
+    return memoizedFunc as TFunc & { cache: Cache };
+}

package/src/function/once.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @category Function
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const initialize = once(createApplication)
+ * initialize()
+ * initialize()
+ * // => `createApplication` is invoked once
+ */
+import { before } from '@function/before';
+
+export function once<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc): TFunc {
+    return before(1, func);
+}

package/src/function/throttle.ts

@@ -0,0 +1,11 @@
+import { debounce } from '@function/debounce';
+
+export function throttle<T extends (...args: Parameters<T>) => ReturnType<T>>(
+    func: T, wait = 0, options: { leading?: boolean, trailing?: boolean } = {}
+): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T> {
+    return debounce(func, wait, {
+        leading: options.leading ?? true,
+        maxWait: wait,
+        trailing: options.trailing ?? true
+    });
+}

package/src/helpers/collections.ts

@@ -0,0 +1,5 @@
+import type { Collection } from '../types';
+
+export function getValuesFromCollection<T>(collection: Collection<T>): T[] {
+    return Array.isArray(collection) ? collection : Object.values(collection);
+}

package/src/helpers/shortHands.ts

@@ -0,0 +1,17 @@
+import type { IterateeFunction, PropertyShorthand } from '../types';
+
+import { isObjectKey } from '@helpers/typeofChecks';
+
+export function getPropertyShorthand<T, K extends keyof T>(key: K): (object: T) => T[K] {
+    return object => object[key];
+}
+
+export function getIterateFunction<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>) {
+    if (typeof iteratee === 'function') {
+        return iteratee;
+    } else if (isObjectKey(iteratee)) {
+        return getPropertyShorthand(iteratee);
+    } else {
+        throw new TypeError('Expected iteratee to be a function or a property name');
+    }
+}

package/src/helpers/stringModifiers.ts

@@ -0,0 +1,18 @@
+import { deburr } from '@string/deburr';
+
+export function splitWords(str: string): string[] {
+    str = deburr(str);
+
+    // Split non-alphanumeric characters with spaces and deal with camel/PascalCase
+    const regex = new RegExp(
+        '[^\\dA-Za-z]' +  // match any character that is not a letter or a digit
+        '|' +                    // or
+        '(?<=[a-z])' +           // lookbehind for a lowercase letter
+        '(?=[A-Z])' +            // lookahead for an uppercase letter
+        '|' +                    // or
+        '(?<=[A-Z])' +           // lookbehind for an uppercase letter
+        '(?=[A-Z][a-z])'         // lookahead for an uppercase letter followed by a lowercase letter
+    );
+
+    return str.split(regex).filter(Boolean);
+}

package/src/helpers/typeofChecks.ts

@@ -0,0 +1,3 @@
+export function isObjectKey(key: unknown): key is keyof object {
+    return typeof key === 'string' || typeof key === 'number' || typeof key === 'symbol';
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './array';
+export * from './collection';
+export * from './function';
+export * from './lang';
+export * from './object';
+export * from './string';
+export * from './types';

package/src/lang/index.ts

@@ -0,0 +1,4 @@
+export * from './isEmpty';
+export * from './isEqual';
+export * from './isEqualWith';
+export * from './isPlainObject';

package/src/lang/isEmpty.ts

@@ -0,0 +1,23 @@
+export function isEmpty(value: unknown): boolean {
+    if (value === null || value === undefined) {
+        return true;
+    }
+
+    if (typeof value === 'string' || Array.isArray(value)) {
+        return value.length === 0;
+    }
+
+    if (typeof value === 'number') {
+        return false;
+    }
+
+    if (value instanceof Map || value instanceof Set) {
+        return value.size === 0;
+    }
+
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+
+    return false;
+}

package/src/lang/isEqual.ts

@@ -0,0 +1,54 @@
+import type { RecordKey } from '../types';
+
+export function isEqual(value1: unknown, value2: unknown): boolean {
+    if (value1 === value2) return true;
+
+    if (Array.isArray(value1) && Array.isArray(value2)) {
+        return isSameArray(value1, value2);
+    }
+
+    if (value1 instanceof RegExp && value2 instanceof RegExp) {
+        return value1.toString() === value2.toString();
+    }
+
+    if (isObject(value1) && isObject(value2)) {
+        return isSameObject(value1, value2);
+    }
+
+    return false;
+}
+
+type KeyValueObject = Record<RecordKey, unknown>;
+function isObject(value: unknown): value is KeyValueObject {
+    return typeof value === 'object'
+        && value !== null
+        && !Array.isArray(value)
+        && Object.prototype.toString.call(value) === '[object Object]';
+}
+
+function isSameObject(value1: KeyValueObject, value2: KeyValueObject) {
+    // check if the objects have the same keys
+    const keys1 = Object.keys(value1);
+    const keys2 = Object.keys(value2);
+    if (!isEqual(keys1, keys2)) return false;
+
+    // check if the values of each key in the objects are equal
+    for (const key of keys1) {
+        if (!isEqual(value1[key], value2[key])) return false;
+    }
+
+    // the objects are deeply equal
+    return true;
+}
+
+function isSameArray(value1: unknown[], value2: unknown[]) {
+    // check if the arrays have the same length
+    if (value1.length !== value2.length) return false;
+
+    // check if the values of each element in the arrays are equal
+    for (const [i, element] of value1.entries()) {
+        if (!isEqual(element, value2[i])) return false;
+    }
+
+    return true;
+}

package/src/lang/isEqualWith.ts

@@ -0,0 +1,5 @@
+import { isEqual } from '@lang/isEqual';
+
+export function isEqualWith<T>(customizer: (value: T) => unknown, a: T, b: T): boolean {
+    return isEqual(customizer(a), customizer(b));
+}

package/src/lang/isPlainObject.ts

@@ -0,0 +1,3 @@
+export function isPlainObject(value: unknown): value is object {
+    return value !== null && typeof value === 'object' && value.constructor === Object;
+}

package/src/object/index.ts

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

package/src/object/pick.ts

@@ -0,0 +1,22 @@
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @category Object
+ * @param object The source object.
+ * @param keys The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * const object = { 'a': 1, 'b': '2', 'c': 3 }
+ *
+ * pick(object, ['a', 'c'])
+ * // => { 'a': 1, 'c': 3 }
+ */
+
+export function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K> {
+    const result = {} as Pick<T, K>;
+    for (const key of keys) {
+        result[key] = object[key];
+    }
+    return result;
+}

package/src/string/camelCase.ts

@@ -0,0 +1,15 @@
+import { splitWords } from '@helpers/stringModifiers';
+
+export function camelCase(str: string): string {
+    const words = splitWords(str);
+
+    // Capitalize the first letter of each word
+    const camelCase = words.map((word, index) => {
+        if (index === 0) {
+            return word.toLowerCase();
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    });
+
+    return camelCase.join('');
+}

package/src/string/capitalize.ts

@@ -0,0 +1,3 @@
+export function capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/string/deburr.ts

@@ -0,0 +1,5 @@
+export function deburr(str: string): string {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/[^\u0000-\u007E]/g, (chr: string) =>
+        chr.normalize('NFD').replace(/[\u0300-\u036F]/g, ''));
+}

package/src/string/escape.ts

@@ -0,0 +1,10 @@
+export function escape(str: string): string {
+    const escapeChars: Record<string, string> = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '\'': '&#39;',
+        '"': '&quot;'
+    };
+    return str.replace(/["&'<>]/g, char => escapeChars[char] || char);
+}