@augment-vir/common 29.2.0 → 30.0.0

package/dist/augments/prisma/prisma-models.d.ts

@@ -0,0 +1,106 @@
+import type { AnyFunction, AnyObject } from '@augment-vir/core';
+/**
+ * Extracts all model names from a generated `Prisma` object.
+ *
+ * @example
+ *
+ * ```ts
+ * import type {Prisma} from '@prisma/client';
+ *
+ * function doThing(modelName: ModelNameFromPrismaTypeMap<Prisma.TypeMap>) {}
+ * ```
+ */
+export type ModelNameFromPrismaTypeMap<PrismaTypeMap extends BasePrismaTypeMap> = PrismaTypeMap['meta']['modelProps'];
+/**
+ * Extracts all model names from a generated `PrismaClient`.
+ *
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ *
+ * function doThing(modelName: ModelNameFromPrismaClient<PrismaClient>) {}
+ * ```
+ */
+export type ModelNameFromPrismaClient<PrismaClient extends AnyObject> = keyof {
+    [Model in Extract<keyof PrismaClient, string> as PrismaClient[Model] extends {
+        findFirst: AnyFunction;
+    } ? Model : never]: boolean;
+};
+/**
+ * Extracts the creation data for a model from the given `PrismaClient` type.
+ *
+ * @example
+ *
+ * ```ts
+ * import type {PrismaClient} from '@prisma/client';
+ *
+ * function doThing(entry: ModelCreationEntry<PrismaClient, 'User'>) {}
+ * ```
+ */
+export type PrismaModelCreationEntry<PrismaClient extends AnyObject, Model extends ModelNameFromPrismaClient<PrismaClient>> = NonNullable<Parameters<PrismaClient[Model]['create']>[0]> extends {
+    data?: infer Data;
+} ? NonNullable<Data> : `ERROR: failed to infer creation entry for model '${Model}'`;
+/**
+ * A base type for `Prisma.TypeMap` because Prisma doesn't give us one. This currently only includes
+ * the properties that are used within `@augment-vir/prisma-node-js`.
+ */
+export type BasePrismaTypeMap = {
+    meta: {
+        modelProps: string;
+    };
+    model: Record<string, {
+        payload: BasePrismaPayload;
+    }>;
+};
+/**
+ * A base type for Prisma model payloads because Prisma doesn't give us one. This currently only
+ * includes the properties that are used within this package.
+ *
+ * Note: this omits the `composites` property because I don't have any examples of what those
+ * actually are.
+ */
+export type BasePrismaPayload = {
+    name: string;
+    objects: Record<string, BasePrismaPayload | BasePrismaPayload[] | null>;
+    scalars: AnyObject;
+};
+/**
+ * A full model entry with all relations from the given Prisma type map and model name.
+ *
+ * @example
+ *
+ * ```ts
+ * import type {Prisma} from '@prisma/client';
+ *
+ * function doThing(fullModel: FullModel<Prisma.TypeMap, 'User'>) {}
+ * ```
+ */
+export type FullPrismaModel<PrismaTypeMap extends BasePrismaTypeMap, Model extends ModelNameFromPrismaTypeMap<PrismaTypeMap>> = ExpandPrismaTypeMapPayload<PrismaTypeMap['model'][Model]['payload']>;
+/**
+ * A base model entry with only its immediate properties from the given Prisma type map and model
+ * name.
+ *
+ * @example
+ *
+ * ```ts
+ * import type {Prisma} from '@prisma/client';
+ *
+ * function doThing(fullModel: BaseModel<Prisma.TypeMap, 'User'>) {}
+ * ```
+ */
+export type BasePrismaModel<PrismaTypeMap extends BasePrismaTypeMap, Model extends ModelNameFromPrismaTypeMap<PrismaTypeMap>> = PrismaTypeMap['model'][Model]['payload']['scalars'];
+/**
+ * Expand a Prisma payload into its scalars and recursive relations.
+ *
+ * @category Internals
+ */
+export type ExpandPrismaTypeMapPayload<Payload extends BasePrismaPayload> = Payload['scalars'] & {
+    [Key in keyof Payload['objects']]: ExpandPotentialArrayPrismaTypeMapPayload<NonNullable<Payload['objects'][Key]>> | (null extends Payload['objects'][Key] ? null : never);
+};
+/**
+ * Expand a payload that might be inside of an array, keeping it inside of an array if it is.
+ *
+ * @category Internals
+ */
+export type ExpandPotentialArrayPrismaTypeMapPayload<PayloadWrapper extends BasePrismaPayload | BasePrismaPayload[]> = PayloadWrapper extends (infer ActualPayload extends BasePrismaPayload)[] ? ExpandPrismaTypeMapPayload<ActualPayload>[] : PayloadWrapper extends BasePrismaPayload ? ExpandPrismaTypeMapPayload<PayloadWrapper> : never;

package/dist/augments/prisma/prisma-models.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/promise/timed-promise.d.ts

@@ -0,0 +1,7 @@
+import { AnyDuration } from '@date-vir/duration';
+export declare class PromiseTimeoutError extends Error {
+    readonly duration: AnyDuration;
+    readonly name = "PromiseTimeoutError";
+    constructor(duration: AnyDuration, failureMessage?: string | undefined);
+}
+export declare function wrapPromiseInTimeout<T>(duration: Readonly<AnyDuration>, originalPromise: PromiseLike<T>, failureMessage?: string | undefined): Promise<T>;

package/dist/augments/promise/timed-promise.js

@@ -0,0 +1,36 @@
+import { check } from '@augment-vir/assert';
+import { ensureError } from '@augment-vir/core';
+import { convertDuration, DurationUnit } from '@date-vir/duration';
+export class PromiseTimeoutError extends Error {
+    duration;
+    name = 'PromiseTimeoutError';
+    constructor(duration, failureMessage) {
+        super([
+            failureMessage,
+            `Promised timed out after ${convertDuration(duration, DurationUnit.Milliseconds).milliseconds} ms.`,
+        ]
+            .filter(check.isTruthy)
+            .join(': '));
+        this.duration = duration;
+    }
+}
+export function wrapPromiseInTimeout(duration, originalPromise, failureMessage) {
+    const milliseconds = convertDuration(duration, DurationUnit.Milliseconds).milliseconds;
+    return new Promise(async (resolve, reject) => {
+        const timeoutId = milliseconds === Infinity
+            ? undefined
+            : setTimeout(() => {
+                reject(new PromiseTimeoutError(duration, failureMessage));
+            }, milliseconds);
+        try {
+            const result = await originalPromise;
+            resolve(result);
+        }
+        catch (error) {
+            reject(ensureError(error));
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    });
+}

package/dist/augments/random/random-boolean.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns true at rate of the percentLikelyToBeTrue input. Inputs should be whole numbers which
+ * will be treated like percents. Anything outside of 0-100 inclusively will be clamped. An input 0
+ * will always return true. An input of 100 will always return true. Decimals on the input will be
+ * chopped off, use whole numbers.
+ *
+ * This function uses cryptographically secure randomness.
+ *
+ * @example
+ *
+ * ```ts
+ * randomBoolean(50); // 50% chance to return true
+ * randomBoolean(0); // always false, 0% chance of being true
+ * randomBoolean(100); // always true, 100% chance of being true
+ * randomBoolean(59.67); // 59% chance of being true
+ * ```
+ */
+export declare function randomBoolean(percentLikelyToBeTrue?: number): boolean;

package/dist/augments/random/random-boolean.js

@@ -0,0 +1,26 @@
+import { clamp } from '../number/clamp.js';
+import { randomInteger } from './random-integer.js';
+/**
+ * Returns true at rate of the percentLikelyToBeTrue input. Inputs should be whole numbers which
+ * will be treated like percents. Anything outside of 0-100 inclusively will be clamped. An input 0
+ * will always return true. An input of 100 will always return true. Decimals on the input will be
+ * chopped off, use whole numbers.
+ *
+ * This function uses cryptographically secure randomness.
+ *
+ * @example
+ *
+ * ```ts
+ * randomBoolean(50); // 50% chance to return true
+ * randomBoolean(0); // always false, 0% chance of being true
+ * randomBoolean(100); // always true, 100% chance of being true
+ * randomBoolean(59.67); // 59% chance of being true
+ * ```
+ */
+export function randomBoolean(percentLikelyToBeTrue = 50) {
+    return (randomInteger({ min: 0, max: 99 }) <
+        clamp(Math.floor(percentLikelyToBeTrue), {
+            min: 0,
+            max: 100,
+        }));
+}

package/dist/augments/random/random-integer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a random integer (no decimal points are included) between the given min and max values
+ * (inclusive).
+ *
+ * This function uses cryptographically secure randomness.
+ *
+ * @category Random:Common
+ */
+export declare function randomInteger({ min: rawMin, max: rawMax }: {
+    min: number;
+    max: number;
+}): number;

package/dist/augments/random/random-integer.js

@@ -0,0 +1,32 @@
+import { ensureMinMax } from '../number/min-max.js';
+/**
+ * Creates a random integer (no decimal points are included) between the given min and max values
+ * (inclusive).
+ *
+ * This function uses cryptographically secure randomness.
+ *
+ * @category Random:Common
+ */
+export function randomInteger({ min: rawMin, max: rawMax }) {
+    const { min, max } = ensureMinMax({ min: Math.floor(rawMin), max: Math.floor(rawMax) });
+    const range = max - min + 1;
+    const bitsNeeded = Math.ceil(Math.log2(range));
+    const neededBytes = Math.ceil(bitsNeeded / 8);
+    /**
+     * Testing on my system maxes out at 65,536 (Node) or 65,537 (Safari / Chrome / Firefox) bytes.
+     * I don't know why, and that may be system dependent, I don't know.
+     */
+    if (neededBytes > 65_000) {
+        throw new RangeError(`Cannot create a random integer so large. ({min: ${min}, max: ${max}})`);
+    }
+    const cutoff = Math.floor(256 ** neededBytes / range) * range;
+    const currentBytes = new Uint8Array(neededBytes);
+    let value;
+    do {
+        crypto.getRandomValues(currentBytes);
+        value = currentBytes.reduce((accum, byte, index) => {
+            return accum + byte * 256 ** index;
+        }, 0);
+    } while (value >= cutoff);
+    return min + (value % range);
+}

package/dist/augments/random/random-string.d.ts

@@ -0,0 +1,14 @@
+/**
+ * All letters allowed in {@link randomString}.
+ *
+ * @category Random:Common
+ */
+export declare const allowedRandomStringLetters: ReadonlyArray<string>;
+/**
+ * Creates a random string (including letters and numbers) of a given length.
+ *
+ * This function uses cryptographically secure randomness.
+ *
+ * @category Random:Common
+ */
+export declare function randomString(generatedStringLength?: number): string;

package/dist/augments/random/random-string.js

@@ -0,0 +1,63 @@
+import { randomInteger } from './random-integer.js';
+/**
+ * All letters allowed in {@link randomString}.
+ *
+ * @category Random:Common
+ */
+export const allowedRandomStringLetters = [
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+];
+/**
+ * Creates a random string (including letters and numbers) of a given length.
+ *
+ * This function uses cryptographically secure randomness.
+ *
+ * @category Random:Common
+ */
+export function randomString(generatedStringLength = 16) {
+    let stringBuilder = '';
+    for (let i = 0; i < generatedStringLength; i++) {
+        const index = randomInteger({
+            min: 0,
+            max: allowedRandomStringLetters.length - 1,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        stringBuilder += allowedRandomStringLetters[index];
+    }
+    return stringBuilder;
+}

package/dist/{types/augments/regexp.d.ts → augments/regexp/regexp-flags.d.ts}

@@ -1,3 +1,3 @@
 export declare function deDupeRegExFlags(flags: string): string;
 export declare function addRegExpFlags(originalRegExp: RegExp, flags: string): RegExp;
-export declare function safeMatch(input: string, regExp: RegExp): string[];
+export declare function makeCaseInsensitiveRegExp(searchForInput: string | RegExp, caseSensitive: boolean): RegExp;

package/dist/augments/regexp/regexp-flags.js

@@ -0,0 +1,18 @@
+import { escapeStringForRegExp } from './regexp-string.js';
+export function deDupeRegExFlags(flags) {
+    const deDuped = new Set(Array.from(flags.toLowerCase()));
+    return Array.from(deDuped).join('');
+}
+export function addRegExpFlags(originalRegExp, flags) {
+    return new RegExp(originalRegExp.source, deDupeRegExFlags([
+        originalRegExp.flags,
+        flags,
+    ].join('')));
+}
+export function makeCaseInsensitiveRegExp(searchForInput, caseSensitive) {
+    const regExpFlags = `g${!caseSensitive && typeof searchForInput === 'string' ? 'i' : ''}`;
+    const searchFor = searchForInput instanceof RegExp
+        ? new RegExp(searchForInput.source, deDupeRegExFlags(`${searchForInput.flags}${regExpFlags}`))
+        : new RegExp(escapeStringForRegExp(searchForInput), regExpFlags);
+    return searchFor;
+}

package/dist/augments/regexp/regexp-string.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Escapes characters from the given string so that it can be used within a RegExp without being
+ * parsed as RegExp syntax.
+ */
+export declare function escapeStringForRegExp(input: string): string;

package/dist/augments/regexp/regexp-string.js

@@ -0,0 +1,7 @@
+/**
+ * Escapes characters from the given string so that it can be used within a RegExp without being
+ * parsed as RegExp syntax.
+ */
+export function escapeStringForRegExp(input) {
+    return input.replace(/[\^$\\.*+?()[\]{}|]/g, String.raw `\$&`);
+}

package/dist/augments/regexp/safe-match.d.ts

@@ -0,0 +1 @@
+export declare function safeMatch(input: string, regExp: RegExp): string[];

package/dist/augments/regexp/safe-match.js

@@ -0,0 +1,4 @@
+export function safeMatch(input, regExp) {
+    const match = input.match(regExp);
+    return match ?? [];
+}

package/dist/augments/selection-set/select-collapsed.d.ts

@@ -0,0 +1,11 @@
+import type { AnyObject, Values } from '@augment-vir/core';
+import { ExcludeEmpty } from '../object/empty.js';
+import { KeyCount } from '../object/key-count.js';
+import { TsRecurse, TsRecursionStart, TsRecursionTracker, TsTooMuchRecursion } from '../type/type-recursion.js';
+import { GenericSelectionSet, PickSelection, SelectionSet } from './selection-set.js';
+export declare function selectCollapsedFrom<Full extends AnyObject, const Selection extends SelectionSet<NoInfer<Full>>>(originalObject: Readonly<Full>, selectionSet: Readonly<Selection>): PickCollapsedSelection<Full, Selection>;
+/**
+ * Collapses a selected value to the first part of the selection that contains more than 1 key or
+ * that is not an object.
+ */
+export type PickCollapsedSelection<Full extends Readonly<AnyObject>, Selection extends SelectionSet<Full>, Depth extends TsRecursionTracker = TsRecursionStart> = Depth extends TsTooMuchRecursion ? 'Error: recursive object depth is too deep.' : KeyCount<ExcludeEmpty<NonNullable<PickSelection<Full, Selection, Depth>>>> extends 1 ? Selection[keyof PickSelection<Full, Selection, Depth>] extends GenericSelectionSet ? PickCollapsedSelection<NonNullable<Full[keyof PickSelection<Full, Selection, Depth>]>, Selection[keyof PickSelection<Full, Selection, Depth>], TsRecurse<Depth>> | Extract<Full[keyof PickSelection<Full, Selection, Depth>], undefined | null> : Values<PickSelection<Full, Selection, Depth>> : PickSelection<Full, Selection, Depth>;

package/dist/augments/selection-set/select-collapsed.js

@@ -0,0 +1,25 @@
+import { check } from '@augment-vir/assert';
+import { selectFrom } from './select-from.js';
+import { shouldPreserveInSelectionSet, } from './selection-set.js';
+export function selectCollapsedFrom(originalObject, selectionSet) {
+    const selected = selectFrom(originalObject, selectionSet);
+    return collapseObject(selected, selectionSet);
+}
+function collapseObject(input, selectionSet) {
+    if (shouldPreserveInSelectionSet(input)) {
+        return input;
+    }
+    const keys = Object.keys(input);
+    if (Array.isArray(input)) {
+        return input.map((innerInput) => collapseObject(innerInput, selectionSet));
+    }
+    else if (check.isLengthAtLeast(keys, 2)) {
+        return input;
+    }
+    else if (check.isLengthAtLeast(keys, 1) && check.isObject(selectionSet)) {
+        return collapseObject(input[keys[0]], selectionSet[keys[0]]);
+    }
+    else {
+        return input;
+    }
+}

package/dist/augments/selection-set/select-from.d.ts

@@ -0,0 +1,3 @@
+import type { AnyObject } from '@augment-vir/core';
+import { PickSelection, SelectionSet } from './selection-set.js';
+export declare function selectFrom<Full extends AnyObject, const Selection extends SelectionSet<NoInfer<Full>>>(originalObject: Readonly<Full>, selectionSet: Readonly<Selection>): PickSelection<Full, Selection>;

package/dist/augments/selection-set/select-from.js

@@ -0,0 +1,25 @@
+import { mapObjectValues } from '../object/map-values.js';
+import { omitObjectKeys } from '../object/object-keys.js';
+import { shouldPreserveInSelectionSet } from './selection-set.js';
+export function selectFrom(originalObject, selectionSet) {
+    if (Array.isArray(originalObject)) {
+        return originalObject.map((originalEntry) => selectFrom(originalEntry, selectionSet));
+    }
+    const keysToRemove = [];
+    return omitObjectKeys(mapObjectValues(originalObject, (key, value) => {
+        const selection = selectionSet[key];
+        if (selection === true) {
+            return value;
+        }
+        else if (!selection) {
+            keysToRemove.push(key);
+            return undefined;
+        }
+        else if (shouldPreserveInSelectionSet(value)) {
+            return value;
+        }
+        else {
+            return selectFrom(value, selection);
+        }
+    }), keysToRemove);
+}

package/dist/augments/selection-set/selection-set.d.ts

@@ -0,0 +1,18 @@
+import type { AnyObject } from '@augment-vir/core';
+import { IsAny, IsNever, Primitive, UnionToIntersection } from 'type-fest';
+import { TsRecurse, TsRecursionStart, TsRecursionTracker, TsTooMuchRecursion } from '../type/type-recursion.js';
+export declare function shouldPreserveInSelectionSet(input: unknown): input is SelectionTypesToPreserve;
+/** All types that won't be recursed into when defining a {@link SelectionSet}. */
+export type SelectionTypesToPreserve = Primitive | RegExp | Promise<any>;
+/** A generic selection set without specific keys. */
+export type GenericSelectionSet = {
+    [Key in PropertyKey]: unknown;
+};
+/** Masks an object value with the given {@link SelectionSet}. */
+export type PickSelection<Full extends Readonly<AnyObject>, Selection extends SelectionSet<Full>, Depth extends TsRecursionTracker = TsRecursionStart> = Depth extends TsTooMuchRecursion ? ['Error: recursive object depth is too deep.'] : Full extends ReadonlyArray<infer Element extends any> ? (PickSelection<Extract<Element, AnyObject>, Selection, TsRecurse<Depth>> | Exclude<Element, AnyObject>)[] : {
+    -readonly [Key in keyof Selection as Selection[Key] extends false ? never : Key extends keyof Full ? Key : never]: (Selection[Key] extends GenericSelectionSet ? PickSelection<NonNullable<Extract<Full[Key], AnyObject>>, Selection[Key], TsRecurse<Depth>> : Full[Key]) | Exclude<Full[Key], AnyObject>;
+};
+/** Defines a selection set for the given object. */
+export type SelectionSet<Full extends Readonly<AnyObject>, Depth extends TsRecursionTracker = TsRecursionStart> = IsAny<Full> extends true ? any : Depth extends TsTooMuchRecursion ? boolean : Full extends ReadonlyArray<infer FullChild extends AnyObject> ? SelectionSet<FullChild, TsRecurse<Depth>> : Partial<{
+    [Key in keyof Full]: IsNever<Exclude<Full[Key], SelectionTypesToPreserve>> extends true ? boolean : UnionToIntersection<SelectionSet<NonNullable<Required<Full>[Key]>, TsRecurse<Depth>>> | boolean;
+}>;

package/dist/augments/selection-set/selection-set.js

@@ -0,0 +1,4 @@
+import { check } from '@augment-vir/assert';
+export function shouldPreserveInSelectionSet(input) {
+    return check.isPrimitive(input) || input instanceof RegExp || input instanceof Promise;
+}

package/dist/augments/string/casing/capitalization.d.ts

@@ -0,0 +1,3 @@
+import { CasingOptions } from './casing.js';
+export declare function maybeCapitalize(input: string, casingOptions: Partial<CasingOptions>): string;
+export declare function capitalizeFirstLetter<InputGeneric extends string>(input: InputGeneric): Capitalize<InputGeneric>;

package/dist/augments/string/casing/capitalization.js

@@ -0,0 +1,11 @@
+export function maybeCapitalize(input, casingOptions) {
+    return casingOptions.capitalizeFirstLetter ? capitalizeFirstLetter(input) : input;
+}
+export function capitalizeFirstLetter(input) {
+    if (!input.length) {
+        return '';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const firstLetter = input[0];
+    return (firstLetter.toUpperCase() + input.slice(1));
+}

package/dist/augments/string/casing/casing.d.ts

@@ -0,0 +1,27 @@
+import { PartialWithUndefined } from '@augment-vir/core';
+export type CasingOptions = {
+    capitalizeFirstLetter: boolean;
+};
+export declare const defaultCasingOptions: Required<CasingOptions>;
+export declare enum StringCaseEnum {
+    Upper = "upper",
+    Lower = "lower"
+}
+/** Indicates whether the given string has different lower and upper case variants. */
+export declare function hasCase(input: string): boolean;
+export type IsCaseOptions = {
+    /**
+     * Fail on characters that don't have different upper and lower case versions (such as
+     * punctuation, like `'.'` or symbols, like `'√'`).
+     */
+    failOnNoCaseCharacters: boolean;
+};
+/**
+ * Checks if the given string is exclusively of the specific case.
+ *
+ * Note that some characters have no casing, such as punctuation (they have no difference between
+ * upper and lower casings). By default, those letters always return `true` for this function,
+ * regardless of which `caseType` is provided. To instead return `false` for any such characters,
+ * pass in an options object and set blockNoCaseCharacters to true.
+ */
+export declare function isCase(input: string, caseType: StringCaseEnum, options?: PartialWithUndefined<IsCaseOptions>): boolean;

package/dist/augments/string/casing/casing.js

@@ -0,0 +1,40 @@
+export const defaultCasingOptions = {
+    capitalizeFirstLetter: false,
+};
+export var StringCaseEnum;
+(function (StringCaseEnum) {
+    StringCaseEnum["Upper"] = "upper";
+    StringCaseEnum["Lower"] = "lower";
+})(StringCaseEnum || (StringCaseEnum = {}));
+/** Indicates whether the given string has different lower and upper case variants. */
+export function hasCase(input) {
+    return input.toLowerCase() !== input.toUpperCase();
+}
+/**
+ * Checks if the given string is exclusively of the specific case.
+ *
+ * Note that some characters have no casing, such as punctuation (they have no difference between
+ * upper and lower casings). By default, those letters always return `true` for this function,
+ * regardless of which `caseType` is provided. To instead return `false` for any such characters,
+ * pass in an options object and set blockNoCaseCharacters to true.
+ */
+export function isCase(input, caseType, options) {
+    if (!input && options?.failOnNoCaseCharacters) {
+        return false;
+    }
+    for (const letter of input) {
+        if (!hasCase(letter)) {
+            if (options?.failOnNoCaseCharacters) {
+                return false;
+            }
+            else {
+                continue;
+            }
+        }
+        else if ((caseType === StringCaseEnum.Upper && letter !== letter.toUpperCase()) ||
+            (caseType === StringCaseEnum.Lower && letter !== letter.toLowerCase())) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/augments/string/casing/kebab-and-camel.d.ts

@@ -0,0 +1,3 @@
+import { CasingOptions } from './casing.js';
+export declare function kebabCaseToCamelCase(rawKebabCase: string, casingOptions?: Partial<CasingOptions> | undefined): string;
+export declare function camelCaseToKebabCase(rawCamelCase: string): string;

package/dist/augments/string/casing/kebab-and-camel.js

@@ -0,0 +1,42 @@
+import { maybeCapitalize } from './capitalization.js';
+import { defaultCasingOptions, isCase, StringCaseEnum } from './casing.js';
+export function kebabCaseToCamelCase(rawKebabCase, casingOptions = defaultCasingOptions) {
+    const kebabCase = rawKebabCase.toLowerCase();
+    if (!kebabCase.length) {
+        return '';
+    }
+    const camelCase = kebabCase
+        .replace(/^-+/, '')
+        .replace(/-{2,}/g, '-')
+        .replace(/-(?:.|$)/g, (dashMatch) => {
+        const letter = dashMatch[1];
+        if (letter) {
+            return letter.toUpperCase();
+        }
+        else {
+            return '';
+        }
+    });
+    return maybeCapitalize(camelCase, casingOptions);
+}
+export function camelCaseToKebabCase(rawCamelCase) {
+    const kebabCase = rawCamelCase
+        .split('')
+        .reduce((accum, currentLetter, index, originalString) => {
+        const previousLetter = index > 0 ? originalString[index - 1] || '' : '';
+        const nextLetter = index < originalString.length - 1 ? originalString[index + 1] || '' : '';
+        const possibleWordBoundary = isCase(previousLetter, StringCaseEnum.Lower, { failOnNoCaseCharacters: true }) ||
+            isCase(nextLetter, StringCaseEnum.Lower, { failOnNoCaseCharacters: true });
+        if (currentLetter === currentLetter.toLowerCase() ||
+            index === 0 ||
+            !possibleWordBoundary) {
+            accum += currentLetter;
+        }
+        else {
+            accum += `-${currentLetter.toLowerCase()}`;
+        }
+        return accum;
+    }, '')
+        .toLowerCase();
+    return kebabCase;
+}

package/dist/augments/string/commas.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Removes all commas from the given string.
+ *
+ * @category String:Common
+ */
+export declare function removeCommas(input: string): string;
+export declare function addCommasToNumber(input: number | string): string;

package/dist/augments/string/commas.js

@@ -0,0 +1,29 @@
+import { safeMatch } from '../regexp/safe-match.js';
+/**
+ * Removes all commas from the given string.
+ *
+ * @category String:Common
+ */
+export function removeCommas(input) {
+    return input.replace(/,/g, '');
+}
+export function addCommasToNumber(input) {
+    if (typeof input === 'string' && isNaN(Number(input))) {
+        return 'NaN';
+    }
+    const numericValue = Number(input);
+    const isNegative = numericValue < 0;
+    const stringValue = String(Math.abs(numericValue));
+    const [digits = '', decimalValues,] = stringValue.split('.');
+    const decimalString = decimalValues ? `.${decimalValues}` : '';
+    const separated = safeMatch(digits.split('').reverse().join(''), /.{1,3}/g)
+        .reverse()
+        .map((entry) => entry.split('').reverse().join(''));
+    const valueWithCommas = separated.join(',');
+    const negativeMarker = isNegative ? '-' : '';
+    return [
+        negativeMarker,
+        valueWithCommas,
+        decimalString,
+    ].join('');
+}