typeshi 1.7.19 → 2.0.1

package/dist/utils/regex/types/StringOptions.TypeGuards.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStringCleanOptions = isStringCleanOptions;
+exports.isStringStripOptions = isStringStripOptions;
+exports.isStringPadOptions = isStringPadOptions;
+exports.isStringCaseEnum = isStringCaseEnum;
+exports.isStringPadEnum = isStringPadEnum;
+exports.isStringReplaceParams = isStringReplaceParams;
+exports.isStringCondition = isStringCondition;
+exports.isStringStripCondition = isStringStripCondition;
+exports.DEP_isCleanStringOptions = DEP_isCleanStringOptions;
+/**
+ * @file src/utils/regex/types/StringOptions.TypeGuards.ts
+ */
+const StringOptions_1 = require("./StringOptions");
+const typeValidation_1 = require("../../typeValidation");
+function isStringCleanOptions(value) {
+    const candidate = value;
+    return ((0, typeValidation_1.isObject)(candidate, false)
+        && typeValidation_1.isUndefinedOr.type(candidate.strip, isStringStripOptions)
+        && typeValidation_1.isUndefinedOr.type(candidate.pad, isStringPadOptions)
+        && typeValidation_1.isUndefinedOr.type(candidate.case, isStringCaseEnum)
+        && typeValidation_1.isUndefinedOr.array(candidate.replace, isStringReplaceParams)
+        && typeValidation_1.isUndefinedOr.boolean(candidate.useDefault));
+}
+function isStringStripOptions(value) {
+    const candidate = value;
+    return ((0, typeValidation_1.isObject)(candidate, false)
+        && (typeValidation_1.isUndefinedOr.string(candidate.char) || candidate.char instanceof RegExp)
+        && typeValidation_1.isUndefinedOr.type(candidate.left, isStringStripCondition)
+        && typeValidation_1.isUndefinedOr.type(candidate.right, isStringStripCondition));
+}
+function isStringPadOptions(value) {
+    const candidate = value;
+    return ((0, typeValidation_1.isObject)(candidate)
+        && (0, typeValidation_1.isPositveInteger)(candidate.maxLength)
+        && (!candidate.char || (typeof candidate.char === 'string' && candidate.char.length === 1))
+        && typeValidation_1.isUndefinedOr.type(candidate.side, isStringPadEnum));
+}
+function isStringCaseEnum(value) {
+    return ((0, typeValidation_1.isNonEmptyString)(value)
+        && Object.values(StringOptions_1.StringCaseEnum).includes(value));
+}
+function isStringPadEnum(value) {
+    return ((0, typeValidation_1.isNonEmptyString)(value)
+        && Object.values(StringOptions_1.StringPadEnum).includes(value));
+}
+function isStringReplaceParams(value) {
+    const candidate = value;
+    return ((0, typeValidation_1.isObject)(candidate)
+        && (typeof candidate.searchValue === 'string' || candidate.searchValue instanceof RegExp)
+        && (typeof candidate.replaceValue === 'string'));
+}
+function isStringCondition(value) {
+    const candidate = value;
+    return ((0, typeValidation_1.isObject)(candidate)
+        && (0, typeValidation_1.isFunction)(candidate.condition)
+        && (!candidate.args || Array.isArray(candidate.args)));
+}
+function isStringStripCondition(value) {
+    const candidate = value;
+    return ((0, typeValidation_1.isObject)(candidate)
+        && (0, typeValidation_1.isFunction)(candidate.condition)
+        && typeValidation_1.isUndefinedOr.array(candidate.args)
+        && typeValidation_1.isUndefinedOr.positiveInteger(candidate.max));
+}
+/**
+ * - {@link DEP_CleanStringOptions}
+ * @param value `any`
+ * @returns **`isCleanStringOptions`** `boolean`
+ * - **`true`** if the `value` is an object with at least one key in `['strip', 'case', 'pad', 'replace']` and no other keys,
+ * - **`false`** `otherwise`.
+ */
+function DEP_isCleanStringOptions(value) {
+    return (value && typeof value === 'object'
+        && (0, typeValidation_1.hasKeys)(value, ['strip', 'case', 'pad', 'replace'], false, true));
+}

package/dist/utils/regex/types/StringOptions.d.ts

@@ -1,6 +1,64 @@
 /**
  * @file src/utils/regex/types/StringOptions.ts
  */
+export declare const StringCaseEnum: {
+    readonly UPPER: "upper";
+    readonly LOWER: "lower";
+    readonly TITLE: "title";
+};
+export type StringCaseEnum = (typeof StringCaseEnum)[keyof typeof StringCaseEnum];
+export declare const StringPadEnum: {
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+    readonly BOTH: "both";
+};
+export type StringPadEnum = (typeof StringPadEnum)[keyof typeof StringPadEnum];
+export interface StringPadOptions {
+    maxLength: number;
+    /** `default` = `' '` (single space character) */
+    char?: string;
+    /** `default` = `'left'` (pad left side of string) */
+    side?: StringPadEnum;
+}
+export interface StringCondition {
+    condition: (s: string, ...args: any[]) => boolean;
+    args?: any[];
+}
+export type StringStripCondition = StringCondition & {
+    /** max number of times to strip char from one side */
+    max?: number;
+};
+export interface StringStripOptions {
+    /**
+     * `default` = `/\s+/`
+     * - will escape special characters if `char` is `string`
+     * */
+    char?: string | RegExp;
+    left?: StringStripCondition;
+    right?: StringStripCondition;
+}
+export interface StringCleanOptions {
+    strip?: StringStripOptions;
+    case?: StringCaseEnum;
+    pad?: StringPadOptions;
+    replace?: StringReplaceParams[];
+    useDefault?: boolean;
+}
+export type CleanStringOptions = StringCleanOptions;
+/**
+ * @typedefn **`StringReplaceOptions`**
+ * @property {StringReplaceParams[]} replacements - an array of objects containing `searchValue` and `replaceValue` properties
+ */
+export type StringReplaceOptions = StringReplaceParams[];
+/**
+ * @typedefn **`StringReplaceParams`**
+ * @property {string | RegExp} searchValue - the string or regular expression to search for in the string
+ * @property {string} replaceValue - the string to replace the `searchValue` with
+ */
+export type StringReplaceParams = {
+    searchValue: string | RegExp;
+    replaceValue: string;
+};
 /**
  * @reference {@link https://javascript.info/regexp-introduction}
  * @enum {string} **`RegExpFlagsEnum`**
@@ -22,10 +80,10 @@ export declare enum RegExpFlagsEnum {
 /**
  * @typedefn **`CleanStringOptions`**
  */
-export type CleanStringOptions = {
-    strip?: StringStripOptions;
-    case?: StringCaseOptions;
-    pad?: StringPadOptions;
+export type DEP_CleanStringOptions = {
+    strip?: DEP_StringStripOptions;
+    case?: DEP_StringCaseOptions;
+    pad?: DEP_StringPadOptions;
     replace?: StringReplaceOptions;
 };
 /**
@@ -34,7 +92,7 @@ export type CleanStringOptions = {
  * @property {boolean} [toLower] - `true` if the string should be converted to lower case
  * @property {boolean} [toTitle] - `true` if the string should be converted to title case, see {@link toTitleCase}
  */
-export type StringCaseOptions = {
+export type DEP_StringCaseOptions = {
     toUpper?: boolean;
     toLower?: boolean;
     toTitle?: boolean;
@@ -46,7 +104,7 @@ export type StringCaseOptions = {
  * @property {boolean} [padLeft] - `true` if the padding should be added to the left side of the string
  * @property {boolean} [padRight] - `true` if the padding should be added to the right side of the string
  */
-export type StringPadOptions = {
+export type DEP_StringPadOptions = {
     padLength: number;
     padChar?: string;
     padLeft?: boolean;
@@ -63,7 +121,7 @@ export type StringPadOptions = {
  * @property {any[]} [rightArgs] - arguments to pass to the `stripRightCondition` function
  * - if `stripRightCondition(s, rightArgs)` is `true` or `stripRightCondition` is `undefined` (i.e. no conditions need to be met to strip right), the right side of `s` is stripped of `char`
  */
-export type StringStripOptions = {
+export type DEP_StringStripOptions = {
     char: string;
     escape?: boolean;
     stripLeftCondition?: (s: string, ...args: any[]) => boolean;
@@ -71,17 +129,3 @@ export type StringStripOptions = {
     stripRightCondition?: (s: string, ...args: any[]) => boolean;
     rightArgs?: any[];
 };
-/**
- * @typedefn **`StringReplaceOptions`**
- * @property {StringReplaceParams[]} replacements - an array of objects containing `searchValue` and `replaceValue` properties
- */
-export type StringReplaceOptions = StringReplaceParams[];
-/**
- * @typedefn **`StringReplaceParams`**
- * @property {string | RegExp} searchValue - the string or regular expression to search for in the string
- * @property {string} replaceValue - the string to replace the `searchValue` with
- */
-export type StringReplaceParams = {
-    searchValue: string | RegExp;
-    replaceValue: string;
-};

package/dist/utils/regex/types/StringOptions.js

@@ -3,7 +3,17 @@
  * @file src/utils/regex/types/StringOptions.ts
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegExpFlagsEnum = void 0;
+exports.RegExpFlagsEnum = exports.StringPadEnum = exports.StringCaseEnum = void 0;
+exports.StringCaseEnum = {
+    UPPER: 'upper',
+    LOWER: 'lower',
+    TITLE: 'title',
+};
+exports.StringPadEnum = {
+    LEFT: 'left',
+    RIGHT: 'right',
+    BOTH: 'both'
+};
 /**
  * @reference {@link https://javascript.info/regexp-introduction}
  * @enum {string} **`RegExpFlagsEnum`**

package/dist/utils/regex/types/index.d.ts

@@ -2,4 +2,4 @@
  * @file src/utils/regex/types/index.ts
  */
 export * from "./StringOptions";
-export * from "./typeGuards";
+export * from "./StringOptions.TypeGuards";

package/dist/utils/regex/types/index.js

@@ -18,4 +18,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @file src/utils/regex/types/index.ts
  */
 __exportStar(require("./StringOptions"), exports);
-__exportStar(require("./typeGuards"), exports);
+__exportStar(require("./StringOptions.TypeGuards"), exports);

package/dist/utils/typeValidation.d.ts

@@ -29,11 +29,11 @@ export declare function isNullLike(value: any): value is '' | null | undefined |
 export declare function anyNull(...values: any[]): boolean;
 /**
  * @param value
- * @returns **`isNonEmptyArray`** `boolean` = `value is Array<any> & { length: number }`
+ * @returns **`isNonEmptyArray`** `boolean` = `value is Array<T> & { length: number }`
  * - **`true`** if `value` is an array and has at least one element,
  * - **`false`** otherwise.
  */
-export declare function isNonEmptyArray(value: any): value is Array<any> & {
+export declare function isNonEmptyArray<T = any>(value: any): value is Array<T> & {
     length: number;
 };
 /**
@@ -42,7 +42,7 @@ export declare function isNonEmptyArray(value: any): value is Array<any> & {
  * - **`true`** if `value` is an array and has no elements,
  * - **`false`** `otherwise`
  */
-export declare function isEmptyArray(value: any): value is Array<any> & {
+export declare function isEmptyArray<T = any>(value: any): value is Array<T> & {
     length: 0;
 };
 /**
@@ -113,11 +113,14 @@ export declare function areEquivalentObjects(objA: Record<string, any>, objB: Re
 export declare function isNumeric(value: any, requireInteger?: boolean, requireNonNegative?: boolean): value is string | number;
 /**
  * @param value `any`
+ * @param requireNonSpace `boolean (optional)` `default` = `false`
+ * - `if true` then `value.trim()` must not result in empty string
+ * - `if false` then allows for `value` to consist solely of whitespace characters
  * @returns **`isNonEmptyString`** `boolean`
- * - `true` `if` `value` is a non-empty string (not just whitespace),
+ * - `true` `if` `value` is a non-empty string
  * - `false` `otherwise`.
  */
-export declare function isNonEmptyString(value: any): value is string & {
+export declare function isNonEmptyString(value: any, requireNonSpace?: boolean): value is string & {
     length: number;
 };
 export declare function isPrimitiveValue(value: any): value is string | number | boolean | null | undefined;
@@ -144,25 +147,47 @@ export declare function isPositveInteger(value: any): value is number;
 export declare const isType: <T>(value: any, guard: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T;
 /**
  * - calls {@link isUndefinedOrNull}`(value)` which allows for value to be `undefined` or `null`
- * - use {@link isUndefinedOr} if you want value is `T | undefined`
+ * - use {@link isUndefinedOr} if you want `value is T | undefined`
  */
 export declare class isOptional {
     static type: <T>(value: any, guard: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T | undefined | null;
     /**
+     * - allows for empty array
      * @param value
-     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
-     * @returns
+     * @param elementGuard `function` checks that each element of array, when passed into this function, returns true
+     * - if not provided, then will only check that value is an array
+     * @param args `any[]` arguments that will be passed into `elementGuard` e.g. `elementGuard(value[i], ...args)`
      */
-    static string: (value: any, requireNonEmpty?: boolean) => value is string | undefined | null;
+    static array: <T>(value: any, elementGuard?: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T[] | undefined | null;
     /**
      * @param value
-     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
+     * @param requireNonSpace `boolean` `default` = `false`
+     * - `if` `true`, require that string have at least 1 non-whitespace character
      * @returns
      */
+    static string: (value: any, requireNonSpace?: boolean) => value is string | undefined | null;
+    /**
+     * @param value
+     * @param requireNonEmpty `boolean` `default` = `false` (if `true`, require that array have at least 1 element)
+     */
     static stringArray: (value: any, requireNonEmpty?: boolean) => value is string[] | undefined | null;
+    /**
+     * @param value `any`
+     * @param requireInteger `boolean` `default = false`
+     * @param requireNonNegative `boolean` `default = false`
+     * @returns **`isNumeric`** `value is string | number`
+     * - **`true`** `if` `value` is either a `number` or a `string` that can be casted to a `number`
+     * while also meeting the boolean parameter requirements
+     * - **`false`** `otherwise`
+     */
     static numeric: (value: any, requireInteger?: boolean, requireNonNegative?: boolean) => value is string | number | undefined | null;
     static number: (value: any, requireInteger?: boolean, requireNonNegative?: boolean) => value is number | undefined | null;
     static positiveInteger: (value: any) => value is number | undefined | null;
+    /**
+     * @param value
+     * @param requireNonNegative `boolean (optional)` `default` = `false`
+     * @param requireNonEmpty `boolean (optional)` `default` = `false`
+     */
     static integerArray: (value: any, requireNonNegative?: boolean, requireNonEmpty?: boolean) => value is number[] | undefined | null;
     static boolean: (value: any) => value is boolean | undefined | null;
     static function: (value: any) => value is Function | undefined | null;
@@ -170,20 +195,42 @@ export declare class isOptional {
 export declare class isUndefinedOr {
     static type: <T>(value: any, guard: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T | undefined;
     /**
+     * - allows for empty array
      * @param value
-     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
-     * @returns
+     * @param elementGuard `function` checks that each element of array, when passeed into this function, returns true
+     * - if not provided, then will only check that value is an array
+     * @param args `any[]` arguments that will be passed into  `elementGuard` e.g. `elementGuard(value[i], ...args)`
      */
-    static string: (value: any, requireNonEmpty?: boolean) => value is string | undefined;
+    static array: <T>(value: any, elementGuard?: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T[] | undefined;
     /**
      * @param value
-     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
-     * @returns
+     * @param requireNonEmpty `boolean` `default` = `false`
+     * - `if` `true`, require that string have at least 1 non-whitespace character
+     */
+    static string: (value: any, requireNonSpace?: boolean) => value is string | undefined;
+    /**
+     * @param value
+     * @param requireNonEmpty `boolean` `default` = `false`
+     * - `if` `true`, require that array have at least 1 element
      */
     static stringArray: (value: any, requireNonEmpty?: boolean) => value is string[] | undefined;
+    /**
+     * @param value `any`
+     * @param requireInteger `boolean` `default = false`
+     * @param requireNonNegative `boolean` `default = false`
+     * @returns **`isNumeric`** `value is string | number`
+     * - **`true`** `if` `value` is either a `number` or a `string` that can be casted to a `number`
+     * while also meeting the boolean parameter requirements
+     * - **`false`** `otherwise`
+     */
     static numeric: (value: any, requireInteger?: boolean, requireNonNegative?: boolean) => value is string | number | undefined;
     static number: (value: any, requireInteger?: boolean, requireNonNegative?: boolean) => value is number | undefined;
     static positiveInteger: (value: any) => value is number | undefined;
+    /**
+     * @param value
+     * @param requireNonNegative `boolean (optional)` `default` = `false`
+     * @param requireNonEmpty `boolean (optional)` `default` = `false`
+     */
     static integerArray: (value: any, requireNonNegative?: boolean, requireNonEmpty?: boolean) => value is number[] | undefined;
     static boolean: (value: any) => value is boolean | undefined;
     static function: (value: any) => value is Function | undefined;

package/dist/utils/typeValidation.js

@@ -74,7 +74,7 @@ function anyNull(...values) {
 }
 /**
  * @param value
- * @returns **`isNonEmptyArray`** `boolean` = `value is Array<any> & { length: number }`
+ * @returns **`isNonEmptyArray`** `boolean` = `value is Array<T> & { length: number }`
  * - **`true`** if `value` is an array and has at least one element,
  * - **`false`** otherwise.
  */
@@ -244,12 +244,18 @@ function isNumeric(value, requireInteger = false, requireNonNegative = false) {
 }
 /**
  * @param value `any`
+ * @param requireNonSpace `boolean (optional)` `default` = `false`
+ * - `if true` then `value.trim()` must not result in empty string
+ * - `if false` then allows for `value` to consist solely of whitespace characters
  * @returns **`isNonEmptyString`** `boolean`
- * - `true` `if` `value` is a non-empty string (not just whitespace),
+ * - `true` `if` `value` is a non-empty string
  * - `false` `otherwise`.
  */
-function isNonEmptyString(value) {
-    return typeof value === 'string' && value.trim() !== '';
+function isNonEmptyString(value, requireNonSpace = false) {
+    return (typeof value === 'string'
+        && (requireNonSpace
+            ? value.trim() !== ''
+            : value.length > 0));
 }
 function isPrimitiveValue(value) {
     if (value === null || value === undefined) {
@@ -299,7 +305,7 @@ const isType = (value, guard, ...args) => {
 exports.isType = isType;
 /**
  * - calls {@link isUndefinedOrNull}`(value)` which allows for value to be `undefined` or `null`
- * - use {@link isUndefinedOr} if you want value is `T | undefined`
+ * - use {@link isUndefinedOr} if you want `value is T | undefined`
  */
 class isOptional {
 }
@@ -308,21 +314,41 @@ isOptional.type = (value, guard, ...args) => {
     return isUndefinedOrNull(value) || (0, exports.isType)(value, guard, ...args);
 };
 /**
+ * - allows for empty array
  * @param value
- * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
- * @returns
+ * @param elementGuard `function` checks that each element of array, when passed into this function, returns true
+ * - if not provided, then will only check that value is an array
+ * @param args `any[]` arguments that will be passed into `elementGuard` e.g. `elementGuard(value[i], ...args)`
  */
-isOptional.string = (value, requireNonEmpty = true) => {
-    return isUndefinedOrNull(value) || requireNonEmpty ? isNonEmptyString(value) : typeof value === "string";
+isOptional.array = (value, elementGuard, ...args) => {
+    return isUndefinedOrNull(value) || (Array.isArray(value)
+        && (!elementGuard || value.every(v => elementGuard(v, ...args))));
 };
 /**
  * @param value
- * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
+ * @param requireNonSpace `boolean` `default` = `false`
+ * - `if` `true`, require that string have at least 1 non-whitespace character
  * @returns
  */
-isOptional.stringArray = (value, requireNonEmpty = true) => {
+isOptional.string = (value, requireNonSpace = false) => {
+    return isUndefinedOrNull(value) || isNonEmptyString(value, requireNonSpace);
+};
+/**
+ * @param value
+ * @param requireNonEmpty `boolean` `default` = `false` (if `true`, require that array have at least 1 element)
+ */
+isOptional.stringArray = (value, requireNonEmpty = false) => {
     return isUndefinedOrNull(value) || isStringArray(value, requireNonEmpty);
 };
+/**
+ * @param value `any`
+ * @param requireInteger `boolean` `default = false`
+ * @param requireNonNegative `boolean` `default = false`
+ * @returns **`isNumeric`** `value is string | number`
+ * - **`true`** `if` `value` is either a `number` or a `string` that can be casted to a `number`
+ * while also meeting the boolean parameter requirements
+ * - **`false`** `otherwise`
+ */
 isOptional.numeric = (value, requireInteger = false, requireNonNegative = false) => {
     return isUndefinedOrNull(value) || isNumeric(value, requireInteger, requireNonNegative);
 };
@@ -333,7 +359,12 @@ isOptional.number = (value, requireInteger = false, requireNonNegative = false)
 isOptional.positiveInteger = (value) => {
     return (isUndefinedOrNull(value) || isPositveInteger(value));
 };
-isOptional.integerArray = (value, requireNonNegative = false, requireNonEmpty = true) => {
+/**
+ * @param value
+ * @param requireNonNegative `boolean (optional)` `default` = `false`
+ * @param requireNonEmpty `boolean (optional)` `default` = `false`
+ */
+isOptional.integerArray = (value, requireNonNegative = false, requireNonEmpty = false) => {
     return isUndefinedOrNull(value) || isIntegerArray(value, requireNonNegative, requireNonEmpty);
 };
 isOptional.boolean = (value) => {
@@ -349,21 +380,41 @@ isUndefinedOr.type = (value, guard, ...args) => {
     return isUndefined(value) || (0, exports.isType)(value, guard, ...args);
 };
 /**
+ * - allows for empty array
  * @param value
- * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
- * @returns
+ * @param elementGuard `function` checks that each element of array, when passeed into this function, returns true
+ * - if not provided, then will only check that value is an array
+ * @param args `any[]` arguments that will be passed into  `elementGuard` e.g. `elementGuard(value[i], ...args)`
  */
-isUndefinedOr.string = (value, requireNonEmpty = true) => {
-    return isUndefined(value) || requireNonEmpty ? isNonEmptyString(value) : typeof value === "string";
+isUndefinedOr.array = (value, elementGuard, ...args) => {
+    return isUndefined(value) || (Array.isArray(value)
+        && (!elementGuard || value.every(v => elementGuard(v, ...args))));
 };
 /**
  * @param value
- * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
- * @returns
+ * @param requireNonEmpty `boolean` `default` = `false`
+ * - `if` `true`, require that string have at least 1 non-whitespace character
+ */
+isUndefinedOr.string = (value, requireNonSpace = false) => {
+    return isUndefined(value) || isNonEmptyString(value, requireNonSpace);
+};
+/**
+ * @param value
+ * @param requireNonEmpty `boolean` `default` = `false`
+ * - `if` `true`, require that array have at least 1 element
  */
-isUndefinedOr.stringArray = (value, requireNonEmpty = true) => {
+isUndefinedOr.stringArray = (value, requireNonEmpty = false) => {
     return isUndefined(value) || isStringArray(value, requireNonEmpty);
 };
+/**
+ * @param value `any`
+ * @param requireInteger `boolean` `default = false`
+ * @param requireNonNegative `boolean` `default = false`
+ * @returns **`isNumeric`** `value is string | number`
+ * - **`true`** `if` `value` is either a `number` or a `string` that can be casted to a `number`
+ * while also meeting the boolean parameter requirements
+ * - **`false`** `otherwise`
+ */
 isUndefinedOr.numeric = (value, requireInteger = false, requireNonNegative = false) => {
     return isUndefined(value) || isNumeric(value, requireInteger, requireNonNegative);
 };
@@ -374,7 +425,12 @@ isUndefinedOr.number = (value, requireInteger = false, requireNonNegative = fals
 isUndefinedOr.positiveInteger = (value) => {
     return (isUndefined(value) || isPositveInteger(value));
 };
-isUndefinedOr.integerArray = (value, requireNonNegative = false, requireNonEmpty = true) => {
+/**
+ * @param value
+ * @param requireNonNegative `boolean (optional)` `default` = `false`
+ * @param requireNonEmpty `boolean (optional)` `default` = `false`
+ */
+isUndefinedOr.integerArray = (value, requireNonNegative = false, requireNonEmpty = false) => {
     return isUndefined(value) || isIntegerArray(value, requireNonNegative, requireNonEmpty);
 };
 isUndefinedOr.boolean = (value) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typeshi",
-    "version": "1.7.19",
+    "version": "2.0.1",
     "description": "TypeScript utility modules",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -24,20 +24,21 @@
     "author": "Andrew Garwood",
     "license": "MIT",
     "dependencies": {
-        "rimraf": "^5.0.0",
-        "ts-jest": "^29.3.4",
-        "ts-node": "^10.9.2",
-        "tslog": "^4.9.3",
-        "lodash": "^4.17.21",
         "addresser": "^1.1.20",
         "csv-parser": "^3.2.0",
         "fastest-levenshtein": "^1.0.16",
+        "lodash": "^4.17.21",
+        "rimraf": "^5.0.0",
+        "ts-node": "^10.9.2",
+        "tslog": "^4.9.3",
         "xlsx": "https://cdn.sheetjs.com/xlsx-latest/xlsx-latest.tgz"
     },
     "devDependencies": {
+        "@jest/globals": "^30.2.0",
         "@types/jest": "^29.5.14",
         "@types/node": "^22.15.15",
         "jest": "^29.7.0",
+        "ts-jest": "^29.4.6",
         "tsconfig-paths": "^4.2.0",
         "typescript": "^5.0.0"
     },

package/dist/utils/regex/types/typeGuards.d.ts

@@ -1,12 +0,0 @@
-/**
- * @file src/utils/regex/types/typeGuards.ts
- */
-import { CleanStringOptions } from ".";
-/**
- * - {@link CleanStringOptions}
- * @param value `any`
- * @returns **`isCleanStringOptions`** `boolean`
- * - **`true`** if the `value` is an object with at least one key in `['strip', 'case', 'pad', 'replace']` and no other keys,
- * - **`false`** `otherwise`.
- */
-export declare function isCleanStringOptions(value: any): value is CleanStringOptions;

package/dist/utils/regex/types/typeGuards.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCleanStringOptions = isCleanStringOptions;
-const typeValidation_1 = require("../../typeValidation");
-/**
- * - {@link CleanStringOptions}
- * @param value `any`
- * @returns **`isCleanStringOptions`** `boolean`
- * - **`true`** if the `value` is an object with at least one key in `['strip', 'case', 'pad', 'replace']` and no other keys,
- * - **`false`** `otherwise`.
- */
-function isCleanStringOptions(value) {
-    return (value && typeof value === 'object'
-        && (0, typeValidation_1.hasKeys)(value, ['strip', 'case', 'pad', 'replace'], false, true));
-}