@duplojs/utils 0.3.0 → 1.0.0

package/dist/array/maxOf.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function maxOf(values) {
+    const [first, ...rest] = values;
+    if (first === undefined) {
+        return undefined;
+    }
+    let result = first;
+    for (const value of rest) {
+        if (value > result) {
+            result = value;
+        }
+    }
+    return result;
+}
+
+exports.maxOf = maxOf;

package/dist/array/maxOf.d.ts

@@ -0,0 +1 @@
+export declare function maxOf<GenericArray extends readonly number[]>(values: GenericArray): number | undefined;

package/dist/array/maxOf.mjs

@@ -0,0 +1,15 @@
+function maxOf(values) {
+    const [first, ...rest] = values;
+    if (first === undefined) {
+        return undefined;
+    }
+    let result = first;
+    for (const value of rest) {
+        if (value > result) {
+            result = value;
+        }
+    }
+    return result;
+}
+
+export { maxOf };

package/dist/array/minElements.cjs

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

package/dist/array/minElements.d.ts

@@ -0,0 +1,3 @@
+import { type CreateTupleFromLength } from "../common/types/createTupleFromLength";
+export declare function minElements<GenericValue extends unknown, GenericLength extends number>(minLength: GenericLength): (array: readonly GenericValue[]) => array is CreateTupleFromLength<GenericValue, GenericLength>;
+export declare function minElements<GenericValue extends unknown, GenericLength extends number>(array: readonly GenericValue[], minLength: GenericLength): array is CreateTupleFromLength<GenericValue, GenericLength>;

package/dist/array/minElements.mjs

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

package/dist/array/minOf.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function minOf(values) {
+    const [first, ...rest] = values;
+    if (first === undefined) {
+        return undefined;
+    }
+    let result = first;
+    for (const value of rest) {
+        if (value < result) {
+            result = value;
+        }
+    }
+    return result;
+}
+
+exports.minOf = minOf;

package/dist/array/minOf.d.ts

@@ -0,0 +1 @@
+export declare function minOf<GenericArray extends readonly number[]>(values: GenericArray): number | undefined;

package/dist/array/minOf.mjs

@@ -0,0 +1,15 @@
+function minOf(values) {
+    const [first, ...rest] = values;
+    if (first === undefined) {
+        return undefined;
+    }
+    let result = first;
+    for (const value of rest) {
+        if (value < result) {
+            result = value;
+        }
+    }
+    return result;
+}
+
+export { minOf };

package/dist/array/pop.cjs

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

package/dist/array/pop.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../common";
+import { type PopTuple } from "./types";
+export declare function pop<const GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends AnyTuple ? PopTuple<GenericArray> : GenericArray;

package/dist/array/pop.mjs

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

package/dist/array/push.cjs

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

package/dist/array/push.d.ts

@@ -0,0 +1,2 @@
+export declare function push<GenericElement extends unknown>(item: NoInfer<GenericElement>): (array: readonly GenericElement[]) => GenericElement[];
+export declare function push<GenericElement extends unknown>(array: readonly GenericElement[], item: NoInfer<GenericElement>, ...items: NoInfer<GenericElement>[]): GenericElement[];

package/dist/array/push.mjs

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

package/dist/array/reduce.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var override = require('../object/override.cjs');
+
+const arrayReduceFromKind = kind.createKind("array-reduce-from");
+const getStartValueParams = {
+    from: (value) => arrayReduceFromKind.addTo(wrapValue.wrapValue(value), null),
+};
+function reduce(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (array) => reduce(array, getStartValue, theFunction);
+    }
+    const [array, getStartValue, theFunction] = args;
+    let lastValue = unwrap.unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    for (let index = 0; index < array.length; index++) {
+        const element = array[index];
+        const result = theFunction({
+            element,
+            index,
+            lastValue,
+            nextWithObject: ((object1, object2) => ({
+                "-next": override.override(object1, object2),
+            })),
+            exit: (output) => ({ "-exit": output }),
+            next: (output) => ({ "-next": output }),
+        });
+        if ("-exit" in result) {
+            return result["-exit"];
+        }
+        lastValue = result["-next"];
+    }
+    return lastValue;
+}
+
+exports.reduce = reduce;

package/dist/array/reduce.d.ts

@@ -0,0 +1,30 @@
+import { type Kind } from "../common/kind";
+import { type WrappedValue } from "../common/wrapValue";
+import { type Unwrap } from "../common/unwrap";
+import { type ToLargeEnsemble } from "../common";
+interface ArrayReduceNext<GenericOutput extends unknown> {
+    "-next": GenericOutput;
+}
+interface ArrayReduceExit<GenericOutput extends unknown> {
+    "-exit": GenericOutput;
+}
+type ExitOrNext<GenericOutput extends unknown = unknown> = ArrayReduceExit<GenericOutput> | ArrayReduceNext<GenericOutput>;
+export interface ArrayReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
+    element: GenericElement;
+    index: number;
+    lastValue: GenericOutput;
+    nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => ArrayReduceNext<GenericOutput> : undefined;
+    next(output: GenericOutput): ArrayReduceNext<GenericOutput>;
+    exit(output: GenericOutput): ArrayReduceExit<GenericOutput>;
+}
+declare const arrayReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"array-reduce-from", unknown>>;
+export interface ArrayReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof arrayReduceFromKind.definition>, WrappedValue<GenericValue> {
+}
+interface GetStartValueParams {
+    from<GenericValue extends unknown>(value: GenericValue): ArrayReduceFromResult<GenericValue>;
+}
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): (array: readonly GenericElement[]) => ToLargeEnsemble<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceFromResult>(getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): (array: readonly GenericElement[]) => Unwrap<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): ToLargeEnsemble<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceFromResult>(array: readonly GenericElement[], getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): Unwrap<GenericReduceFrom>;
+export {};

package/dist/array/reduce.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../common/kind.mjs';
+import { wrapValue } from '../common/wrapValue.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+import { override } from '../object/override.mjs';
+
+const arrayReduceFromKind = createKind("array-reduce-from");
+const getStartValueParams = {
+    from: (value) => arrayReduceFromKind.addTo(wrapValue(value), null),
+};
+function reduce(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (array) => reduce(array, getStartValue, theFunction);
+    }
+    const [array, getStartValue, theFunction] = args;
+    let lastValue = unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    for (let index = 0; index < array.length; index++) {
+        const element = array[index];
+        const result = theFunction({
+            element,
+            index,
+            lastValue,
+            nextWithObject: ((object1, object2) => ({
+                "-next": override(object1, object2),
+            })),
+            exit: (output) => ({ "-exit": output }),
+            next: (output) => ({ "-next": output }),
+        });
+        if ("-exit" in result) {
+            return result["-exit"];
+        }
+        lastValue = result["-next"];
+    }
+    return lastValue;
+}
+
+export { reduce };

package/dist/array/reduceRight.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var override = require('../object/override.cjs');
+
+const arrayReduceRightFromKind = kind.createKind("array-reduce-right-from");
+const getStartValueParams = {
+    from: (value) => arrayReduceRightFromKind.addTo(wrapValue.wrapValue(value), null),
+};
+function reduceRight(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (array) => reduceRight(array, getStartValue, theFunction);
+    }
+    const [array, getStartValue, theFunction] = args;
+    let lastValue = unwrap.unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    for (let index = array.length - 1; index >= 0; index--) {
+        const element = array[index];
+        const result = theFunction({
+            element,
+            index,
+            lastValue,
+            nextWithObject: ((object1, object2) => ({
+                "-next": override.override(object1, object2),
+            })),
+            exit: (output) => ({ "-exit": output }),
+            next: (output) => ({ "-next": output }),
+        });
+        if ("-exit" in result) {
+            return result["-exit"];
+        }
+        lastValue = result["-next"];
+    }
+    return lastValue;
+}
+
+exports.reduceRight = reduceRight;

package/dist/array/reduceRight.d.ts

@@ -0,0 +1,30 @@
+import { type Kind } from "../common/kind";
+import { type WrappedValue } from "../common/wrapValue";
+import { type Unwrap } from "../common/unwrap";
+import { type ToLargeEnsemble } from "../common";
+interface ArrayReduceRightNext<GenericOutput extends unknown> {
+    "-next": GenericOutput;
+}
+interface ArrayReduceRightExit<GenericOutput extends unknown> {
+    "-exit": GenericOutput;
+}
+type ExitOrNextRight<GenericOutput extends unknown = unknown> = ArrayReduceRightExit<GenericOutput> | ArrayReduceRightNext<GenericOutput>;
+export interface ArrayReduceRightFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
+    element: GenericElement;
+    index: number;
+    lastValue: GenericOutput;
+    nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => ArrayReduceRightNext<GenericOutput> : undefined;
+    next(output: GenericOutput): ArrayReduceRightNext<GenericOutput>;
+    exit(output: GenericOutput): ArrayReduceRightExit<GenericOutput>;
+}
+declare const arrayReduceRightFromKind: import("../common").KindHandler<import("../common").KindDefinition<"array-reduce-right-from", unknown>>;
+export interface ArrayReduceRightFromResult<GenericValue extends unknown = unknown> extends Kind<typeof arrayReduceRightFromKind.definition>, WrappedValue<GenericValue> {
+}
+interface GetStartValueParams {
+    from<GenericValue extends unknown>(value: GenericValue): ArrayReduceRightFromResult<GenericValue>;
+}
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(startValue: GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNextRight<ToLargeEnsemble<GenericReduceFrom>>): (array: readonly GenericElement[]) => ToLargeEnsemble<GenericReduceFrom>;
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceRightFromResult>(getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNextRight<Unwrap<GenericReduceFrom>>): (array: readonly GenericElement[]) => Unwrap<GenericReduceFrom>;
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(array: readonly GenericElement[], startValue: GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNextRight<ToLargeEnsemble<GenericReduceFrom>>): ToLargeEnsemble<GenericReduceFrom>;
+export declare function reduceRight<GenericElement extends unknown, GenericReduceFrom extends ArrayReduceRightFromResult>(array: readonly GenericElement[], getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: ArrayReduceRightFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNextRight<Unwrap<GenericReduceFrom>>): Unwrap<GenericReduceFrom>;
+export {};

package/dist/array/reduceRight.mjs

@@ -0,0 +1,39 @@
+import { createKind } from '../common/kind.mjs';
+import { wrapValue } from '../common/wrapValue.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+import { override } from '../object/override.mjs';
+
+const arrayReduceRightFromKind = createKind("array-reduce-right-from");
+const getStartValueParams = {
+    from: (value) => arrayReduceRightFromKind.addTo(wrapValue(value), null),
+};
+function reduceRight(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (array) => reduceRight(array, getStartValue, theFunction);
+    }
+    const [array, getStartValue, theFunction] = args;
+    let lastValue = unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    for (let index = array.length - 1; index >= 0; index--) {
+        const element = array[index];
+        const result = theFunction({
+            element,
+            index,
+            lastValue,
+            nextWithObject: ((object1, object2) => ({
+                "-next": override(object1, object2),
+            })),
+            exit: (output) => ({ "-exit": output }),
+            next: (output) => ({ "-next": output }),
+        });
+        if ("-exit" in result) {
+            return result["-exit"];
+        }
+        lastValue = result["-next"];
+    }
+    return lastValue;
+}
+
+export { reduceRight };

package/dist/array/reverse.cjs

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

package/dist/array/reverse.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../common/types/anyTuple";
+import { type ReverseTuple } from "../array";
+export declare function reverse<GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends AnyTuple ? ReverseTuple<GenericArray> : GenericArray;

package/dist/array/reverse.mjs

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

package/dist/array/set.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function set(...args) {
+    if (args.length === 2) {
+        const [index, value] = args;
+        return (array) => set(array, index, value);
+    }
+    const [array, index, value] = args;
+    const length = array.length;
+    const modIndex = ((index % length) + length) % length;
+    return array.with(modIndex, value);
+}
+
+exports.set = set;

package/dist/array/set.d.ts

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

package/dist/array/set.mjs

@@ -0,0 +1,12 @@
+function set(...args) {
+    if (args.length === 2) {
+        const [index, value] = args;
+        return (array) => set(array, index, value);
+    }
+    const [array, index, value] = args;
+    const length = array.length;
+    const modIndex = ((index % length) + length) % length;
+    return array.with(modIndex, value);
+}
+
+export { set };

package/dist/array/shift.cjs

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

package/dist/array/shift.d.ts

@@ -0,0 +1,3 @@
+import { type AnyTuple } from "../common";
+import { type ShiftTuple } from "../array/types/shiftTuple";
+export declare function shift<const GenericArray extends readonly unknown[]>(array: GenericArray): GenericArray extends AnyTuple ? ShiftTuple<GenericArray> : GenericArray;

package/dist/array/shift.mjs

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

package/dist/array/slice.cjs

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

package/dist/array/slice.d.ts

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

package/dist/array/slice.mjs

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

package/dist/array/some.cjs

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

package/dist/array/some.d.ts

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

package/dist/array/some.mjs

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

package/dist/array/sort/default.cjs

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

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

@@ -0,0 +1,2 @@
+export declare function sort<GenericElement extends unknown>(compareFn: (first: GenericElement, second: GenericElement) => number): (array: readonly GenericElement[]) => GenericElement[];
+export declare function sort<GenericElement extends unknown>(array: readonly GenericElement[], compareFn: (first: GenericElement, second: GenericElement) => number): GenericElement[];

package/dist/array/sort/default.mjs

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

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

@@ -0,0 +1,3 @@
+export * from "./default";
+export * from "./number";
+export * from "./string";

package/dist/array/sort/number.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+function sortNumber(...args) {
+    if (args.length === 1) {
+        const [sort] = args;
+        return (array) => sortNumber(array, sort);
+    }
+    const [array, sort] = args;
+    return [...array].sort(sort === "dsc"
+        ? (first, second) => second - first
+        : (first, second) => first - second);
+}
+
+exports.sortNumber = sortNumber;

package/dist/array/sort/number.d.ts

@@ -0,0 +1,4 @@
+type Sort = "asc" | "dsc";
+export declare function sortNumber<GenericArray extends readonly number[]>(sort: Sort): (array: GenericArray) => number[];
+export declare function sortNumber<GenericArray extends readonly number[]>(array: GenericArray, sort: Sort): number[];
+export {};

package/dist/array/sort/number.mjs

@@ -0,0 +1,12 @@
+function sortNumber(...args) {
+    if (args.length === 1) {
+        const [sort] = args;
+        return (array) => sortNumber(array, sort);
+    }
+    const [array, sort] = args;
+    return [...array].sort(sort === "dsc"
+        ? (first, second) => second - first
+        : (first, second) => first - second);
+}
+
+export { sortNumber };

package/dist/array/sort/string.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+function sortString(...args) {
+    if (args.length === 1) {
+        const [sort] = args;
+        return (array) => sortString(array, sort);
+    }
+    const [array, sort] = args;
+    return [...array].sort(sort === "dsc"
+        ? (first, second) => {
+            if (first < second) {
+                return 1;
+            }
+            else if (first > second) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        }
+        : undefined);
+}
+
+exports.sortString = sortString;

package/dist/array/sort/string.d.ts

@@ -0,0 +1,4 @@
+type Sort = "asc" | "dsc";
+export declare function sortString<GenericArray extends readonly string[]>(sort: Sort): (array: GenericArray) => string[];
+export declare function sortString<GenericArray extends readonly string[]>(array: GenericArray, sort: Sort): string[];
+export {};

package/dist/array/sort/string.mjs

@@ -0,0 +1,22 @@
+function sortString(...args) {
+    if (args.length === 1) {
+        const [sort] = args;
+        return (array) => sortString(array, sort);
+    }
+    const [array, sort] = args;
+    return [...array].sort(sort === "dsc"
+        ? (first, second) => {
+            if (first < second) {
+                return 1;
+            }
+            else if (first > second) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        }
+        : undefined);
+}
+
+export { sortString };