@duplojs/utils 0.3.0 → 1.0.0

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

@@ -0,0 +1,2 @@
+import { type First } from "../types";
+export declare function first<GenericString extends string>(input: GenericString): First<GenericString>;

package/dist/string/at/first.mjs

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

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

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

package/dist/string/at/last.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+function last(string) {
+    return string.length > 0
+        ? string[string.length - 1]
+        : undefined;
+}
+
+exports.last = last;

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

@@ -0,0 +1,2 @@
+import { type Last } from "../types";
+export declare function last<GenericValue extends string>(string: GenericValue): Last<GenericValue>;

package/dist/string/at/last.mjs

@@ -0,0 +1,7 @@
+function last(string) {
+    return string.length > 0
+        ? string[string.length - 1]
+        : undefined;
+}
+
+export { last };

package/dist/string/capitalize.cjs

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

package/dist/string/capitalize.d.ts

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

package/dist/string/capitalize.mjs

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

package/dist/string/charAt.cjs

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

package/dist/string/charAt.d.ts

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

package/dist/string/charAt.mjs

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

package/dist/string/concat.cjs

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

package/dist/string/concat.d.ts

@@ -0,0 +1,2 @@
+export declare function concat<GenericInput extends string>(text: string): (input: GenericInput) => string;
+export declare function concat(input: string, ...textsRest: string[]): string;

package/dist/string/concat.mjs

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

package/dist/string/endsWith.cjs

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

package/dist/string/endsWith.d.ts

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

package/dist/string/endsWith.mjs

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

package/dist/string/includes.cjs

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

package/dist/string/includes.d.ts

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

package/dist/string/includes.mjs

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

package/dist/string/index.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+var isKeyof = require('./isKeyof.cjs');
+var _default = require('./at/default.cjs');
+var first = require('./at/first.cjs');
+var last = require('./at/last.cjs');
+var split = require('./split.cjs');
+var charAt = require('./charAt.cjs');
+var toUpperCase = require('./toUpperCase.cjs');
+var toLowerCase = require('./toLowerCase.cjs');
+var _default$1 = require('./trim/default.cjs');
+var end = require('./trim/end.cjs');
+var start = require('./trim/start.cjs');
+var capitalize = require('./capitalize.cjs');
+var uncapitalize = require('./uncapitalize.cjs');
+var substring = require('./substring.cjs');
+var startsWith = require('./startsWith.cjs');
+var endsWith = require('./endsWith.cjs');
+var includes = require('./includes.cjs');
+var search = require('./search.cjs');
+var replace = require('./replace.cjs');
+var replaceAll = require('./replaceAll.cjs');
+var match = require('./match.cjs');
+var matchAll = require('./matchAll.cjs');
+var concat = require('./concat.cjs');
+var slice = require('./slice.cjs');
+var padStart = require('./padStart.cjs');
+var padEnd = require('./padEnd.cjs');
+var indexOf = require('./indexOf.cjs');
+var lastIndexOf = require('./lastIndexOf.cjs');
+var repeat = require('./repeat.cjs');
+var normalize = require('./normalize.cjs');
+var test = require('./test.cjs');
+
+
+
+exports.isKeyof = isKeyof.isKeyof;
+exports.at = _default.at;
+exports.first = first.first;
+exports.last = last.last;
+exports.split = split.split;
+exports.charAt = charAt.charAt;
+exports.toUpperCase = toUpperCase.toUpperCase;
+exports.toLowerCase = toLowerCase.toLowerCase;
+exports.trim = _default$1.trim;
+exports.trimEnd = end.trimEnd;
+exports.trimStart = start.trimStart;
+exports.capitalize = capitalize.capitalize;
+exports.uncapitalize = uncapitalize.uncapitalize;
+exports.substring = substring.substring;
+exports.startsWith = startsWith.startsWith;
+exports.endsWith = endsWith.endsWith;
+exports.includes = includes.includes;
+exports.search = search.search;
+exports.replace = replace.replace;
+exports.replaceAll = replaceAll.replaceAll;
+exports.match = match.match;
+exports.matchAll = matchAll.matchAll;
+exports.concat = concat.concat;
+exports.slice = slice.slice;
+exports.padStart = padStart.padStart;
+exports.padEnd = padEnd.padEnd;
+exports.indexOf = indexOf.indexOf;
+exports.lastIndexOf = lastIndexOf.lastIndexOf;
+exports.repeat = repeat.repeat;
+exports.normalize = normalize.normalize;
+exports.test = test.test;

package/dist/string/index.d.ts

@@ -0,0 +1,28 @@
+export * from "./types";
+export * from "./isKeyof";
+export * from "./at";
+export * from "./split";
+export * from "./charAt";
+export * from "./toUpperCase";
+export * from "./toLowerCase";
+export * from "./trim";
+export * from "./capitalize";
+export * from "./uncapitalize";
+export * from "./substring";
+export * from "./startsWith";
+export * from "./endsWith";
+export * from "./includes";
+export * from "./search";
+export * from "./replace";
+export * from "./replaceAll";
+export * from "./match";
+export * from "./matchAll";
+export * from "./concat";
+export * from "./slice";
+export * from "./padStart";
+export * from "./padEnd";
+export * from "./indexOf";
+export * from "./lastIndexOf";
+export * from "./repeat";
+export * from "./normalize";
+export * from "./test";

package/dist/string/index.mjs

@@ -0,0 +1,31 @@
+export { isKeyof } from './isKeyof.mjs';
+export { at } from './at/default.mjs';
+export { first } from './at/first.mjs';
+export { last } from './at/last.mjs';
+export { split } from './split.mjs';
+export { charAt } from './charAt.mjs';
+export { toUpperCase } from './toUpperCase.mjs';
+export { toLowerCase } from './toLowerCase.mjs';
+export { trim } from './trim/default.mjs';
+export { trimEnd } from './trim/end.mjs';
+export { trimStart } from './trim/start.mjs';
+export { capitalize } from './capitalize.mjs';
+export { uncapitalize } from './uncapitalize.mjs';
+export { substring } from './substring.mjs';
+export { startsWith } from './startsWith.mjs';
+export { endsWith } from './endsWith.mjs';
+export { includes } from './includes.mjs';
+export { search } from './search.mjs';
+export { replace } from './replace.mjs';
+export { replaceAll } from './replaceAll.mjs';
+export { match } from './match.mjs';
+export { matchAll } from './matchAll.mjs';
+export { concat } from './concat.mjs';
+export { slice } from './slice.mjs';
+export { padStart } from './padStart.mjs';
+export { padEnd } from './padEnd.mjs';
+export { indexOf } from './indexOf.mjs';
+export { lastIndexOf } from './lastIndexOf.mjs';
+export { repeat } from './repeat.mjs';
+export { normalize } from './normalize.mjs';
+export { test } from './test.mjs';

package/dist/string/indexOf.cjs

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

package/dist/string/indexOf.d.ts

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

package/dist/string/indexOf.mjs

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

package/dist/string/isKeyof.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function isKeyof(...args) {
+    if (args.length === 1) {
+        const [obj] = args;
+        return (key) => isKeyof(key, obj);
+    }
+    const [key, obj] = args;
+    return obj[key] !== undefined;
+}
+
+exports.isKeyof = isKeyof;

package/dist/string/isKeyof.d.ts

@@ -0,0 +1,3 @@
+import { type ObjectKey } from "../common/types/objectKey";
+export declare function isKeyof<GenericObject extends object, GenericKey extends ObjectKey>(obj: GenericObject): (key: GenericKey) => key is keyof GenericObject & GenericKey;
+export declare function isKeyof<GenericObject extends object, GenericKey extends ObjectKey>(key: GenericKey, obj: GenericObject): key is keyof GenericObject & GenericKey;

package/dist/string/isKeyof.mjs

@@ -0,0 +1,10 @@
+function isKeyof(...args) {
+    if (args.length === 1) {
+        const [obj] = args;
+        return (key) => isKeyof(key, obj);
+    }
+    const [key, obj] = args;
+    return obj[key] !== undefined;
+}
+
+export { isKeyof };

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;