@duplojs/utils 0.3.0 → 1.0.0

package/dist/array/flat.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function flat(...args) {
+    if (args.length === 0) {
+        return (array) => flat(array);
+    }
+    if (args.length === 1) {
+        const [depthOrArray] = args;
+        if (Array.isArray(depthOrArray)) {
+            return depthOrArray.flat(1);
+        }
+        const depth = depthOrArray;
+        return (array) => flat(array, depth);
+    }
+    const [array, depth] = args;
+    return array.flat(depth);
+}
+
+exports.flat = flat;

package/dist/array/flat.d.ts

@@ -0,0 +1,4 @@
+export declare function flat(): <const GenericArray extends readonly unknown[]>(array: GenericArray) => FlatArray<GenericArray, 1>[];
+export declare function flat<const Depth extends number>(depth: Depth): <const GenericArray extends readonly unknown[]>(array: GenericArray) => FlatArray<GenericArray, Depth>[];
+export declare function flat<const GenericArray extends readonly unknown[], const Depth extends number>(array: GenericArray, depth: Depth): FlatArray<GenericArray, Depth>[];
+export declare function flat<const GenericArray extends readonly unknown[]>(array: GenericArray): FlatArray<GenericArray, 1>[];

package/dist/array/flat.mjs

@@ -0,0 +1,17 @@
+function flat(...args) {
+    if (args.length === 0) {
+        return (array) => flat(array);
+    }
+    if (args.length === 1) {
+        const [depthOrArray] = args;
+        if (Array.isArray(depthOrArray)) {
+            return depthOrArray.flat(1);
+        }
+        const depth = depthOrArray;
+        return (array) => flat(array, depth);
+    }
+    const [array, depth] = args;
+    return array.flat(depth);
+}
+
+export { flat };

package/dist/array/flatMap.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function flatMap(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (array) => flatMap(array, theFunction);
+    }
+    const [array, theFunction] = args;
+    return array.flatMap((element, index) => theFunction(element, { index }));
+}
+
+exports.flatMap = flatMap;

package/dist/array/flatMap.d.ts

@@ -0,0 +1,6 @@
+interface ArrayMapParams {
+    index: number;
+}
+export declare function flatMap<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (element: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => FlatArray<GenericOutput, 1>[];
+export declare function flatMap<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (element: GenericElement, params: ArrayMapParams) => GenericOutput): FlatArray<GenericOutput, 1>[];
+export {};

package/dist/array/flatMap.mjs

@@ -0,0 +1,10 @@
+function flatMap(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (array) => flatMap(array, theFunction);
+    }
+    const [array, theFunction] = args;
+    return array.flatMap((element, index) => theFunction(element, { index }));
+}
+
+export { flatMap };

package/dist/array/from.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+function from(input) {
+    if (typeof input === "object" && Symbol.asyncIterator in input) {
+        return (async () => {
+            const array = [];
+            for await (const element of input) {
+                array.push(element);
+            }
+            return array;
+        })();
+    }
+    return Array.from(input);
+}
+
+exports.from = from;

package/dist/array/from.d.ts

@@ -0,0 +1 @@
+export declare function from<const GenericArray extends (ArrayLike<unknown> | Iterable<unknown> | AsyncIterable<unknown>)>(input: GenericArray): GenericArray extends AsyncIterable<infer InferredValue> ? Promise<InferredValue[]> : GenericArray extends Iterable<infer InferredValue> ? InferredValue[] : GenericArray extends ArrayLike<infer InferredValue> ? InferredValue[] : never;

package/dist/array/from.mjs

@@ -0,0 +1,14 @@
+function from(input) {
+    if (typeof input === "object" && Symbol.asyncIterator in input) {
+        return (async () => {
+            const array = [];
+            for await (const element of input) {
+                array.push(element);
+            }
+            return array;
+        })();
+    }
+    return Array.from(input);
+}
+
+export { from };

package/dist/array/group.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var reduce = require('./reduce.cjs');
+
+function groupOutput(...args) {
+    if (args.length === 1) {
+        const [group] = args;
+        return (input) => groupOutput(group, input);
+    }
+    const [group, value] = args;
+    return {
+        group,
+        value,
+    };
+}
+function group(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (array) => group(array, theFunction);
+    }
+    const [array, theFunction] = args;
+    return reduce.reduce(array, ({ from }) => from({}), ({ index, element, lastValue, nextWithObject }) => {
+        const { group, value } = theFunction(element, {
+            index,
+            output: groupOutput,
+        });
+        return nextWithObject(lastValue, {
+            [group]: [
+                ...(lastValue[group] ?? []),
+                value,
+            ],
+        });
+    });
+}
+
+exports.group = group;
+exports.groupOutput = groupOutput;

package/dist/array/group.d.ts

@@ -0,0 +1,16 @@
+import { type SimplifyTopLevel } from "../common/types/simplifyTopLevel";
+export interface ArrayGroupFunctionOutput<GenericGroupeName extends string = string, GenericGroupeValue extends unknown = unknown> {
+    group: GenericGroupeName;
+    value: GenericGroupeValue;
+}
+export declare function groupOutput<GenericGroupeValue extends unknown, GenericGroupeName extends string>(group: GenericGroupeName): (value: GenericGroupeValue) => ArrayGroupFunctionOutput<GenericGroupeName, GenericGroupeValue>;
+export declare function groupOutput<GenericGroupeValue extends unknown, GenericGroupeName extends string>(group: GenericGroupeName, value: GenericGroupeValue): ArrayGroupFunctionOutput<GenericGroupeName, GenericGroupeValue>;
+export interface ArrayGroupFunctionParams {
+    index: number;
+    output: typeof groupOutput;
+}
+export type ArrayGroupResult<GenericOutput extends ArrayGroupFunctionOutput> = SimplifyTopLevel<{
+    [Output in GenericOutput as Output["group"]]?: Output["value"][];
+}>;
+export declare function group<GenericArray extends readonly unknown[], GenericOutput extends ArrayGroupFunctionOutput>(theFunction: (element: GenericArray[number], params: ArrayGroupFunctionParams) => GenericOutput): (array: GenericArray) => ArrayGroupResult<GenericOutput>;
+export declare function group<GenericElement extends unknown, GenericOutput extends ArrayGroupFunctionOutput>(array: readonly GenericElement[], theFunction: (element: GenericElement, params: ArrayGroupFunctionParams) => GenericOutput): ArrayGroupResult<GenericOutput>;

package/dist/array/group.mjs

@@ -0,0 +1,34 @@
+import { reduce } from './reduce.mjs';
+
+function groupOutput(...args) {
+    if (args.length === 1) {
+        const [group] = args;
+        return (input) => groupOutput(group, input);
+    }
+    const [group, value] = args;
+    return {
+        group,
+        value,
+    };
+}
+function group(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (array) => group(array, theFunction);
+    }
+    const [array, theFunction] = args;
+    return reduce(array, ({ from }) => from({}), ({ index, element, lastValue, nextWithObject }) => {
+        const { group, value } = theFunction(element, {
+            index,
+            output: groupOutput,
+        });
+        return nextWithObject(lastValue, {
+            [group]: [
+                ...(lastValue[group] ?? []),
+                value,
+            ],
+        });
+    });
+}
+
+export { group, groupOutput };

package/dist/array/includes.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function includes(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (array) => includes(array, value);
+    }
+    const [array, value] = args;
+    return array.includes(value);
+}
+
+exports.includes = includes;

package/dist/array/includes.d.ts

@@ -0,0 +1,2 @@
+export declare function includes<GenericArrayValue extends unknown>(value: NoInfer<GenericArrayValue>): (array: readonly GenericArrayValue[]) => boolean;
+export declare function includes<GenericArrayValue extends unknown>(array: readonly GenericArrayValue[], value: NoInfer<GenericArrayValue>): boolean;

package/dist/array/includes.mjs

@@ -0,0 +1,10 @@
+function includes(...args) {
+    if (args.length === 1) {
+        const [value] = args;
+        return (array) => includes(array, value);
+    }
+    const [array, value] = args;
+    return array.includes(value);
+}
+
+export { includes };

package/dist/array/index.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+var filter = require('./filter.cjs');
+var find = require('./find.cjs');
+var findLast = require('./findLast.cjs');
+var group = require('./group.cjs');
+var includes = require('./includes.cjs');
+var map = require('./map.cjs');
+var maxElements = require('./maxElements.cjs');
+var maxOf = require('./maxOf.cjs');
+var minElements = require('./minElements.cjs');
+var minOf = require('./minOf.cjs');
+var push = require('./push.cjs');
+var reduce = require('./reduce.cjs');
+var some = require('./some.cjs');
+var _default = require('./sort/default.cjs');
+var number = require('./sort/number.cjs');
+var string = require('./sort/string.cjs');
+var _delete = require('./splice/delete.cjs');
+var insert = require('./splice/insert.cjs');
+var replace = require('./splice/replace.cjs');
+var is = require('./is.cjs');
+var _default$1 = require('./at/default.cjs');
+var first = require('./at/first.cjs');
+var last = require('./at/last.cjs');
+var findIndex = require('./findIndex.cjs');
+var findLastIndex = require('./findLastIndex.cjs');
+var flat = require('./flat.cjs');
+var reverse = require('./reverse.cjs');
+var join = require('./join.cjs');
+var from = require('./from.cjs');
+var flatMap = require('./flatMap.cjs');
+var shift = require('./shift.cjs');
+var unshift = require('./unshift.cjs');
+var pop = require('./pop.cjs');
+var reduceRight = require('./reduceRight.cjs');
+var every = require('./every.cjs');
+var lastIndexOf = require('./lastIndexOf.cjs');
+var indexOf = require('./indexOf.cjs');
+var slice = require('./slice.cjs');
+var _default$2 = require('./fill/default.cjs');
+var all = require('./fill/all.cjs');
+var set = require('./set.cjs');
+var concat = require('./concat.cjs');
+var copyWithin = require('./copyWithin.cjs');
+var findAndReplace = require('./findAndReplace.cjs');
+var _delete$1 = require('./findAndSplice/delete.cjs');
+var insert$1 = require('./findAndSplice/insert.cjs');
+var replace$1 = require('./findAndSplice/replace.cjs');
+var sum = require('./sum.cjs');
+
+
+
+exports.filter = filter.filter;
+exports.find = find.find;
+exports.findLast = findLast.findLast;
+exports.group = group.group;
+exports.groupOutput = group.groupOutput;
+exports.includes = includes.includes;
+exports.map = map.map;
+exports.maxElements = maxElements.maxElements;
+exports.maxOf = maxOf.maxOf;
+exports.minElements = minElements.minElements;
+exports.minOf = minOf.minOf;
+exports.push = push.push;
+exports.reduce = reduce.reduce;
+exports.some = some.some;
+exports.sort = _default.sort;
+exports.sortNumber = number.sortNumber;
+exports.sortString = string.sortString;
+exports.spliceDelete = _delete.spliceDelete;
+exports.spliceInsert = insert.spliceInsert;
+exports.spliceReplace = replace.spliceReplace;
+exports.is = is.is;
+exports.at = _default$1.at;
+exports.first = first.first;
+exports.last = last.last;
+exports.findIndex = findIndex.findIndex;
+exports.findLastIndex = findLastIndex.findLastIndex;
+exports.flat = flat.flat;
+exports.reverse = reverse.reverse;
+exports.join = join.join;
+exports.from = from.from;
+exports.flatMap = flatMap.flatMap;
+exports.shift = shift.shift;
+exports.unshift = unshift.unshift;
+exports.pop = pop.pop;
+exports.reduceRight = reduceRight.reduceRight;
+exports.every = every.every;
+exports.lastIndexOf = lastIndexOf.lastIndexOf;
+exports.indexOf = indexOf.indexOf;
+exports.slice = slice.slice;
+exports.fill = _default$2.fill;
+exports.fillAll = all.fillAll;
+exports.set = set.set;
+exports.concat = concat.concat;
+exports.copyWithin = copyWithin.copyWithin;
+exports.findAndReplace = findAndReplace.findAndReplace;
+exports.findAndSpliceDelete = _delete$1.findAndSpliceDelete;
+exports.findAndSpliceInsert = insert$1.findAndSpliceInsert;
+exports.findAndSpliceReplace = replace$1.findAndSpliceReplace;
+exports.sum = sum.sum;

package/dist/array/index.d.ts

@@ -0,0 +1,40 @@
+export * from "./types";
+export * from "./filter";
+export * from "./find";
+export * from "./findLast";
+export * from "./group";
+export * from "./includes";
+export * from "./map";
+export * from "./maxElements";
+export * from "./maxOf";
+export * from "./minElements";
+export * from "./minOf";
+export * from "./push";
+export * from "./reduce";
+export * from "./some";
+export * from "./sort";
+export * from "./splice";
+export * from "./is";
+export * from "./at";
+export * from "./findIndex";
+export * from "./findLastIndex";
+export * from "./flat";
+export * from "./reverse";
+export * from "./join";
+export * from "./from";
+export * from "./flatMap";
+export * from "./shift";
+export * from "./unshift";
+export * from "./pop";
+export * from "./reduceRight";
+export * from "./every";
+export * from "./lastIndexOf";
+export * from "./indexOf";
+export * from "./slice";
+export * from "./fill";
+export * from "./set";
+export * from "./concat";
+export * from "./copyWithin";
+export * from "./findAndReplace";
+export * from "./findAndSplice";
+export * from "./sum";

package/dist/array/index.mjs

@@ -0,0 +1,48 @@
+export { filter } from './filter.mjs';
+export { find } from './find.mjs';
+export { findLast } from './findLast.mjs';
+export { group, groupOutput } from './group.mjs';
+export { includes } from './includes.mjs';
+export { map } from './map.mjs';
+export { maxElements } from './maxElements.mjs';
+export { maxOf } from './maxOf.mjs';
+export { minElements } from './minElements.mjs';
+export { minOf } from './minOf.mjs';
+export { push } from './push.mjs';
+export { reduce } from './reduce.mjs';
+export { some } from './some.mjs';
+export { sort } from './sort/default.mjs';
+export { sortNumber } from './sort/number.mjs';
+export { sortString } from './sort/string.mjs';
+export { spliceDelete } from './splice/delete.mjs';
+export { spliceInsert } from './splice/insert.mjs';
+export { spliceReplace } from './splice/replace.mjs';
+export { is } from './is.mjs';
+export { at } from './at/default.mjs';
+export { first } from './at/first.mjs';
+export { last } from './at/last.mjs';
+export { findIndex } from './findIndex.mjs';
+export { findLastIndex } from './findLastIndex.mjs';
+export { flat } from './flat.mjs';
+export { reverse } from './reverse.mjs';
+export { join } from './join.mjs';
+export { from } from './from.mjs';
+export { flatMap } from './flatMap.mjs';
+export { shift } from './shift.mjs';
+export { unshift } from './unshift.mjs';
+export { pop } from './pop.mjs';
+export { reduceRight } from './reduceRight.mjs';
+export { every } from './every.mjs';
+export { lastIndexOf } from './lastIndexOf.mjs';
+export { indexOf } from './indexOf.mjs';
+export { slice } from './slice.mjs';
+export { fill } from './fill/default.mjs';
+export { fillAll } from './fill/all.mjs';
+export { set } from './set.mjs';
+export { concat } from './concat.mjs';
+export { copyWithin } from './copyWithin.mjs';
+export { findAndReplace } from './findAndReplace.mjs';
+export { findAndSpliceDelete } from './findAndSplice/delete.mjs';
+export { findAndSpliceInsert } from './findAndSplice/insert.mjs';
+export { findAndSpliceReplace } from './findAndSplice/replace.mjs';
+export { sum } from './sum.mjs';

package/dist/array/indexOf.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+function indexOf(...args) {
+    if (args.length === 1) {
+        const [element] = args;
+        return (array) => indexOf(array, element);
+    }
+    const [array, element, fromIndex] = args;
+    // eslint-disable-next-line no-nested-ternary
+    const start = fromIndex !== undefined
+        ? (fromIndex < 0
+            ? Math.max(0, array.length + fromIndex)
+            : Math.min(fromIndex, array.length - 1))
+        : 0;
+    for (let index = start; index < array.length; index++) {
+        if (array[index] === element) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+exports.indexOf = indexOf;

package/dist/array/indexOf.d.ts

@@ -0,0 +1,2 @@
+export declare function indexOf<GenericElement extends unknown>(element: GenericElement): (array: readonly GenericElement[]) => number | undefined;
+export declare function indexOf<GenericElement extends unknown>(array: readonly GenericElement[], element: GenericElement, fromIndex?: number): number | undefined;

package/dist/array/indexOf.mjs

@@ -0,0 +1,21 @@
+function indexOf(...args) {
+    if (args.length === 1) {
+        const [element] = args;
+        return (array) => indexOf(array, element);
+    }
+    const [array, element, fromIndex] = args;
+    // eslint-disable-next-line no-nested-ternary
+    const start = fromIndex !== undefined
+        ? (fromIndex < 0
+            ? Math.max(0, array.length + fromIndex)
+            : Math.min(fromIndex, array.length - 1))
+        : 0;
+    for (let index = start; index < array.length; index++) {
+        if (array[index] === element) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+export { indexOf };

package/dist/array/is.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function is(arg) {
+    return arg instanceof Array;
+}
+
+exports.is = is;

package/dist/array/is.d.ts

@@ -0,0 +1 @@
+export declare function is<GenericValue extends unknown>(arg: GenericValue): arg is GenericValue extends any[] ? GenericValue : never;

package/dist/array/is.mjs

@@ -0,0 +1,5 @@
+function is(arg) {
+    return arg instanceof Array;
+}
+
+export { is };

package/dist/array/join.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function join(...args) {
+    if (args.length === 1) {
+        const [separator] = args;
+        return (array) => join(array, separator);
+    }
+    const [array, separator] = args;
+    return array.join(separator);
+}
+
+exports.join = join;

package/dist/array/join.d.ts

@@ -0,0 +1,8 @@
+import { type IsEqual } from "../common";
+import { type Adaptor } from "../common/types/adaptor";
+import { type AnyTuple } from "../common/types/anyTuple";
+import { type ShiftTuple } from "./types";
+type ComputeResult<GenericArray extends readonly string[], GenericSeparator extends string, Depth extends readonly unknown[] = []> = Depth["length"] extends 40 ? string : GenericArray extends AnyTuple ? IsEqual<GenericArray["length"], 1> extends true ? GenericArray[0] : `${GenericArray[0]}${GenericSeparator}${ComputeResult<Adaptor<ShiftTuple<GenericArray>, readonly string[]>, GenericSeparator, [...Depth, 0]>}` : string;
+export declare function join<GenericArray extends readonly string[], GenericSeparator extends string>(separator: GenericSeparator): (array: GenericArray) => GenericArray extends AnyTuple ? ComputeResult<GenericArray, GenericSeparator> : string;
+export declare function join<GenericArray extends readonly string[], GenericSeparator extends string>(array: GenericArray, separator: GenericSeparator): GenericArray extends AnyTuple ? ComputeResult<GenericArray, GenericSeparator> : string;
+export {};

package/dist/array/join.mjs

@@ -0,0 +1,10 @@
+function join(...args) {
+    if (args.length === 1) {
+        const [separator] = args;
+        return (array) => join(array, separator);
+    }
+    const [array, separator] = args;
+    return array.join(separator);
+}
+
+export { join };

package/dist/array/lastIndexOf.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+function lastIndexOf(...args) {
+    if (args.length === 1) {
+        const [element] = args;
+        return (array) => lastIndexOf(array, element);
+    }
+    const [array, element, fromIndex] = args;
+    // eslint-disable-next-line no-nested-ternary
+    const start = fromIndex !== undefined
+        ? (fromIndex < 0
+            ? Math.max(0, array.length + fromIndex)
+            : Math.min(fromIndex, array.length - 1))
+        : array.length - 1;
+    for (let index = start; index >= 0; index--) {
+        if (array[index] === element) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+exports.lastIndexOf = lastIndexOf;

package/dist/array/lastIndexOf.d.ts

@@ -0,0 +1,2 @@
+export declare function lastIndexOf<GenericElement extends unknown>(element: GenericElement): (array: readonly GenericElement[]) => number | undefined;
+export declare function lastIndexOf<GenericElement extends unknown>(array: readonly GenericElement[], element: GenericElement, fromIndex?: number): number | undefined;

package/dist/array/lastIndexOf.mjs

@@ -0,0 +1,21 @@
+function lastIndexOf(...args) {
+    if (args.length === 1) {
+        const [element] = args;
+        return (array) => lastIndexOf(array, element);
+    }
+    const [array, element, fromIndex] = args;
+    // eslint-disable-next-line no-nested-ternary
+    const start = fromIndex !== undefined
+        ? (fromIndex < 0
+            ? Math.max(0, array.length + fromIndex)
+            : Math.min(fromIndex, array.length - 1))
+        : array.length - 1;
+    for (let index = start; index >= 0; index--) {
+        if (array[index] === element) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+export { lastIndexOf };

package/dist/array/map.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function map(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (array) => map(array, theFunction);
+    }
+    const [array, theFunction] = args;
+    return array.map((item, index) => theFunction(item, { index }));
+}
+
+exports.map = map;

package/dist/array/map.d.ts

@@ -0,0 +1,6 @@
+interface ArrayMapParams {
+    index: number;
+}
+export declare function map<GenericArray extends readonly unknown[], GenericOutput extends unknown>(theFunction: (item: GenericArray[number], params: ArrayMapParams) => GenericOutput): (array: GenericArray) => GenericOutput[];
+export declare function map<GenericElement extends unknown, GenericOutput extends unknown>(array: readonly GenericElement[], theFunction: (item: GenericElement, params: ArrayMapParams) => GenericOutput): GenericOutput[];
+export {};

package/dist/array/map.mjs

@@ -0,0 +1,10 @@
+function map(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (array) => map(array, theFunction);
+    }
+    const [array, theFunction] = args;
+    return array.map((item, index) => theFunction(item, { index }));
+}
+
+export { map };

package/dist/array/maxElements.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function maxElements(...args) {
+    if (args.length === 1) {
+        const [maxLength] = args;
+        return (array) => maxElements(array, maxLength);
+    }
+    const [array, maxLength] = args;
+    return array.length <= maxLength;
+}
+
+exports.maxElements = maxElements;

package/dist/array/maxElements.d.ts

@@ -0,0 +1,2 @@
+export declare function maxElements<GenericArray extends readonly unknown[]>(maxLength: number): (array: GenericArray) => boolean;
+export declare function maxElements<GenericArray extends readonly unknown[]>(array: GenericArray, maxLength: number): boolean;

package/dist/array/maxElements.mjs

@@ -0,0 +1,10 @@
+function maxElements(...args) {
+    if (args.length === 1) {
+        const [maxLength] = args;
+        return (array) => maxElements(array, maxLength);
+    }
+    const [array, maxLength] = args;
+    return array.length <= maxLength;
+}
+
+export { maxElements };