typeshi 1.7.2 → 1.7.4

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

@@ -8,16 +8,17 @@
  * @property {string} LOCALE - Local format (YYYY-MM-DDTHH:mm:ss.sssZ)
  * @property {string} UNIX - Unix format (milliseconds since epoch)
  */
-export declare enum DateFormatEnum {
-    /**ISO format (YYYY-MM-DDTHH:mm:ss.sssZ) */
-    ISO = "ISO",
-    /**UTC format (YYYY-MM-DDTHH:mm:ss.sssZ) */
-    UTC = "UTC",
-    /**Local format (YYYY-MM-DDTHH:mm:ss.sssZ) */
-    LOCALE = "LOCALE",
+export declare const DateFormatEnum: {
+    /**ISO format (e.g., "2025-04-16T00:00:00.000Z") */
+    readonly ISO: "ISO";
+    /**UTC format (e.g., "Sun, 31 Dec 1899 00:00:00 GMT") */
+    readonly UTC: "UTC";
+    /**Locale format (e.g., "4/21/2025, 4:22:45 PM") */
+    readonly LOCALE: "LOCALE";
     /** ```/\d{13}/``` if milliseconds, ```/\d{10}/``` if seconds */
-    UNIX = "UNIX"
-}
+    readonly UNIX: "UNIX";
+};
+export type DateFormatEnum = (typeof DateFormatEnum)[keyof typeof DateFormatEnum];
 /**
  * @enum {string} **`TimeUnitEnum`**
  * @property {string} MILLISECONDS - milliseconds
@@ -26,28 +27,40 @@ export declare enum DateFormatEnum {
  * @property {string} HOURS - hours
  * @property {string} DAYS - days
  */
-export declare enum TimeUnitEnum {
-    MILLISECONDS = "milliseconds",
-    SECONDS = "seconds",
-    MINUTES = "minutes",
-    HOURS = "hours",
-    DAYS = "days"
-}
+export declare const TimeUnitEnum: {
+    readonly MILLISECONDS: "milliseconds";
+    readonly SECONDS: "seconds";
+    readonly MINUTES: "minutes";
+    readonly HOURS: "hours";
+    readonly DAYS: "days";
+};
+export type TimeUnitEnum = (typeof TimeUnitEnum)[keyof typeof TimeUnitEnum];
 /**
- * `re = /^\d{4}-\d{2}-\d{2}$/`
- * @description Regular expression pattern for ISO date format (YYYY-MM-DD)
+ * `re = /\d{4}(-|\/)\d{2}(-|\/)\d{2}(T\d{2}:\d{2}:\d{2}(.\d{3})Z)?/`
+ * @description Regular expression pattern for ISO date format (YYYY-MM-DD or YYYY/MM/DD) + optional time (THH:mm:ss.sssZ)
  * @example "2025-04-16"
  * */
 export declare const ISO_PATTERN: RegExp;
+/**
+ * `re = /(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4}( \d{2}:\d{2}:\d{2} GMT)?/`
+ * @description Regular expression pattern for UTC date format (e.g., "Sun, 31 Dec 1899 00:00:00 GMT")
+ */
+export declare const UTC_PATTERN: RegExp;
+/**
+ * `re = /\d{1,2}[-/]\d{1,2}[-/]\d{4}(, \d{1,2}:\d{2}:\d{2} (AM|PM))?/`
+ * @description Regular expression pattern for Locale date format (M/D/YYYY or M-D-YYYY) + optional time (hh:mm:ss AM/PM)
+ * @example "4/21/2025, 4:22:45 PM"
+ */
+export declare const LOCALE_PATTERN: RegExp;
 /**
  * - defaultValue: string = `"en-US"`
- * @description set as first param, locales, in {@link Date}.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)
+ * @description set as first param, locales, in {@link Date}`.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)`
  * @reference ~\node_modules\typescript\lib\lib.es2020.date.d.ts @see {@link Date}
  */
 export declare const DEFAULT_LOCALE = "en-US";
 /**
  * - defaultValue: string = `"America/Los_Angeles"`
- * @description set as second param, options, in {@link Date}.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)
+ * @description set as second param, options, in {@link Date}`.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)`
  * @reference ~\node_modules\typescript\lib\lib.es2020.date.d.ts @see {@link Date}
  */
 export declare const DEFAULT_TIMEZONE = "America/Los_Angeles";
@@ -81,7 +94,7 @@ export declare function getUnixTimestampFromISO(dateString: string): number | nu
  * @param dateStr Date string in locale format (e.g., '4/21/2025, 4:22:45 PM')
  * @returns {Date} **`date`** {@link Date} object
  */
-export declare function parseLocaleStringToDate(dateStr: string): Date;
+export declare function localeStringToDate(dateStr: string): Date;
 /**
  * @description Gets the current date and time in Pacific Time in Locale format
  * @returns {string} The current date and time in Pacific Time in Locale format
@@ -96,19 +109,57 @@ export declare function getCurrentPacificTime(): string;
 export declare function toPacificTime(initialDateString: string): string;
 export declare const Milliseconds: {
     readonly from: {
+        /**
+         * @param n `number`
+         * @returns `n * (1000 * 60 * 60 * 24)` number of milliseconds in `n` days
+         */
+        readonly days: (n: number) => number;
+        /**
+         * @param n `number`
+         * @returns `n * (1000 * 60 * 60)` number of milliseconds in `n` hours
+         */
         readonly hours: (n: number) => number;
+        /**
+         * @param n `number`
+         * @returns `n * (1000 * 60)` number of milliseconds in `n` minutes
+         */
         readonly minutes: (n: number) => number;
+        /**
+         * @param n `number`
+         * @returns `n * (1000)` number of milliseconds in `n` seconds
+         */
         readonly seconds: (n: number) => number;
         /**
          * @param d `Date` object
-         * @returns `number` milliseconds since epoch
+         * @returns `number` = `d.getTime()` = milliseconds since epoch
          */
         readonly date: (d: Date) => number;
-        readonly localeString: (s: string) => number | null;
+        /**
+         * @param s `string` date string to pass into Date Constructor (e.g. ISO, UTC, Locale, etc.)
+         * @returns `number` milliseconds since epoch or `null` if invalid (i.e. Date constructor can't parse it)
+         */
+        readonly string: (s: string) => number | null;
     };
     readonly to: {
+        /**
+         * @param n `number`
+         * @returns `number` days in `n` milliseconds
+         */
+        readonly days: (n: number) => number;
+        /**
+         * @param n `number`
+         * @returns `number` hours in `n` milliseconds
+         */
         readonly hours: (n: number) => number;
+        /**
+         * @param n `number`
+         * @returns `number` minutes in `n` milliseconds
+         */
         readonly minutes: (n: number) => number;
+        /**
+         * @param n `number`
+         * @returns `number` seconds in `n` milliseconds
+         */
         readonly seconds: (n: number) => number;
         /**
          * interprets `n` as milliseconds since epoch
@@ -117,11 +168,12 @@ export declare const Milliseconds: {
          */
         readonly date: (n: number) => Date;
         /**
-         * @param n `number` milliseconds since epoch
-         * @param locale `string` default = `'en-US'`
-         * @param timeZone `string` default = `'America/Los_Angeles'`
-         * @returns `string` locale date string
+         * @param n `number`
+         * @param format {@link DateFormatEnum} default = {@link DateFormatEnum.ISO}
+         * @param locale `string` default = `'en-US'` (only used if format = {@link DateFormatEnum.LOCALE})
+         * @param timeZone `string` default = `'America/Los_Angeles'` (only used if format = {@link DateFormatEnum.LOCALE})
+         * @returns `string` formatted date string or empty string if error
          */
-        readonly localeString: (n: number, locale?: string, timeZone?: string) => string;
+        readonly string: (n: number, format?: DateFormatEnum, locale?: string, timeZone?: string) => string;
     };
 };

package/dist/utils/io/dateTime.js

@@ -3,11 +3,11 @@
  * @file src/utils/io/dateTime.ts
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Milliseconds = exports.DEFAULT_TIMEZONE = exports.DEFAULT_LOCALE = exports.ISO_PATTERN = exports.TimeUnitEnum = exports.DateFormatEnum = void 0;
+exports.Milliseconds = exports.DEFAULT_TIMEZONE = exports.DEFAULT_LOCALE = exports.LOCALE_PATTERN = exports.UTC_PATTERN = exports.ISO_PATTERN = exports.TimeUnitEnum = exports.DateFormatEnum = void 0;
 exports.getDateFromUnixTimestamp = getDateFromUnixTimestamp;
 exports.calculateDifferenceOfDateStrings = calculateDifferenceOfDateStrings;
 exports.getUnixTimestampFromISO = getUnixTimestampFromISO;
-exports.parseLocaleStringToDate = parseLocaleStringToDate;
+exports.localeStringToDate = localeStringToDate;
 exports.getCurrentPacificTime = getCurrentPacificTime;
 exports.toPacificTime = toPacificTime;
 /**
@@ -17,18 +17,16 @@ exports.toPacificTime = toPacificTime;
  * @property {string} LOCALE - Local format (YYYY-MM-DDTHH:mm:ss.sssZ)
  * @property {string} UNIX - Unix format (milliseconds since epoch)
  */
-var DateFormatEnum;
-(function (DateFormatEnum) {
-    /**ISO format (YYYY-MM-DDTHH:mm:ss.sssZ) */
-    DateFormatEnum["ISO"] = "ISO";
-    /**UTC format (YYYY-MM-DDTHH:mm:ss.sssZ) */
-    DateFormatEnum["UTC"] = "UTC";
-    /**Local format (YYYY-MM-DDTHH:mm:ss.sssZ) */
-    DateFormatEnum["LOCALE"] = "LOCALE";
+exports.DateFormatEnum = {
+    /**ISO format (e.g., "2025-04-16T00:00:00.000Z") */
+    ISO: 'ISO',
+    /**UTC format (e.g., "Sun, 31 Dec 1899 00:00:00 GMT") */
+    UTC: 'UTC',
+    /**Locale format (e.g., "4/21/2025, 4:22:45 PM") */
+    LOCALE: 'LOCALE',
     /** ```/\d{13}/``` if milliseconds, ```/\d{10}/``` if seconds */
-    DateFormatEnum["UNIX"] = "UNIX";
-})(DateFormatEnum || (exports.DateFormatEnum = DateFormatEnum = {}));
-;
+    UNIX: 'UNIX'
+};
 /**
  * @enum {string} **`TimeUnitEnum`**
  * @property {string} MILLISECONDS - milliseconds
@@ -37,29 +35,39 @@ var DateFormatEnum;
  * @property {string} HOURS - hours
  * @property {string} DAYS - days
  */
-var TimeUnitEnum;
-(function (TimeUnitEnum) {
-    TimeUnitEnum["MILLISECONDS"] = "milliseconds";
-    TimeUnitEnum["SECONDS"] = "seconds";
-    TimeUnitEnum["MINUTES"] = "minutes";
-    TimeUnitEnum["HOURS"] = "hours";
-    TimeUnitEnum["DAYS"] = "days";
-})(TimeUnitEnum || (exports.TimeUnitEnum = TimeUnitEnum = {}));
+exports.TimeUnitEnum = {
+    MILLISECONDS: 'milliseconds',
+    SECONDS: 'seconds',
+    MINUTES: 'minutes',
+    HOURS: 'hours',
+    DAYS: 'days'
+};
 /**
- * `re = /^\d{4}-\d{2}-\d{2}$/`
- * @description Regular expression pattern for ISO date format (YYYY-MM-DD)
+ * `re = /\d{4}(-|\/)\d{2}(-|\/)\d{2}(T\d{2}:\d{2}:\d{2}(.\d{3})Z)?/`
+ * @description Regular expression pattern for ISO date format (YYYY-MM-DD or YYYY/MM/DD) + optional time (THH:mm:ss.sssZ)
  * @example "2025-04-16"
  * */
-exports.ISO_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+exports.ISO_PATTERN = /\d{4}[-/]\d{2}[-/]\d{2}(T\d{2}:\d{2}:\d{2}(.\d{3})Z)?/;
+/**
+ * `re = /(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4}( \d{2}:\d{2}:\d{2} GMT)?/`
+ * @description Regular expression pattern for UTC date format (e.g., "Sun, 31 Dec 1899 00:00:00 GMT")
+ */
+exports.UTC_PATTERN = /(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4}( \d{2}:\d{2}:\d{2} GMT)?/;
+/**
+ * `re = /\d{1,2}[-/]\d{1,2}[-/]\d{4}(, \d{1,2}:\d{2}:\d{2} (AM|PM))?/`
+ * @description Regular expression pattern for Locale date format (M/D/YYYY or M-D-YYYY) + optional time (hh:mm:ss AM/PM)
+ * @example "4/21/2025, 4:22:45 PM"
+ */
+exports.LOCALE_PATTERN = /\d{1,2}[-/]\d{1,2}[-/]\d{4}(, \d{1,2}:\d{2}:\d{2} (AM|PM))?/; // e.g., 4/21/2025, 4:22:45 PM
 /**
  * - defaultValue: string = `"en-US"`
- * @description set as first param, locales, in {@link Date}.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)
+ * @description set as first param, locales, in {@link Date}`.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)`
  * @reference ~\node_modules\typescript\lib\lib.es2020.date.d.ts @see {@link Date}
  */
 exports.DEFAULT_LOCALE = 'en-US';
 /**
  * - defaultValue: string = `"America/Los_Angeles"`
- * @description set as second param, options, in {@link Date}.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)
+ * @description set as second param, options, in {@link Date}`.toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions)`
  * @reference ~\node_modules\typescript\lib\lib.es2020.date.d.ts @see {@link Date}
  */
 exports.DEFAULT_TIMEZONE = 'America/Los_Angeles';
@@ -88,13 +96,13 @@ function getDateFromUnixTimestamp(unixTimestamp, dateFormat) {
         return null;
     }
     const date = new Date(unixTimestamp);
-    if (dateFormat === DateFormatEnum.ISO) {
+    if (dateFormat === exports.DateFormatEnum.ISO) {
         return date.toISOString();
     }
-    else if (dateFormat === DateFormatEnum.UTC) {
+    else if (dateFormat === exports.DateFormatEnum.UTC) {
         return date.toUTCString();
     }
-    else if (dateFormat === DateFormatEnum.LOCALE) {
+    else if (dateFormat === exports.DateFormatEnum.LOCALE) {
         return date.toLocaleString(exports.DEFAULT_LOCALE, { timeZone: exports.DEFAULT_TIMEZONE });
     }
     console.error('Invalid date format specified. Use DateFormatEnum.ISO, DateFormatEnum.UTC, or DateFormatEnum.LOCALE');
@@ -109,23 +117,23 @@ function getDateFromUnixTimestamp(unixTimestamp, dateFormat) {
  * @description Calculates the difference between two date strings in the specified unit of time. Subtracts ds1 from ds2.
  * @returns **`difference`** `number | null` The difference between the two date strings in the specified {@link TimeUnitEnum} unit, or `null` if an error occurs
  */
-function calculateDifferenceOfDateStrings(ds1, ds2 = getCurrentPacificTime(), unit = TimeUnitEnum.MILLISECONDS, absoluteDifference = true) {
+function calculateDifferenceOfDateStrings(ds1, ds2 = getCurrentPacificTime(), unit = exports.TimeUnitEnum.MILLISECONDS, absoluteDifference = true) {
     const date1 = new Date(ds1);
     const date2 = new Date(ds2);
     const diffInMs = absoluteDifference
         ? Math.abs(date2.getTime() - date1.getTime())
         : date2.getTime() - date1.getTime();
     switch (unit) {
-        case TimeUnitEnum.MILLISECONDS:
+        case exports.TimeUnitEnum.MILLISECONDS:
             return diffInMs;
-        case TimeUnitEnum.SECONDS:
-            return Math.floor(diffInMs / 1000);
-        case TimeUnitEnum.MINUTES:
-            return Math.floor(diffInMs / (1000 * 60));
-        case TimeUnitEnum.HOURS:
-            return Math.floor(diffInMs / (1000 * 60 * 60));
-        case TimeUnitEnum.DAYS:
-            return Math.floor(diffInMs / (1000 * 60 * 60 * 24));
+        case exports.TimeUnitEnum.SECONDS:
+            return exports.Milliseconds.from.seconds(diffInMs);
+        case exports.TimeUnitEnum.MINUTES:
+            return exports.Milliseconds.from.minutes(diffInMs);
+        case exports.TimeUnitEnum.HOURS:
+            return exports.Milliseconds.from.hours(diffInMs);
+        case exports.TimeUnitEnum.DAYS:
+            return exports.Milliseconds.from.days(diffInMs);
         default:
             console.error('Invalid time unit specified. Use TimeUnitEnum.MILLISECONDS, TimeUnitEnum.SECONDS, TimeUnitEnum.MINUTES, TimeUnitEnum.HOURS, or TimeUnitEnum.DAYS');
             return null;
@@ -160,7 +168,7 @@ function getUnixTimestampFromISO(dateString) {
  * @param dateStr Date string in locale format (e.g., '4/21/2025, 4:22:45 PM')
  * @returns {Date} **`date`** {@link Date} object
  */
-function parseLocaleStringToDate(dateStr) {
+function localeStringToDate(dateStr) {
     try {
         const [datePart, timeWithPeriod] = dateStr.split(', ');
         const [month, day, year] = datePart.split('/').map(Number);
@@ -177,7 +185,7 @@ function parseLocaleStringToDate(dateStr) {
         return new Date(year, month - 1, day, hours, minutes, seconds);
     }
     catch (error) {
-        throw new Error(`Failed to parse date string: ${dateStr}. Expected format: 'M/D/YYYY, h:mm:ss AM/PM'`);
+        throw new Error(`Failed to parse date string: '${dateStr}'. Expected format: 'MM/DD/YYYY, hh:mm:ss AM/PM'`);
     }
 }
 /**
@@ -202,40 +210,85 @@ function toPacificTime(initialDateString) {
 }
 exports.Milliseconds = {
     from: {
+        /**
+         * @param n `number`
+         * @returns `n * (1000 * 60 * 60 * 24)` number of milliseconds in `n` days
+         */
+        days: (n) => {
+            return n * (1000 * 60 * 60 * 24);
+        },
+        /**
+         * @param n `number`
+         * @returns `n * (1000 * 60 * 60)` number of milliseconds in `n` hours
+         */
         hours: (n) => {
             return n * (1000 * 60 * 60);
         },
+        /**
+         * @param n `number`
+         * @returns `n * (1000 * 60)` number of milliseconds in `n` minutes
+         */
         minutes: (n) => {
             return n * (1000 * 60);
         },
+        /**
+         * @param n `number`
+         * @returns `n * (1000)` number of milliseconds in `n` seconds
+         */
         seconds: (n) => {
             return n * (1000);
         },
         /**
          * @param d `Date` object
-         * @returns `number` milliseconds since epoch
+         * @returns `number` = `d.getTime()` = milliseconds since epoch
          */
         date: (d) => {
             return d.getTime();
         },
-        localeString: (s) => {
+        /**
+         * @param s `string` date string to pass into Date Constructor (e.g. ISO, UTC, Locale, etc.)
+         * @returns `number` milliseconds since epoch or `null` if invalid (i.e. Date constructor can't parse it)
+         */
+        string: (s) => {
             try {
-                const date = parseLocaleStringToDate(s);
+                const date = new Date(s);
+                if (isNaN(date.getTime())) {
+                    throw new Error(`Invalid date string: '${s}'`);
+                }
                 return date.getTime();
             }
             catch (error) {
-                console.error(error);
+                console.error(`Failed to parse date string: '${s}'`, error);
                 return null;
             }
-        }
+        },
     },
     to: {
+        /**
+         * @param n `number`
+         * @returns `number` days in `n` milliseconds
+         */
+        days: (n) => {
+            return n / (1000 * 60 * 60 * 24);
+        },
+        /**
+         * @param n `number`
+         * @returns `number` hours in `n` milliseconds
+         */
         hours: (n) => {
             return n / (1000 * 60 * 60);
         },
+        /**
+         * @param n `number`
+         * @returns `number` minutes in `n` milliseconds
+         */
         minutes: (n) => {
             return n / (1000 * 60);
         },
+        /**
+         * @param n `number`
+         * @returns `number` seconds in `n` milliseconds
+         */
         seconds: (n) => {
             return n / (1000);
         },
@@ -248,14 +301,29 @@ exports.Milliseconds = {
             return new Date(n);
         },
         /**
-         * @param n `number` milliseconds since epoch
-         * @param locale `string` default = `'en-US'`
-         * @param timeZone `string` default = `'America/Los_Angeles'`
-         * @returns `string` locale date string
+         * @param n `number`
+         * @param format {@link DateFormatEnum} default = {@link DateFormatEnum.ISO}
+         * @param locale `string` default = `'en-US'` (only used if format = {@link DateFormatEnum.LOCALE})
+         * @param timeZone `string` default = `'America/Los_Angeles'` (only used if format = {@link DateFormatEnum.LOCALE})
+         * @returns `string` formatted date string or empty string if error
          */
-        localeString: (n, locale = exports.DEFAULT_LOCALE, timeZone = exports.DEFAULT_TIMEZONE) => {
+        string: (n, format = exports.DateFormatEnum.ISO, locale = exports.DEFAULT_LOCALE, timeZone = exports.DEFAULT_TIMEZONE) => {
             const date = new Date(n);
-            return date.toLocaleString(locale, { timeZone });
-        }
+            if (isNaN(date.getTime())) {
+                console.error(`Invalid milliseconds value: '${n}'`);
+                return ``;
+            }
+            switch (format) {
+                case exports.DateFormatEnum.ISO:
+                    return date.toISOString();
+                case exports.DateFormatEnum.UTC:
+                    return date.toUTCString();
+                case exports.DateFormatEnum.LOCALE:
+                    return date.toLocaleString(locale, { timeZone });
+                default:
+                    console.error(`Invalid date format specified: '${format}'.`, `Use DateFormatEnum.ISO, DateFormatEnum.UTC, or DateFormatEnum.LOCALE`);
+                    return ``;
+            }
+        },
     },
 };

package/dist/utils/typeValidation.d.ts

@@ -137,11 +137,29 @@ export declare function isInteger(value: any, requireNonNegative?: boolean): val
  * @returns **`isObject`** `boolean` `value is Record<string, any>`
  */
 export declare function isObject(value: any, requireNonEmpty?: boolean, requireNonArray?: boolean): value is Record<string, any>;
+export declare const isOptional: {
+    string: (value: any) => value is string | undefined;
+    stringArray: (value: any) => value is string[] | undefined;
+    numeric: (value: any, requireInteger?: boolean, requireNonNegative?: boolean) => value is string | number | undefined;
+    number: (value: any, requireInteger?: boolean, requireNonNegative?: boolean) => value is number | undefined;
+    integerArray: (value: any, requireNonNegative?: boolean) => value is number[] | undefined;
+};
 /**
- * isBoolean is may be unnecessary, but added for completeness
+ * these may be unnecessary, but added for completeness
  */
 /**
  * @param value `any`
  * @returns **`isBoolean`** `boolean`
  */
 export declare function isBoolean(value: any): value is boolean;
+/**
+ * @param value `any`
+ * @returns **`isFunction`** `boolean`
+ */
+export declare function isFunction(value: any): value is Function;
+/**
+ * - passing in `null` returns `false`
+ * @param value `any`
+ * @returns **`isUndefined`** `boolean` `return value === undefined`
+ */
+export declare function isUndefined(value: any): value is undefined;

package/dist/utils/typeValidation.js

@@ -3,7 +3,7 @@
  * @file src/utils/typeValidation.ts
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmpty = void 0;
+exports.isOptional = exports.isEmpty = void 0;
 exports.isNullLike = isNullLike;
 exports.anyNull = anyNull;
 exports.isNonEmptyArray = isNonEmptyArray;
@@ -19,6 +19,8 @@ exports.isPrimitiveValue = isPrimitiveValue;
 exports.isInteger = isInteger;
 exports.isObject = isObject;
 exports.isBoolean = isBoolean;
+exports.isFunction = isFunction;
+exports.isUndefined = isUndefined;
 const index_1 = require("./regex/index");
 /**
  * - alias for {@link isNullLike}
@@ -279,8 +281,26 @@ function isObject(value, requireNonEmpty = true, requireNonArray = true) {
         && (requireNonArray ? !Array.isArray(value) : true)
         && (requireNonEmpty ? Object.keys(value).length > 0 : true));
 }
+exports.isOptional = {
+    string: (value) => {
+        return isUndefined(value) || typeof value === 'string';
+    },
+    stringArray: (value) => {
+        return isUndefined(value) || isStringArray(value);
+    },
+    numeric: (value, requireInteger = false, requireNonNegative = false) => {
+        return isUndefined(value) || isNumeric(value, requireInteger, requireNonNegative);
+    },
+    number: (value, requireInteger = false, requireNonNegative = false) => {
+        return isUndefined(value) || (isNumeric(value, requireInteger, requireNonNegative)
+            && typeof value === 'number');
+    },
+    integerArray: (value, requireNonNegative = false) => {
+        return isUndefined(value) || isIntegerArray(value, requireNonNegative);
+    }
+};
 /**
- * isBoolean is may be unnecessary, but added for completeness
+ * these may be unnecessary, but added for completeness
  */
 /**
  * @param value `any`
@@ -289,3 +309,18 @@ function isObject(value, requireNonEmpty = true, requireNonArray = true) {
 function isBoolean(value) {
     return (typeof value === 'boolean');
 }
+/**
+ * @param value `any`
+ * @returns **`isFunction`** `boolean`
+ */
+function isFunction(value) {
+    return (typeof value === 'function');
+}
+/**
+ * - passing in `null` returns `false`
+ * @param value `any`
+ * @returns **`isUndefined`** `boolean` `return value === undefined`
+ */
+function isUndefined(value) {
+    return value === undefined;
+}

package/package.json

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