moderndash 0.0.16 → 0.0.18

package/src/function/before.ts

@@ -1,31 +0,0 @@
-/**
- * Creates a function that invokes `func`, 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 = () => console.log("Caution!");
- *
- * // Only call caution two times
- * const reducedCaution = before(2, caution)
- *
- * reducedCaution()
- * reducedCaution()
- * reducedCaution()
- * // => `caution` is invoked twice
- */
-
-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

@@ -1,125 +0,0 @@
-import type { GenericFunction } from 'src/types.js';
-
-// TODO this is a port from lodash, it probably can be improved and shortened, also fix TS errors
-export function debounce<TFunc extends GenericFunction<TFunc>>(
-    fn: TFunc, wait = 0, options: { leading?: boolean, maxWait?: number, trailing?: boolean } = {}
-): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc> {
-    let lastArgs: Parameters<TFunc> | undefined;
-    let lastThis: ThisParameterType<TFunc> | undefined;
-    let result: ReturnType<TFunc>;
-    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<TFunc> | undefined = lastArgs;
-        const thisArg: ThisParameterType<TFunc> | undefined = lastThis;
-
-        lastArgs = lastThis = undefined;
-        lastInvokeTime = time;
-        // @ts-expect-error
-        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-expect-error
-        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<TFunc>, ...args: Parameters<TFunc>): ReturnType<TFunc> {
-        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

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

package/src/function/memoize.ts

@@ -1,63 +0,0 @@
-import type{ GenericFunction } from 'src/types.js';
-
-const defaultResolver = (...args: unknown[]) => JSON.stringify(args);
-
-/**
- * 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.
- * @typeParam TFunc - The input function type
- * @typeParam Cache - The cache map type
- * @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 GenericFunction<TFunc>, Cache extends Map<string | symbol, ReturnType<TFunc>>>(
-    func: TFunc, resolver: ((...args: Parameters<TFunc>) => string | symbol) = defaultResolver
-): TFunc & { cache: Cache } {
-
-    const cache = new Map() as Cache;
-    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

@@ -1,22 +0,0 @@
-import type { GenericFunction } from 'src/types.js';
-
-import { before } from '@function/before';
-
-/**
- * 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(() => console.log('initialize'))
- * initialize()
- * initialize()
- * // => `createApplication` is invoked once
- */
-
-export function once<TFunc extends GenericFunction<TFunc>>(func: TFunc): TFunc {
-    return before(1, func);
-}

package/src/function/throttle.ts

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

package/src/function/times.ts

@@ -1,24 +0,0 @@
-/**
- * Invokes the iteratee `n` times, returning an array of the results of
- * each invocation. The function is invoked with one argument: (index).
- *
- * @example
- * times(3, index => console.log("Run", index)))
- * // => "Run 0" | "Run 1" | "Run 2"
- * times(3, Math.random)
- * // => [0.123, 0.456, 0.789]
- * times(4, () => 0)
- * // => [0, 0, 0, 0]
- * @category Function
- * @param n - The number of times to invoke `func`.
- * @param iteratee - The function invoked per iteration.
- * @returns Returns the array of results.
- */
-
-export function times<T>(n: number, func: (index: number) => T): T[] {
-    const result: T[] = [];
-    for (let i = 0; i < n; i++) {
-        result.push(func(i));
-    }
-    return result;
-}

package/src/helpers/collections.ts

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

package/src/helpers/shortHands.ts

@@ -1,17 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

package/src/index.ts

@@ -1,7 +0,0 @@
-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

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

package/src/lang/isEmpty.ts

@@ -1,51 +0,0 @@
-/**
- * Checks if `value` is an empty object, collection, map, or set.
- *
- * Objects are considered empty if they have no own enumerable string keyed
- * properties.
- *
- * Array-like values such as `arguments` objects, arrays, buffers, strings, or
- * Similarly, maps and sets are considered empty if they have a `size` of `0`.
- *
- * @category Lang
- * @param value - The value to check.
- * @returns Returns `true` if `value` is empty, else `false`.
- * @example
- * isEmpty(null)
- * // => true
- *
- * isEmpty({})
- * // => true
- *
- * isEmpty("")
- * // => true
- *
- * isEmpty([1, 2, 3])
- * // => false
- *
- * isEmpty('abc')
- * // => false
- *
- * isEmpty({ 'a': 1 })
- * // => false
- */
-
-export function isEmpty(value: string | object | null | undefined): boolean {
-    if (value === null || value === undefined) {
-        return true;
-    }
-
-    if (typeof value === 'string' || Array.isArray(value)) {
-        return value.length === 0;
-    }
-
-    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

@@ -1,80 +0,0 @@
-import type { RecordKey } from '../types';
-
-
-/**
- * Performs a deep comparison between two values to determine if they are
- * equivalent.
- *
- * **Note:** This method supports comparing arrays, array buffers, booleans,
- * date objects, error objects, maps, numbers, `Object` objects, regexes,
- * sets, strings, symbols, and typed arrays. `Object` objects are compared
- * by their own, not inherited, enumerable properties. Functions and DOM
- * nodes are compared by strict equality, i.e. `===`.
- *
- * @category Lang
- * @param value1 - The value to compare.
- * @param value2 - The other value to compare.
- * @returns Returns `true` if the values are equivalent, else `false`.
- * @example
- * var object = { 'a': 1 };
- * var other = { 'a': 1 };
- *
- * _.isEqual(object, other);
- * // => true
- *
- * object === other;
- * // => false
- */
-
-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

@@ -1,34 +0,0 @@
-import { isEqual } from '@lang/isEqual';
-
-/**
- * This method is like `_.isEqual` except that it accepts `customizer` which
- * is invoked to compare values. If `customizer` returns `undefined`, comparisons
- * are handled by the method instead. The `customizer` is invoked with up to
- * six arguments: (objValue, othValue [, index|key, object, other, stack]).
- *
- * @category Lang
- * @param value1 - The value to compare.
- * @param value2 - The other value to compare.
- * @param customizer - The function to customize comparisons.
- * @returns Returns `true` if the values are equivalent, else `false`.
- * @example
- * function isGreeting(value) {
- *   return /^h(?:i|ello)$/.test(value);
- * }
- *
- * function customizer(objValue, othValue) {
- *   if (isGreeting(objValue) && isGreeting(othValue)) {
- *     return true;
- *   }
- * }
- *
- * var array = ['hello', 'goodbye'];
- * var other = ['hi', 'goodbye'];
- *
- * isEqualWith(array, other, customizer);
- * // => true
-*/
-
-export function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean {
-    return isEqual(customizer(a), customizer(b));
-}

package/src/lang/isPlainObject.ts

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

package/src/object/index.ts

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

package/src/object/pick.ts

@@ -1,21 +0,0 @@
-/**
- * Creates an object composed of the picked `object` properties.
- *
- * @example
- * const object = { 'a': 1, 'b': '2', 'c': 3 }
- *
- * pick(object, ['a', 'c'])
- * // => { 'a': 1, 'c': 3 }
- * @category Object
- * @param object - The source object.
- * @param keys - The property paths to pick.
- * @returns Returns the new object.
- */
-
-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

@@ -1,30 +0,0 @@
-import { splitWords } from '@helpers/stringModifiers';
-
-/**
- * Converts `string` to camelCase.
- *
- * @example
- * camelCase('Foo Bar')
- * // => 'fooBar'
- * camelCase('--foo-bar--')
- * // => 'fooBar'
- * camelCase('__FOO_BAR__')
- * // => 'fooBar'
- * @category String
- * @param str - The string to convert.
- * @returns Returns the camel cased string.
- */
-
-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

@@ -1,14 +0,0 @@
-/**
- * Converts the first character of a string to upper case and the remaining to lower case.
- *
- * @example
- * capitalize('FRED')
- * // => 'Fred'
- * @category String
- * @param str - The string to capitalize.
- * @returns Returns the capitalized string.
- */
-
-export function capitalize(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}

package/src/string/deburr.ts

@@ -1,20 +0,0 @@
-/**
- * Deburrs a string by converting
- * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
- * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
- * letters to basic Latin letters and removing
- * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
- *
- * @example
- * deburr('déjà vu')
- * // => 'deja vu'
- * @category String
- * @param str - The string to deburr.
- * @returns Returns the deburred string.
- */
-
-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

@@ -1,21 +0,0 @@
-/**
- * Converts the characters `&`, `<`, `>`, `"` and `'` in a string to their corresponding HTML entities.
- *
- * @example
- * escape('fred, barney, & pebbles')
- * // => 'fred, barney, &amp; pebbles'
- * @category String
- * @param str - The string to escape.
- * @returns Returns the escaped string.
- */
-
-export function escape(str: string): string {
-    const escapeChars: Record<string, string> = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '\'': '&#39;',
-        '"': '&quot;'
-    };
-    return str.replace(/["&'<>]/g, char => escapeChars[char] || char);
-}

package/src/string/escapeRegExp.ts

@@ -1,15 +0,0 @@
-/**
- * Escapes the `RegExp` special characters `^`, `$`, `\`, `.`, `*`, `+`,
- * `?`, `(`, `)`, `[`, `]`, `{`, `}`, and `|` in a string.
- *
- * @example
- * escapeRegExp('[moderndash](https://moderndash.io/)')
- * // => '\[moderndash\]\(https://moderndash\.io/\)'
- * @category String
- * @param str - The string to escape.
- * @returns Returns the escaped string.
- */
-
-export function escapeRegExp(str: string): string {
-    return str.replace(/[$()*+.?[\\\]^{|}]/g, '\\$&');
-}

package/src/string/index.ts

@@ -1,11 +0,0 @@
-export * from './camelCase';
-export * from './capitalize';
-export * from './deburr';
-export * from './escape';
-export * from './escapeRegExp';
-export * from './kebabCase';
-export * from './pascalCase';
-export * from './snakeCase';
-export * from './startCase';
-export * from './stripSpecialChars';
-export * from './unescape';