@duplojs/utils 0.3.1 → 1.0.1

package/dist/array/at/default.cjs

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

package/dist/array/at/default.d.ts

@@ -0,0 +1,5 @@
+import type { AtTuple } from "../types";
+export declare function at<GenericTuple extends readonly unknown[], GenericIndex extends number>(index: GenericIndex): (array: GenericTuple) => AtTuple<GenericTuple, GenericIndex>;
+export declare function at<GenericElement extends unknown>(index: number): (array: readonly GenericElement[]) => GenericElement | undefined;
+export declare function at<GenericTuple extends readonly unknown[], GenericIndex extends number>(array: GenericTuple, index: GenericIndex): AtTuple<GenericTuple, GenericIndex>;
+export declare function at<GenericElement extends unknown>(array: readonly GenericElement[], index: number): GenericElement | undefined;

package/dist/array/at/default.mjs

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

package/dist/array/at/first.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function first(array) {
+    return array[0];
+}
+
+exports.first = first;

package/dist/array/at/first.d.ts

@@ -0,0 +1,2 @@
+import { type AnyTuple } from "../../common";
+export declare function first<GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends AnyTuple ? GenericArray[0] : GenericArray[number] | undefined;

package/dist/array/at/first.mjs

@@ -0,0 +1,5 @@
+function first(array) {
+    return array[0];
+}
+
+export { first };

package/dist/array/at/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./default";
+export * from "./first";
+export * from "./last";

package/dist/array/at/last.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function last(array) {
+    return array.at(-1);
+}
+
+exports.last = last;

package/dist/array/at/last.d.ts

@@ -0,0 +1 @@
+export declare function last<GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends readonly [...any[], infer InferredValue] ? InferredValue : GenericArray[number] | undefined;

package/dist/array/at/last.mjs

@@ -0,0 +1,5 @@
+function last(array) {
+    return array.at(-1);
+}
+
+export { last };

package/dist/array/concat.cjs

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

package/dist/array/concat.d.ts

@@ -0,0 +1,2 @@
+export declare function concat<GenericElement extends unknown>(elements: readonly GenericElement[]): (array: readonly GenericElement[]) => GenericElement[];
+export declare function concat<GenericElement extends unknown>(array: readonly GenericElement[], elements: readonly GenericElement[], ...elementsRest: readonly GenericElement[][]): GenericElement[];

package/dist/array/concat.mjs

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

package/dist/array/copyWithin.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function copyWithin(...args) {
+    if (!Array.isArray(args[0])) {
+        const [target, start, end] = args;
+        return (array) => copyWithin(array, target, start, end);
+    }
+    const [array, target, start, end] = args;
+    return [...array].copyWithin(target, start, end);
+}
+
+exports.copyWithin = copyWithin;

package/dist/array/copyWithin.d.ts

@@ -0,0 +1,2 @@
+export declare function copyWithin<GenericElement extends unknown>(target: number, start: number, end?: number): (array: readonly GenericElement[]) => GenericElement[];
+export declare function copyWithin<GenericElement extends unknown>(array: readonly GenericElement[], target: number, start: number, end?: number): GenericElement[];

package/dist/array/copyWithin.mjs

@@ -0,0 +1,10 @@
+function copyWithin(...args) {
+    if (!Array.isArray(args[0])) {
+        const [target, start, end] = args;
+        return (array) => copyWithin(array, target, start, end);
+    }
+    const [array, target, start, end] = args;
+    return [...array].copyWithin(target, start, end);
+}
+
+export { copyWithin };

package/dist/array/every.cjs

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

package/dist/array/every.d.ts

@@ -0,0 +1,6 @@
+interface ArrayEveryParams {
+    index: number;
+}
+export declare function every<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArrayEveryParams) => boolean): (array: GenericArray) => boolean;
+export declare function every<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayEveryParams) => boolean): boolean;
+export {};

package/dist/array/every.mjs

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

package/dist/array/fill/all.cjs

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

package/dist/array/fill/all.d.ts

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

package/dist/array/fill/all.mjs

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

package/dist/array/fill/default.cjs

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

package/dist/array/fill/default.d.ts

@@ -0,0 +1,2 @@
+export declare function fill<GenericElement extends unknown>(value: GenericElement, start: number, end: number): (array: readonly GenericElement[]) => GenericElement[];
+export declare function fill<GenericElement extends unknown>(array: readonly GenericElement[], value: GenericElement, start: number, end: number): GenericElement[];

package/dist/array/fill/default.mjs

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

package/dist/array/fill/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./default";
+export * from "./all";

package/dist/array/filter.cjs

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

package/dist/array/filter.d.ts

@@ -0,0 +1,8 @@
+interface ArrayFilterParams {
+    index: number;
+}
+export declare function filter<GenericArray extends readonly unknown[], GenericOutput extends GenericArray[number]>(predicate: (item: GenericArray[number], params: ArrayFilterParams) => item is GenericOutput): (array: GenericArray) => GenericOutput[];
+export declare function filter<GenericElement extends unknown, GenericOutput extends GenericElement>(array: readonly GenericElement[], predicate: (item: GenericElement, params: ArrayFilterParams) => item is GenericOutput): GenericOutput[];
+export declare function filter<GenericArray extends readonly unknown[]>(predicate: (item: GenericArray[number], params: ArrayFilterParams) => boolean): (array: GenericArray) => GenericArray[number][];
+export declare function filter<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (item: GenericElement, params: ArrayFilterParams) => boolean): GenericElement[];
+export {};

package/dist/array/filter.mjs

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

package/dist/array/find.cjs

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

package/dist/array/find.d.ts

@@ -0,0 +1,8 @@
+interface ArrayFindParams {
+    index: number;
+}
+export declare function find<GenericArray extends readonly unknown[], GenericOutput extends GenericArray[number]>(predicate: (element: GenericArray[number], params: ArrayFindParams) => element is GenericOutput): (array: GenericArray) => GenericOutput | undefined;
+export declare function find<GenericElement extends unknown, GenericOutput extends GenericElement>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindParams) => element is GenericOutput): GenericOutput | undefined;
+export declare function find<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArrayFindParams) => boolean): (array: GenericArray) => GenericArray[number] | undefined;
+export declare function find<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindParams) => boolean): GenericElement | undefined;
+export {};

package/dist/array/find.mjs

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

package/dist/array/findAndReplace.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function findAndReplace(...args) {
+    if (args.length === 2) {
+        const [predicate, value] = args;
+        return (input) => findAndReplace(input, predicate, value);
+    }
+    const [input, predicate, value] = args;
+    for (let index = 0; index < input.length; index++) {
+        if (predicate(input[index], { index })) {
+            const newArray = [...input];
+            newArray[index] = value;
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+exports.findAndReplace = findAndReplace;

package/dist/array/findAndReplace.d.ts

@@ -0,0 +1,7 @@
+import { type AnyValue } from "../common";
+interface ArrayFindAndSetIndexParams {
+    index: number;
+}
+export declare function findAndReplace<GenericArray extends readonly unknown[], GenericValue extends AnyValue>(predicate: (element: GenericArray[number], params: ArrayFindAndSetIndexParams) => boolean, value: GenericValue): (input: GenericArray) => (GenericArray[number] | GenericValue)[] | undefined;
+export declare function findAndReplace<GenericArray extends readonly unknown[], GenericValue extends AnyValue>(input: GenericArray, predicate: (element: GenericArray[number], params: ArrayFindAndSetIndexParams) => boolean, value: GenericValue): (GenericArray[number] | GenericValue)[] | undefined;
+export {};

package/dist/array/findAndReplace.mjs

@@ -0,0 +1,17 @@
+function findAndReplace(...args) {
+    if (args.length === 2) {
+        const [predicate, value] = args;
+        return (input) => findAndReplace(input, predicate, value);
+    }
+    const [input, predicate, value] = args;
+    for (let index = 0; index < input.length; index++) {
+        if (predicate(input[index], { index })) {
+            const newArray = [...input];
+            newArray[index] = value;
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+export { findAndReplace };

package/dist/array/findAndSplice/delete.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function findAndSpliceDelete(...args) {
+    if (args.length === 2) {
+        const [predicate, deleteCount] = args;
+        return (array) => findAndSpliceDelete(array, predicate, deleteCount);
+    }
+    const [array, predicate, deleteCount] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            const newArray = [...array];
+            newArray.splice(index, deleteCount);
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+exports.findAndSpliceDelete = findAndSpliceDelete;

package/dist/array/findAndSplice/delete.d.ts

@@ -0,0 +1,6 @@
+interface ArrayFindAndSpliceDeleteIndexParams {
+    index: number;
+}
+export declare function findAndSpliceDelete<GenericElement extends unknown>(predicate: (element: GenericElement, params: ArrayFindAndSpliceDeleteIndexParams) => boolean, deleteCount: number): (array: readonly GenericElement[]) => GenericElement[] | undefined;
+export declare function findAndSpliceDelete<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindAndSpliceDeleteIndexParams) => boolean, deleteCount: number): GenericElement[] | undefined;
+export {};

package/dist/array/findAndSplice/delete.mjs

@@ -0,0 +1,17 @@
+function findAndSpliceDelete(...args) {
+    if (args.length === 2) {
+        const [predicate, deleteCount] = args;
+        return (array) => findAndSpliceDelete(array, predicate, deleteCount);
+    }
+    const [array, predicate, deleteCount] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            const newArray = [...array];
+            newArray.splice(index, deleteCount);
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+export { findAndSpliceDelete };

package/dist/array/findAndSplice/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./delete";
+export * from "./insert";
+export * from "./replace";

package/dist/array/findAndSplice/insert.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function findAndSpliceInsert(...args) {
+    if (args.length === 2) {
+        const [predicate, elements] = args;
+        return (array) => findAndSpliceInsert(array, predicate, elements);
+    }
+    const [array, predicate, elements] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            const newArray = [...array];
+            newArray.splice(index, 0, ...elements);
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+exports.findAndSpliceInsert = findAndSpliceInsert;

package/dist/array/findAndSplice/insert.d.ts

@@ -0,0 +1,6 @@
+interface ArrayFindAndSpliceInsertIndexParams {
+    index: number;
+}
+export declare function findAndSpliceInsert<GenericElement extends unknown>(predicate: (element: GenericElement, params: ArrayFindAndSpliceInsertIndexParams) => boolean, elements: GenericElement[]): (array: readonly GenericElement[]) => GenericElement[] | undefined;
+export declare function findAndSpliceInsert<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindAndSpliceInsertIndexParams) => boolean, elements: GenericElement[]): GenericElement[] | undefined;
+export {};

package/dist/array/findAndSplice/insert.mjs

@@ -0,0 +1,17 @@
+function findAndSpliceInsert(...args) {
+    if (args.length === 2) {
+        const [predicate, elements] = args;
+        return (array) => findAndSpliceInsert(array, predicate, elements);
+    }
+    const [array, predicate, elements] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            const newArray = [...array];
+            newArray.splice(index, 0, ...elements);
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+export { findAndSpliceInsert };

package/dist/array/findAndSplice/replace.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+function findAndSpliceReplace(...args) {
+    if (args.length === 2) {
+        const [predicate, elements] = args;
+        return (array) => findAndSpliceReplace(array, predicate, elements);
+    }
+    const [array, predicate, elements] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            const newArray = [...array];
+            newArray.splice(index, elements.length, ...elements);
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+exports.findAndSpliceReplace = findAndSpliceReplace;

package/dist/array/findAndSplice/replace.d.ts

@@ -0,0 +1,6 @@
+interface ArrayFindAndSpliceReplaceIndexParams {
+    index: number;
+}
+export declare function findAndSpliceReplace<GenericElement extends unknown>(predicate: (element: GenericElement, params: ArrayFindAndSpliceReplaceIndexParams) => boolean, elements: GenericElement[]): (array: readonly GenericElement[]) => GenericElement[] | undefined;
+export declare function findAndSpliceReplace<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindAndSpliceReplaceIndexParams) => boolean, elements: GenericElement[]): GenericElement[] | undefined;
+export {};

package/dist/array/findAndSplice/replace.mjs

@@ -0,0 +1,17 @@
+function findAndSpliceReplace(...args) {
+    if (args.length === 2) {
+        const [predicate, elements] = args;
+        return (array) => findAndSpliceReplace(array, predicate, elements);
+    }
+    const [array, predicate, elements] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            const newArray = [...array];
+            newArray.splice(index, elements.length, ...elements);
+            return newArray;
+        }
+    }
+    return undefined;
+}
+
+export { findAndSpliceReplace };

package/dist/array/findIndex.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function findIndex(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (array) => findIndex(array, predicate);
+    }
+    const [array, predicate] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+exports.findIndex = findIndex;

package/dist/array/findIndex.d.ts

@@ -0,0 +1,6 @@
+interface ArrayFindIndexParams {
+    index: number;
+}
+export declare function findIndex<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArrayFindIndexParams) => boolean): (array: GenericArray) => number | undefined;
+export declare function findIndex<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindIndexParams) => boolean): number | undefined;
+export {};

package/dist/array/findIndex.mjs

@@ -0,0 +1,15 @@
+function findIndex(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (array) => findIndex(array, predicate);
+    }
+    const [array, predicate] = args;
+    for (let index = 0; index < array.length; index++) {
+        if (predicate(array[index], { index })) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+export { findIndex };

package/dist/array/findLast.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function findLast(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (input) => findLast(input, predicate);
+    }
+    const [input, predicate] = args;
+    for (let index = input.length - 1; index >= 0; index--) {
+        const item = input[index];
+        if (predicate(item, { index })) {
+            return item;
+        }
+    }
+    return undefined;
+}
+
+exports.findLast = findLast;

package/dist/array/findLast.d.ts

@@ -0,0 +1,8 @@
+interface ArrayFindLastParams {
+    index: number;
+}
+export declare function findLast<GenericArray extends readonly unknown[], GenericOutput extends GenericArray[number]>(predicate: (element: GenericArray[number], params: ArrayFindLastParams) => element is GenericOutput): (input: GenericArray) => GenericOutput | undefined;
+export declare function findLast<GenericElement extends unknown, GenericOutput extends GenericElement>(input: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindLastParams) => element is GenericOutput): GenericOutput | undefined;
+export declare function findLast<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArrayFindLastParams) => boolean): (input: GenericArray) => GenericArray[number] | undefined;
+export declare function findLast<GenericElement extends unknown>(input: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindLastParams) => boolean): GenericElement | undefined;
+export {};

package/dist/array/findLast.mjs

@@ -0,0 +1,16 @@
+function findLast(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (input) => findLast(input, predicate);
+    }
+    const [input, predicate] = args;
+    for (let index = input.length - 1; index >= 0; index--) {
+        const item = input[index];
+        if (predicate(item, { index })) {
+            return item;
+        }
+    }
+    return undefined;
+}
+
+export { findLast };

package/dist/array/findLastIndex.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function findLastIndex(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (array) => findLastIndex(array, predicate);
+    }
+    const [array, predicate] = args;
+    for (let index = array.length - 1; index >= 0; index--) {
+        const item = array[index];
+        if (predicate(item, { index })) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+exports.findLastIndex = findLastIndex;

package/dist/array/findLastIndex.d.ts

@@ -0,0 +1,6 @@
+interface ArrayFindLastIndexParams {
+    index: number;
+}
+export declare function findLastIndex<GenericArray extends readonly unknown[]>(predicate: (element: GenericArray[number], params: ArrayFindLastIndexParams) => boolean): (array: GenericArray) => number | undefined;
+export declare function findLastIndex<GenericElement extends unknown>(array: readonly GenericElement[], predicate: (element: GenericElement, params: ArrayFindLastIndexParams) => boolean): number | undefined;
+export {};

package/dist/array/findLastIndex.mjs

@@ -0,0 +1,16 @@
+function findLastIndex(...args) {
+    if (args.length === 1) {
+        const [predicate] = args;
+        return (array) => findLastIndex(array, predicate);
+    }
+    const [array, predicate] = args;
+    for (let index = array.length - 1; index >= 0; index--) {
+        const item = array[index];
+        if (predicate(item, { index })) {
+            return index;
+        }
+    }
+    return undefined;
+}
+
+export { findLastIndex };