@duplojs/utils 0.3.1 → 1.0.1

package/dist/string/lastIndexOf.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function lastIndexOf(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => lastIndexOf(input, searchString);
+    }
+    const [input, searchString, position] = args;
+    const result = input.lastIndexOf(searchString, position);
+    return result === -1 ? undefined : result;
+}
+
+exports.lastIndexOf = lastIndexOf;

package/dist/string/lastIndexOf.d.ts

@@ -0,0 +1,2 @@
+export declare function lastIndexOf<GenericInput extends string>(searchString: string): (input: GenericInput) => number | undefined;
+export declare function lastIndexOf<GenericInput extends string>(input: GenericInput, searchString: string, position?: number): number | undefined;

package/dist/string/lastIndexOf.mjs

@@ -0,0 +1,11 @@
+function lastIndexOf(...args) {
+    if (args.length === 1) {
+        const [searchString] = args;
+        return (input) => lastIndexOf(input, searchString);
+    }
+    const [input, searchString, position] = args;
+    const result = input.lastIndexOf(searchString, position);
+    return result === -1 ? undefined : result;
+}
+
+export { lastIndexOf };

package/dist/string/match.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function match(...args) {
+    if (args.length === 1) {
+        const [pattern] = args;
+        return (input) => match(input, pattern);
+    }
+    const [input, pattern] = args;
+    const result = input.match(pattern);
+    return result ? result : undefined;
+}
+
+exports.match = match;

package/dist/string/match.d.ts

@@ -0,0 +1,2 @@
+export declare function match<GenericInput extends string>(pattern: string | RegExp): (input: GenericInput) => RegExpMatchArray | undefined;
+export declare function match<GenericInput extends string>(input: GenericInput, pattern: string | RegExp): RegExpMatchArray | undefined;

package/dist/string/match.mjs

@@ -0,0 +1,11 @@
+function match(...args) {
+    if (args.length === 1) {
+        const [pattern] = args;
+        return (input) => match(input, pattern);
+    }
+    const [input, pattern] = args;
+    const result = input.match(pattern);
+    return result ? result : undefined;
+}
+
+export { match };

package/dist/string/matchAll.cjs

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

package/dist/string/matchAll.d.ts

@@ -0,0 +1,2 @@
+export declare function matchAll<GenericInput extends string>(pattern: RegExp): (input: GenericInput) => RegExpStringIterator<RegExpMatchArray>;
+export declare function matchAll<GenericInput extends string>(input: GenericInput, pattern: RegExp): RegExpStringIterator<RegExpMatchArray>;

package/dist/string/matchAll.mjs

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

package/dist/string/normalize.cjs

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

package/dist/string/normalize.d.ts

@@ -0,0 +1,3 @@
+import { type NormalizeForm } from "./types/normalizeForm";
+export declare function normalize<GenericInput extends string>(form: NormalizeForm): (input: GenericInput) => string;
+export declare function normalize<GenericInput extends string>(input: GenericInput, form: NormalizeForm): string;

package/dist/string/normalize.mjs

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

package/dist/string/padEnd.cjs

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

package/dist/string/padEnd.d.ts

@@ -0,0 +1,2 @@
+export declare function padEnd<GenericInput extends string>(targetLength: number, padString: string): (input: GenericInput) => string;
+export declare function padEnd<GenericInput extends string>(input: GenericInput, targetLength: number, padString: string): string;

package/dist/string/padEnd.mjs

@@ -0,0 +1,10 @@
+function padEnd(...args) {
+    if (args.length === 2) {
+        const [targetLength, padString] = args;
+        return (input) => padEnd(input, targetLength, padString);
+    }
+    const [input, targetLength, padString] = args;
+    return input.padEnd(targetLength, padString);
+}
+
+export { padEnd };

package/dist/string/padStart.cjs

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

package/dist/string/padStart.d.ts

@@ -0,0 +1,2 @@
+export declare function padStart<GenericInput extends string>(targetLength: number, padString: string): (input: GenericInput) => string;
+export declare function padStart<GenericInput extends string>(input: GenericInput, targetLength: number, padString: string): string;

package/dist/string/padStart.mjs

@@ -0,0 +1,10 @@
+function padStart(...args) {
+    if (args.length === 2) {
+        const [targetLength, padString] = args;
+        return (input) => padStart(input, targetLength, padString);
+    }
+    const [input, targetLength, padString] = args;
+    return input.padStart(targetLength, padString);
+}
+
+export { padStart };

package/dist/string/repeat.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function repeat(...args) {
+    if (args.length === 1) {
+        const [count] = args;
+        return (input) => repeat(input, count);
+    }
+    const [input, count] = args;
+    if (count < 0 || !Number.isFinite(count)) {
+        return "";
+    }
+    return input.repeat(count);
+}
+
+exports.repeat = repeat;

package/dist/string/repeat.d.ts

@@ -0,0 +1,2 @@
+export declare function repeat<GenericInput extends string>(count: number): (input: GenericInput) => string;
+export declare function repeat<GenericInput extends string>(input: GenericInput, count: number): string;

package/dist/string/repeat.mjs

@@ -0,0 +1,13 @@
+function repeat(...args) {
+    if (args.length === 1) {
+        const [count] = args;
+        return (input) => repeat(input, count);
+    }
+    const [input, count] = args;
+    if (count < 0 || !Number.isFinite(count)) {
+        return "";
+    }
+    return input.repeat(count);
+}
+
+export { repeat };

package/dist/string/replace.cjs

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

package/dist/string/replace.d.ts

@@ -0,0 +1,2 @@
+export declare function replace<GenericInput extends string>(pattern: string | RegExp, replacement: string): (input: GenericInput) => string;
+export declare function replace<GenericInput extends string>(input: GenericInput, pattern: string | RegExp, replacement: string): string;

package/dist/string/replace.mjs

@@ -0,0 +1,10 @@
+function replace(...args) {
+    if (args.length === 2) {
+        const [pattern, replacement] = args;
+        return (input) => replace(input, pattern, replacement);
+    }
+    const [input, pattern, replacement] = args;
+    return input.replace(pattern, replacement);
+}
+
+export { replace };

package/dist/string/replaceAll.cjs

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

package/dist/string/replaceAll.d.ts

@@ -0,0 +1,2 @@
+export declare function replaceAll<GenericInput extends string>(pattern: string | RegExp, replacement: string): (input: GenericInput) => string;
+export declare function replaceAll(input: string, pattern: string | RegExp, replacement: string): string;

package/dist/string/replaceAll.mjs

@@ -0,0 +1,10 @@
+function replaceAll(...args) {
+    if (args.length === 2) {
+        const [pattern, replacement] = args;
+        return (input) => replaceAll(input, pattern, replacement);
+    }
+    const [input, pattern, replacement] = args;
+    return input.replaceAll(pattern, replacement);
+}
+
+export { replaceAll };

package/dist/string/search.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+function search(...args) {
+    if (args.length === 1) {
+        const [pattern] = args;
+        return (input) => search(input, pattern);
+    }
+    const [input, pattern] = args;
+    const result = input.search(pattern);
+    return result === -1 ? undefined : result;
+}
+
+exports.search = search;

package/dist/string/search.d.ts

@@ -0,0 +1,2 @@
+export declare function search<GenericInput extends string>(pattern: string | RegExp): (input: GenericInput) => number | undefined;
+export declare function search<GenericInput extends string>(input: GenericInput, pattern: string | RegExp): number | undefined;

package/dist/string/search.mjs

@@ -0,0 +1,11 @@
+function search(...args) {
+    if (args.length === 1) {
+        const [pattern] = args;
+        return (input) => search(input, pattern);
+    }
+    const [input, pattern] = args;
+    const result = input.search(pattern);
+    return result === -1 ? undefined : result;
+}
+
+export { search };

package/dist/string/slice.cjs

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

package/dist/string/slice.d.ts

@@ -0,0 +1,2 @@
+export declare function slice<GenericInput extends string>(start: number, end: number): (input: GenericInput) => string;
+export declare function slice<GenericInput extends string>(input: GenericInput, start: number, end: number): string;

package/dist/string/slice.mjs

@@ -0,0 +1,10 @@
+function slice(...args) {
+    if (args.length === 2) {
+        const [start, end] = args;
+        return (input) => slice(input, start, end);
+    }
+    const [input, start, end] = args;
+    return input.slice(start, end);
+}
+
+export { slice };

package/dist/string/split.cjs

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

package/dist/string/split.d.ts

@@ -0,0 +1,7 @@
+import type { Split } from "./types/split";
+interface StringSplitParams<GenericLimit extends number> {
+    limit: GenericLimit;
+}
+export declare function split<GenericString extends string, GenericSeparator extends string>(separator: GenericSeparator | RegExp): (input: GenericString) => Split<GenericString, GenericSeparator>;
+export declare function split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number>(input: GenericString, separator: GenericSeparator | RegExp, params?: StringSplitParams<GenericLimit>): Split<GenericString, GenericSeparator, GenericLimit>;
+export {};

package/dist/string/split.mjs

@@ -0,0 +1,10 @@
+function split(...args) {
+    if (args.length === 1) {
+        const [separator] = args;
+        return (input) => split(input, separator);
+    }
+    const [input, separator, params] = args;
+    return input.split(separator, params?.limit);
+}
+
+export { split };

package/dist/string/startsWith.cjs

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

package/dist/string/startsWith.d.ts

@@ -0,0 +1,2 @@
+export declare function startsWith<GenericSearchString extends string, GenericString extends string>(searchString: GenericSearchString): (input: GenericString) => input is Extract<GenericString, `${GenericSearchString}${string}`>;
+export declare function startsWith<GenericString extends string, GenericSearchString extends string>(input: GenericString, searchString: GenericSearchString): input is Extract<GenericString, `${GenericSearchString}${string}`>;

package/dist/string/startsWith.mjs

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

package/dist/string/substring.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function substring(...args) {
+    if (typeof args[0] === "number") {
+        const [start, end] = args;
+        return (input) => substring(input, start, end);
+    }
+    const [input, start, end] = args;
+    return input.substring(start, end);
+}
+
+exports.substring = substring;

package/dist/string/substring.d.ts

@@ -0,0 +1,2 @@
+export declare function substring<GenericInput extends string>(start: number, end?: number): (input: GenericInput) => string;
+export declare function substring<GenericInput extends string>(input: GenericInput, start: number, end?: number): string;

package/dist/string/substring.mjs

@@ -0,0 +1,10 @@
+function substring(...args) {
+    if (typeof args[0] === "number") {
+        const [start, end] = args;
+        return (input) => substring(input, start, end);
+    }
+    const [input, start, end] = args;
+    return input.substring(start, end);
+}
+
+export { substring };

package/dist/string/test.cjs

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

package/dist/string/test.d.ts

@@ -0,0 +1,2 @@
+export declare function test<GenericInput extends string>(regExp: RegExp): (input: GenericInput) => boolean;
+export declare function test<GenericInput extends string>(input: GenericInput, regExp: RegExp): boolean;

package/dist/string/test.mjs

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

package/dist/string/toLowerCase.cjs

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

package/dist/string/toLowerCase.d.ts

@@ -0,0 +1 @@
+export declare function toLowerCase<GenericString extends string>(input: GenericString): Lowercase<GenericString>;

package/dist/string/toLowerCase.mjs

@@ -0,0 +1,5 @@
+function toLowerCase(input) {
+    return input.toLowerCase();
+}
+
+export { toLowerCase };

package/dist/string/toUpperCase.cjs

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

package/dist/string/toUpperCase.d.ts

@@ -0,0 +1 @@
+export declare function toUpperCase<GenericString extends string>(input: GenericString): Uppercase<GenericString>;

package/dist/string/toUpperCase.mjs

@@ -0,0 +1,5 @@
+function toUpperCase(input) {
+    return input.toUpperCase();
+}
+
+export { toUpperCase };

package/dist/string/trim/default.cjs

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

package/dist/string/trim/default.d.ts

@@ -0,0 +1 @@
+export declare function trim<GenericInput extends string>(input: GenericInput): string;

package/dist/string/trim/default.mjs

@@ -0,0 +1,5 @@
+function trim(input) {
+    return input.trim();
+}
+
+export { trim };

package/dist/string/trim/end.cjs

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

package/dist/string/trim/end.d.ts

@@ -0,0 +1 @@
+export declare function trimEnd<GenericInput extends string>(input: GenericInput): string;

package/dist/string/trim/end.mjs

@@ -0,0 +1,5 @@
+function trimEnd(input) {
+    return input.trimEnd();
+}
+
+export { trimEnd };

package/dist/string/trim/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./default";
+export * from "./end";
+export * from "./start";

package/dist/string/trim/start.cjs

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

package/dist/string/trim/start.d.ts

@@ -0,0 +1 @@
+export declare function trimStart<GenericInput extends string>(input: GenericInput): string;

package/dist/string/trim/start.mjs

@@ -0,0 +1,5 @@
+function trimStart(input) {
+    return input.trimStart();
+}
+
+export { trimStart };

package/dist/string/types/endsWith.d.ts

@@ -0,0 +1 @@
+export type EndsWith<GenericString extends string, GenericSearchString extends string> = GenericString extends `${string}${GenericSearchString}` ? true : false;

package/dist/string/types/first.d.ts

@@ -0,0 +1,2 @@
+import { type IsEqual } from "../../common";
+export type First<GenericValue extends string> = IsEqual<GenericValue, ""> extends true ? undefined : GenericValue extends `${infer InferredFirst}${string}` ? InferredFirst : string | undefined;

package/dist/string/types/includes.d.ts

@@ -0,0 +1 @@
+export type Includes<GenericString extends string, GenericSearchString extends string> = GenericString extends `${string}${GenericSearchString}${string}` ? true : false;

package/dist/string/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./last";
+export * from "./first";
+export * from "./includes";
+export * from "./endsWith";
+export * from "./startsWith";
+export * from "./normalizeForm";
+export * from "./split";

package/dist/string/types/last.d.ts

@@ -0,0 +1,2 @@
+import { type IsEqual } from "../../common";
+export type Last<GenericValue extends string> = IsEqual<GenericValue, ""> extends true ? undefined : GenericValue extends `${string}${infer InferredLeft}${infer InferredRight}` ? IsEqual<InferredRight, ""> extends true ? InferredLeft : Last<`${InferredLeft}${InferredRight}`> : string | undefined;

package/dist/string/types/normalizeForm.d.ts

@@ -0,0 +1 @@
+export type NormalizeForm = "NFC" | "NFD" | "NFKC" | "NFKD";

package/dist/string/types/split.d.ts

@@ -0,0 +1,6 @@
+import { type Or, type IsEqual } from "../../common";
+import { type Includes } from "./includes";
+export type Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends string[] = []> = Or<[
+    IsEqual<GenericString, string>,
+    IsEqual<GenericSeparator, string>
+]> extends true ? string[] : GenericString extends `${infer InferredBefore}${GenericSeparator}${infer InferredAfter}` ? [...GenericLastResult, InferredBefore] extends infer InferredResult extends any[] ? IsEqual<InferredAfter, ""> extends true ? InferredResult : IsEqual<InferredResult["length"], 250> extends true ? Includes<InferredAfter, GenericSeparator> extends true ? [...InferredResult, ...string[]] : InferredResult : IsEqual<InferredResult["length"], GenericLimit> extends true ? InferredResult : Split<InferredAfter, GenericSeparator, GenericLimit, InferredResult> : never : [...GenericLastResult, GenericString];

package/dist/string/types/startsWith.d.ts

@@ -0,0 +1 @@
+export type StartsWith<GenericString extends string, GenericSearchString extends string> = GenericString extends `${GenericSearchString}${string}` ? true : false;

package/dist/string/uncapitalize.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function uncapitalize(input) {
+    return (input.charAt(0).toLowerCase() + input.slice(1));
+}
+
+exports.uncapitalize = uncapitalize;

package/dist/string/uncapitalize.d.ts

@@ -0,0 +1 @@
+export declare function uncapitalize<GenericString extends string>(input: GenericString): Uncapitalize<GenericString>;

package/dist/string/uncapitalize.mjs

@@ -0,0 +1,5 @@
+function uncapitalize(input) {
+    return (input.charAt(0).toLowerCase() + input.slice(1));
+}
+
+export { uncapitalize };