typeshi 1.7.13 → 1.7.15

package/dist/utils/io/logging.d.ts

@@ -19,12 +19,12 @@ export declare function autoFormatLogsOnExit(filePaths?: string[]): void;
 /**
  * Formats a debug log file from JSON format to a more readable text format.
  * Removes the numeric keys and properly handles escape sequences.
- * @param inputFilePath `string` - path to the input log file (e.g., DEBUG.txt)
- * @param outputFilePath `string` - optional, path to the output formatted file.
- * If not provided, will use inputFilePath with '.FORMATTED' inserted before the extension.
+ * @param inputPath `string` - path to the input log file (e.g., DEBUG.txt)
+ * @param outputPath `string` - optional, path to the output formatted file.
+ * If not provided, will use inputPath with '.FORMATTED' inserted before the extension.
  * @returns `void`
  */
-export declare function formatDebugLogFile(inputFilePath: string, outputFilePath?: string): void;
+export declare function formatDebugLogFile(inputPath: string, outputPath?: string): void;
 /**
  * Formats all debug log files in the log directory.
  * Looks for .txt files and creates .FORMATTED.txt versions.

package/dist/utils/io/logging.js

@@ -101,23 +101,23 @@ function autoFormatLogsOnExit(filePaths) {
 /**
  * Formats a debug log file from JSON format to a more readable text format.
  * Removes the numeric keys and properly handles escape sequences.
- * @param inputFilePath `string` - path to the input log file (e.g., DEBUG.txt)
- * @param outputFilePath `string` - optional, path to the output formatted file.
- * If not provided, will use inputFilePath with '.FORMATTED' inserted before the extension.
+ * @param inputPath `string` - path to the input log file (e.g., DEBUG.txt)
+ * @param outputPath `string` - optional, path to the output formatted file.
+ * If not provided, will use inputPath with '.FORMATTED' inserted before the extension.
  * @returns `void`
  */
-function formatDebugLogFile(inputFilePath, outputFilePath) {
-    validate.existingPathArgument(`logging.formatDebugLogFile`, { inputFilePath });
+function formatDebugLogFile(inputPath, outputPath) {
+    validate.existingPathArgument(`logging.formatDebugLogFile`, { inputPath });
     // Generate output path if not provided
-    if (!outputFilePath) {
-        const parsedPath = node_path_1.default.parse(inputFilePath);
-        outputFilePath = node_path_1.default.join(parsedPath.dir, `${parsedPath.name}.FORMATTED${parsedPath.ext}`);
+    if (!outputPath) {
+        const parsedPath = node_path_1.default.parse(inputPath);
+        outputPath = node_path_1.default.join(parsedPath.dir, `${parsedPath.name}.FORMATTED${parsedPath.ext}`);
     }
     try {
-        const fileContent = fs.readFileSync(inputFilePath, 'utf-8');
+        const fileContent = fs.readFileSync(inputPath, 'utf-8');
         const formattedContent = formatLogContent(fileContent);
-        fs.writeFileSync(outputFilePath, formattedContent, { encoding: 'utf-8' });
-        // mlog.info(`[formatDebugLogFile()] Formatted log file saved to '${outputFilePath}'`);
+        fs.writeFileSync(outputPath, formattedContent, { encoding: 'utf-8' });
+        // mlog.info(`[formatDebugLogFile()] Formatted log file saved to '${outputPath}'`);
     }
     catch (error) {
         setupLog_1.typeshiLogger.error('[formatDebugLogFile()] Error formatting log file:', error);

package/dist/utils/io/reading.d.ts

@@ -14,8 +14,9 @@ export declare function isFile(value: string): value is string;
 export declare function getDelimiterFromFilePath(filePath: string): DelimiterCharacterEnum | string;
 /**
  * @param filePath `string`
- * @returns **`jsonData`** — `Record<string, any>`
- * - JSON data as an object
+ * @returns **`jsonData`** — `T extends Record<string, any>` - JSON data as an object
+ * @note returns empty object if error occurred while reading `filepath` or parsing json
+ * - use {@link readJsonSyncOrThrow} if throwing error is desired behavior
  */
 export declare const readJsonSync: typeof readJsonFileAsObject;
 /**

package/dist/utils/io/reading.js

@@ -109,8 +109,9 @@ function getDelimiterFromFilePath(filePath) {
 }
 /**
  * @param filePath `string`
- * @returns **`jsonData`** — `Record<string, any>`
- * - JSON data as an object
+ * @returns **`jsonData`** — `T extends Record<string, any>` - JSON data as an object
+ * @note returns empty object if error occurred while reading `filepath` or parsing json
+ * - use {@link readJsonSyncOrThrow} if throwing error is desired behavior
  */
 exports.readJsonSync = readJsonFileAsObject;
 /**

package/dist/utils/io/writing.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @file src/utils/io/writing.ts
+ */
+import * as fs from "node:fs";
 import { WriteJsonOptions } from "./types";
 /**
  * Output JSON data to a file with `fs.writeFileSync` or `fs.appendFileSync`.
@@ -21,17 +25,7 @@ export declare function writeObjectToJsonSync(options: WriteJsonOptions): void;
  */
 export declare function writeObjectToJsonSync(data: Record<string, any> | string, filePath: string, indent?: number, enableOverwrite?: boolean): void;
 export declare const writeJsonSync: typeof writeObjectToJsonSync;
-/**
- * @param data `Record<string, any> | string` - JSON data to stringify
- * @param indent `number` `optional`, default=`0` - number of additional indents to add to each line
- * @param spaces `number` `optional`, default=`4`
- * @returns **`jsonString`** `string`
- */
-export declare function indentedStringify(data: Record<string, any> | string, indent?: number, spaces?: number): string;
-/**
- * @returns **`timestamp`** `string` = `(${MM}-${DD})_(${HH}.${mm}.${ss}.${ms})`
- */
-export declare function getFileNameTimestamp(): string;
+export declare const writeArraysToCsvSync: typeof writeListsToCsvSync;
 /**
  * @param listData `Record<string, Array<string>>` map col names to col values
  * @param outputPath `string`
@@ -39,6 +33,23 @@ export declare function getFileNameTimestamp(): string;
  * @param columnDelimiter `string` - optional, default=`''`
  */
 export declare function writeListsToCsvSync(listData: Record<string, Array<string>>, outputPath: string, delimiter?: string, columnDelimiter?: string): void;
+/**
+ * @param arr `T[]`
+ * @param outputPath `string`
+ * @param separator `string` `default` = `'\n'`
+ * @param options {@link fs.WriteFileOptions} `default` = `{ encoding: 'utf-8', flag: 'w' }`
+ * - use `flag: 'a'` to append rather than overwrite
+ */
+export declare function writeArrayToFileSync<T>(arr: T[], outputPath: string, separator?: string, options?: fs.WriteFileOptions): void;
+/**
+ * @consideration maybe it would be better to have the delimiter be an explicit param rather
+ * than implicitly determined by `outputPath`
+ * - can write to `tsv` by having `outputPath` end with `'.tsv'`
+ * @param rows `Record<string, any>[]` - array of objects to write to CSV
+ * @param outputPath `string` - path to the output CSV file.
+ * @returns **`void`**
+ */
+export declare function writeRowsToCsvSync(rows: Record<string, any>[], outputPath: string, headers?: string[]): void;
 /**
  * @TODO handle other file extensions
  * @param maxMB - Maximum size in MB to keep in the file, default is `5` -> 5MB.
@@ -57,11 +68,13 @@ export declare function clearFileSync(...filePaths: string[]): void;
  */
 export declare function clearFile(...filePaths: string[]): Promise<void>;
 /**
- * @consideration maybe it would be better to have the delimiter be an explicit param rather
- * than implicitly determined by `outputPath`
- * - can write to `tsv` by having `outputPath` end with `'.tsv'`
- * @param rows `Record<string, any>[]` - array of objects to write to CSV
- * @param outputPath `string` - path to the output CSV file.
- * @returns **`void`**
+ * @param data `Record<string, any> | string` - JSON data to stringify
+ * @param indent `number` `optional`, default=`0` - number of additional indents to add to each line
+ * @param spaces `number` `optional`, default=`4`
+ * @returns **`jsonString`** `string`
  */
-export declare function writeRowsToCsvSync(rows: Record<string, any>[], outputPath: string, headers?: string[]): void;
+export declare function indentedStringify(data: Record<string, any> | string, indent?: number, spaces?: number): string;
+/**
+ * @returns **`timestamp`** `string` = `(${MM}-${DD})_(${HH}.${mm}.${ss}.${ms})`
+ */
+export declare function getFileNameTimestamp(): string;

package/dist/utils/io/writing.js

@@ -33,27 +33,26 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeJsonSync = void 0;
+exports.writeArraysToCsvSync = exports.writeJsonSync = void 0;
 exports.writeObjectToJsonSync = writeObjectToJsonSync;
-exports.indentedStringify = indentedStringify;
-exports.getFileNameTimestamp = getFileNameTimestamp;
 exports.writeListsToCsvSync = writeListsToCsvSync;
+exports.writeArrayToFileSync = writeArrayToFileSync;
+exports.writeRowsToCsvSync = writeRowsToCsvSync;
 exports.trimFileSync = trimFileSync;
 exports.trimFile = trimFile;
 exports.clearFileSync = clearFileSync;
 exports.clearFile = clearFile;
-exports.writeRowsToCsvSync = writeRowsToCsvSync;
+exports.indentedStringify = indentedStringify;
+exports.getFileNameTimestamp = getFileNameTimestamp;
 /**
  * @file src/utils/io/writing.ts
  */
-const fs = __importStar(require("fs"));
+const fs = __importStar(require("node:fs"));
 const env_1 = require("../../config/env");
 const setupLog_1 = require("../../config/setupLog");
 const reading_1 = require("./reading");
 const types_1 = require("./types");
 const typeValidation_1 = require("../typeValidation");
-const validate = __importStar(require("../argumentValidation"));
-const fs_1 = require("fs");
 const logging_1 = require("./logging");
 function writeObjectToJsonSync(
 /** {@link WriteJsonOptions} `| Record<string, any> | string`, */
@@ -115,38 +114,7 @@ arg1, filePath, indent = 4, enableOverwrite = true) {
     }
 }
 exports.writeJsonSync = writeObjectToJsonSync;
-/**
- * @param data `Record<string, any> | string` - JSON data to stringify
- * @param indent `number` `optional`, default=`0` - number of additional indents to add to each line
- * @param spaces `number` `optional`, default=`4`
- * @returns **`jsonString`** `string`
- */
-function indentedStringify(data, indent = 0, spaces = 4) {
-    if (!data) {
-        return '';
-    }
-    let jsonString = typeof data === 'string'
-        ? data : JSON.stringify(data, null, spaces);
-    jsonString = jsonString
-        .split('\n')
-        .map(line => setupLog_1.INDENT_LOG_LINE + '\t'.repeat(indent) + line)
-        .join('')
-        .replace(/^\n\t. /, '').replace(/•/g, '');
-    return jsonString;
-}
-/**
- * @returns **`timestamp`** `string` = `(${MM}-${DD})_(${HH}.${mm}.${ss}.${ms})`
- */
-function getFileNameTimestamp() {
-    const now = new Date();
-    const MM = String(now.getMonth() + 1).padStart(2, '0');
-    const DD = String(now.getDate()).padStart(2, '0');
-    const HH = String(now.getHours()).padStart(2, '0');
-    const mm = String(now.getMinutes()).padStart(2, '0');
-    const ss = String(now.getSeconds()).padStart(2, '0');
-    const ms = String(now.getMilliseconds()).padStart(3, '0');
-    return `(${MM}-${DD})_(${HH}.${mm}.${ss}.${ms})`;
-}
+exports.writeArraysToCsvSync = writeListsToCsvSync;
 /**
  * @param listData `Record<string, Array<string>>` map col names to col values
  * @param outputPath `string`
@@ -173,6 +141,56 @@ function writeListsToCsvSync(listData, outputPath, delimiter = types_1.Delimiter
         setupLog_1.typeshiLogger.info(`CSV file has been saved to ${outputPath}`);
     });
 }
+/**
+ * @param arr `T[]`
+ * @param outputPath `string`
+ * @param separator `string` `default` = `'\n'`
+ * @param options {@link fs.WriteFileOptions} `default` = `{ encoding: 'utf-8', flag: 'w' }`
+ * - use `flag: 'a'` to append rather than overwrite
+ */
+function writeArrayToFileSync(arr, outputPath, separator = '\n', options = { encoding: 'utf-8', flag: 'w' }) {
+    const source = (0, logging_1.getSourceString)(__filename, writeArrayToFileSync.name);
+    try {
+        const content = arr.map(el => JSON.stringify(el)).join(separator);
+        fs.writeFileSync(outputPath, content, options);
+    }
+    catch (error) {
+        setupLog_1.typeshiLogger.error([`${source} Error writing array to file`,
+            `intended outputPath: '${outputPath}'`,
+            `caught error: ${error}`
+        ].join(setupLog_1.INDENT_LOG_LINE));
+    }
+    return;
+}
+/**
+ * @consideration maybe it would be better to have the delimiter be an explicit param rather
+ * than implicitly determined by `outputPath`
+ * - can write to `tsv` by having `outputPath` end with `'.tsv'`
+ * @param rows `Record<string, any>[]` - array of objects to write to CSV
+ * @param outputPath `string` - path to the output CSV file.
+ * @returns **`void`**
+ */
+function writeRowsToCsvSync(rows, outputPath, headers) {
+    const source = (0, logging_1.getSourceString)(__filename, writeRowsToCsvSync.name);
+    try {
+        const delimiter = (0, reading_1.getDelimiterFromFilePath)(outputPath);
+        if (!(0, typeValidation_1.isStringArray)(headers)) {
+            headers = Array.from(new Set(rows.map(r => Object.keys(r)).flat()));
+        }
+        if ((0, typeValidation_1.isEmptyArray)(headers)) {
+            setupLog_1.typeshiLogger.error([`${source} No headers found in rows, nothing to write.`,
+                `Intended outputPath: '${outputPath}'`,
+            ].join(setupLog_1.INDENT_LOG_LINE));
+            return;
+        }
+        const csvContent = [headers.join(delimiter)].concat(rows.map(row => (headers ?? []).map(h => row[h] ?? '').join(delimiter))).join('\n');
+        fs.writeFileSync(outputPath, csvContent, { encoding: 'utf-8' });
+        setupLog_1.typeshiLogger.info(`${source} file has been saved to '${outputPath}'`);
+    }
+    catch (error) {
+        setupLog_1.typeshiLogger.error(`${source} Error writing to CSV file`, error);
+    }
+}
 /**
  * @TODO handle other file extensions
  * @param maxMB - Maximum size in MB to keep in the file, default is `5` -> 5MB.
@@ -241,19 +259,19 @@ async function trimFile(maxMB = 5, ...filePaths) {
  */
 function clearFileSync(...filePaths) {
     for (const filePath of filePaths) {
-        if (!filePath || !(0, fs_1.existsSync)(filePath)) {
+        if (!filePath || !fs.existsSync(filePath)) {
             setupLog_1.typeshiLogger.warn(`clearFileSync() Log file does not exist: ${filePath}`);
             continue;
         }
         try {
-            (0, fs_1.writeFileSync)(filePath, '', { encoding: 'utf-8', flag: 'w' });
+            fs.writeFileSync(filePath, '', { encoding: 'utf-8', flag: 'w' });
         }
         catch (error) {
             if (error.code === 'EBUSY' || error.code === 'EMFILE') {
                 // File is busy, try again after a short delay
                 setTimeout(() => {
                     try {
-                        (0, fs_1.writeFileSync)(filePath, '', { encoding: 'utf-8', flag: 'w' });
+                        fs.writeFileSync(filePath, '', { encoding: 'utf-8', flag: 'w' });
                     }
                     catch (retryError) {
                         setupLog_1.typeshiLogger.warn(`clearFileSync() Failed to clear file after retry: ${filePath}`, retryError);
@@ -272,14 +290,14 @@ function clearFileSync(...filePaths) {
  */
 async function clearFile(...filePaths) {
     const promises = filePaths.map(async (filePath) => {
-        if (!filePath || !(0, fs_1.existsSync)(filePath)) {
+        if (!filePath || !fs.existsSync(filePath)) {
             setupLog_1.typeshiLogger.warn(`clearFile() Log file does not exist: ${filePath}`);
             return;
         }
         return new Promise((resolve, reject) => {
             const tryWrite = (attempt = 1) => {
                 try {
-                    (0, fs_1.writeFileSync)(filePath, '', { encoding: 'utf-8', flag: 'w' });
+                    fs.writeFileSync(filePath, '', { encoding: 'utf-8', flag: 'w' });
                     resolve();
                 }
                 catch (error) {
@@ -299,34 +317,34 @@ async function clearFile(...filePaths) {
     await (0, env_1.DELAY)(1000, ` > [clearFile()] Releasing file handles...`);
 }
 /**
- * @consideration maybe it would be better to have the delimiter be an explicit param rather
- * than implicitly determined by `outputPath`
- * - can write to `tsv` by having `outputPath` end with `'.tsv'`
- * @param rows `Record<string, any>[]` - array of objects to write to CSV
- * @param outputPath `string` - path to the output CSV file.
- * @returns **`void`**
+ * @param data `Record<string, any> | string` - JSON data to stringify
+ * @param indent `number` `optional`, default=`0` - number of additional indents to add to each line
+ * @param spaces `number` `optional`, default=`4`
+ * @returns **`jsonString`** `string`
  */
-function writeRowsToCsvSync(rows, outputPath, headers) {
-    const source = (0, logging_1.getSourceString)(__filename, writeRowsToCsvSync.name);
-    validate.arrayArgument(source, { rows });
-    validate.stringArgument(source, { outputPath });
-    const delimiter = (0, reading_1.getDelimiterFromFilePath)(outputPath);
-    if (!(0, typeValidation_1.isStringArray)(headers)) {
-        headers = Array.from(new Set(rows.map(r => Object.keys(r)).flat()));
-    }
-    if ((0, typeValidation_1.isEmptyArray)(headers)) {
-        setupLog_1.typeshiLogger.error([`${source} No headers found in rows, nothing to write.`,
-            `Intended outputPath: '${outputPath}'`,
-        ].join(setupLog_1.INDENT_LOG_LINE));
-        return;
-    }
-    const csvContent = [headers.join(delimiter)].concat(rows.map(row => headers.map(h => row[h] ?? '').join(delimiter))).join('\n');
-    try {
-        fs.writeFileSync(outputPath, csvContent, { encoding: 'utf-8' });
-        setupLog_1.typeshiLogger.info(`${source} file has been saved to '${outputPath}'`);
-    }
-    catch (e) {
-        setupLog_1.typeshiLogger.error('[writeRowsToCsv()] Error writing to CSV file', e);
-        throw e;
+function indentedStringify(data, indent = 0, spaces = 4) {
+    if (!data) {
+        return '';
     }
+    let jsonString = typeof data === 'string'
+        ? data : JSON.stringify(data, null, spaces);
+    jsonString = jsonString
+        .split('\n')
+        .map(line => setupLog_1.INDENT_LOG_LINE + '\t'.repeat(indent) + line)
+        .join('')
+        .replace(/^\n\t. /, '').replace(/•/g, '');
+    return jsonString;
+}
+/**
+ * @returns **`timestamp`** `string` = `(${MM}-${DD})_(${HH}.${mm}.${ss}.${ms})`
+ */
+function getFileNameTimestamp() {
+    const now = new Date();
+    const MM = String(now.getMonth() + 1).padStart(2, '0');
+    const DD = String(now.getDate()).padStart(2, '0');
+    const HH = String(now.getHours()).padStart(2, '0');
+    const mm = String(now.getMinutes()).padStart(2, '0');
+    const ss = String(now.getSeconds()).padStart(2, '0');
+    const ms = String(now.getMilliseconds()).padStart(3, '0');
+    return `(${MM}-${DD})_(${HH}.${mm}.${ss}.${ms})`;
 }

package/dist/utils/regex/stringOperations.d.ts

@@ -40,14 +40,14 @@ export declare function stringContainsAnyOf(s: string, substrings: string | stri
  * - **`false`** `otherwise`.
  */
 export declare function equivalentAlphanumericStrings(s1: string, s2: string, tolerance?: number): boolean;
-export declare class StringOperation {
+export declare namespace Str {
     /**
      * @param s `string`
      * @param prefixes `string | string[] | RegExp` possible starting string(s).
      * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
      * @returns **`true`** if the string starts with any of the prefixes, **`false`** otherwise.
      */
-    static startsWith: typeof stringStartsWithAnyOf;
+    const startsWith: typeof stringStartsWithAnyOf;
     /**
      * Checks if a string ends with any of the specified suffixes.
      * @param s `string`
@@ -55,14 +55,14 @@ export declare class StringOperation {
      * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
      * @returns **`true`** if the string ends with any of the suffixes, **`false`** otherwise.
      */
-    static endsWith: typeof stringEndsWithAnyOf;
+    const endsWith: typeof stringEndsWithAnyOf;
     /**
-     * @param s `string` to check.
-     * @param substrings `string | string[] | RegExp`.
+     * @param s `string`
+     * @param substrings `string | string[] | RegExp`
      * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
      * @returns **`true`** if the string contains any of the substrings, **`false`** otherwise.
      */
-    static contains: typeof stringContainsAnyOf;
+    const contains: typeof stringContainsAnyOf;
     /**
      * Ignores case by default:
      * - converts `s1` & `s2` to lowercase and removes all non-alphanumeric characters from both strings,
@@ -75,7 +75,7 @@ export declare class StringOperation {
      * - **`true`** `if` the two alphanumeric strings are equivalent,
      * - **`false`** `otherwise`.
      */
-    static equivalentAlphanumeric: typeof equivalentAlphanumericStrings;
+    const equivalentAlphanumeric: typeof equivalentAlphanumericStrings;
 }
 /** for simple regular expressions...
  * so like not ones that have parentheses, pipes, or curly braced numbers */

package/dist/utils/regex/stringOperations.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringOperation = void 0;
+exports.Str = void 0;
 exports.stringEndsWithAnyOf = stringEndsWithAnyOf;
 exports.stringStartsWithAnyOf = stringStartsWithAnyOf;
 exports.stringContainsAnyOf = stringContainsAnyOf;
@@ -173,44 +173,44 @@ function equivalentAlphanumericStrings(s1, s2, tolerance = 0.90) {
     }
     return false;
 }
-class StringOperation {
-}
-exports.StringOperation = StringOperation;
-/**
- * @param s `string`
- * @param prefixes `string | string[] | RegExp` possible starting string(s).
- * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
- * @returns **`true`** if the string starts with any of the prefixes, **`false`** otherwise.
- */
-StringOperation.startsWith = stringStartsWithAnyOf;
-/**
- * Checks if a string ends with any of the specified suffixes.
- * @param s `string`
- * @param suffixes `string | string[] | RegExp` possible ending strings.
- * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
- * @returns **`true`** if the string ends with any of the suffixes, **`false`** otherwise.
- */
-StringOperation.endsWith = stringEndsWithAnyOf;
-/**
- * @param s `string` to check.
- * @param substrings `string | string[] | RegExp`.
- * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
- * @returns **`true`** if the string contains any of the substrings, **`false`** otherwise.
- */
-StringOperation.contains = stringContainsAnyOf;
-/**
- * Ignores case by default:
- * - converts `s1` & `s2` to lowercase and removes all non-alphanumeric characters from both strings,
- * - sorts the characters in both strings,
- * - then compares the two strings for equivalence.
- * @param s1 `string`
- * @param s2 `string`
- * @param tolerance `number` - a number between 0 and 1, default is `0.90`
- * @returns **`boolean`**
- * - **`true`** `if` the two alphanumeric strings are equivalent,
- * - **`false`** `otherwise`.
- */
-StringOperation.equivalentAlphanumeric = equivalentAlphanumericStrings;
+var Str;
+(function (Str) {
+    /**
+     * @param s `string`
+     * @param prefixes `string | string[] | RegExp` possible starting string(s).
+     * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
+     * @returns **`true`** if the string starts with any of the prefixes, **`false`** otherwise.
+     */
+    Str.startsWith = stringStartsWithAnyOf;
+    /**
+     * Checks if a string ends with any of the specified suffixes.
+     * @param s `string`
+     * @param suffixes `string | string[] | RegExp` possible ending strings.
+     * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
+     * @returns **`true`** if the string ends with any of the suffixes, **`false`** otherwise.
+     */
+    Str.endsWith = stringEndsWithAnyOf;
+    /**
+     * @param s `string`
+     * @param substrings `string | string[] | RegExp`
+     * @param flags `RegExpFlagsEnum[] (Optional)` regex flags to use when creating the {@link RegExp} object. see {@link RegExpFlagsEnum}
+     * @returns **`true`** if the string contains any of the substrings, **`false`** otherwise.
+     */
+    Str.contains = stringContainsAnyOf;
+    /**
+     * Ignores case by default:
+     * - converts `s1` & `s2` to lowercase and removes all non-alphanumeric characters from both strings,
+     * - sorts the characters in both strings,
+     * - then compares the two strings for equivalence.
+     * @param s1 `string`
+     * @param s2 `string`
+     * @param tolerance `number` - a number between 0 and 1, default is `0.90`
+     * @returns **`boolean`**
+     * - **`true`** `if` the two alphanumeric strings are equivalent,
+     * - **`false`** `otherwise`.
+     */
+    Str.equivalentAlphanumeric = equivalentAlphanumericStrings;
+})(Str || (exports.Str = Str = {}));
 /** for simple regular expressions...
  * so like not ones that have parentheses, pipes, or curly braced numbers */
 function extractSource(regex) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typeshi",
-    "version": "1.7.13",
+    "version": "1.7.15",
     "description": "TypeScript utility modules",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",