typeshi 1.7.9 → 1.7.11

package/dist/utils/typeValidation.d.ts

@@ -47,21 +47,24 @@ export declare function isEmptyArray(value: any): value is Array<any> & {
 };
 /**
  * @param value `any`
+ * @param requireNonNegative `boolean` `default = false`
+ * @param requireNonEmpty `boolean` `default = true`
+ * - `if` `true` then `value` must be array with at least 1 element
+ * - `if` `false` then `value` can be empty array
  * @returns **`isIntegerArray`** `boolean` = `value is Array<number> & { length: number }`
- * - **`true`** if `value` is an array with `length > 0` and each of its elements is an `integer`
- * - **`false`** `otherwise`
  */
-export declare function isIntegerArray(value: any, requireNonNegative?: boolean): value is Array<number> & {
+export declare function isIntegerArray(value: any, requireNonNegative?: boolean, requireNonEmpty?: boolean): value is Array<number> & {
     length: number;
 };
 /**
  * @consideration add param to allow for empty strings?
  * @param value `any`
+ * @param requireNonEmpty `boolean` `default = true`
+ * - `if` `true` then `value` must be array with at least 1 element
+ * - `if` `false` then `value` can be empty array
  * @returns **`isStringArray`** `boolean` = `value is Array<string> & { length: number }`
- * - **`true`** if `value` is an array with `length > 0` and each of its elements is a **non-empty** `string`
- * - **`false`** `otherwise`
  */
-export declare function isStringArray(value: any): value is Array<string> & {
+export declare function isStringArray(value: any, requireNonEmpty?: boolean): value is Array<string> & {
     length: number;
 };
 /**
@@ -147,15 +150,20 @@ export declare class isOptional {
     static type: <T>(value: any, guard: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T | undefined | null;
     /**
      * @param value
-     * @param requireNonEmpty `bolean` `default` = `true`
+     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
      * @returns
      */
     static string: (value: any, requireNonEmpty?: boolean) => value is string | undefined | null;
-    static stringArray: (value: any) => value is string[] | undefined | null;
+    /**
+     * @param value
+     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
+     * @returns
+     */
+    static stringArray: (value: any, requireNonEmpty?: boolean) => value is string[] | undefined | null;
     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;
-    static integerArray: (value: any, requireNonNegative?: boolean) => value is number[] | undefined | null;
+    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;
 }
@@ -163,15 +171,20 @@ export declare class isUndefinedOr {
     static type: <T>(value: any, guard: (v: any, ...args: any[]) => v is T, ...args: any[]) => value is T | undefined;
     /**
      * @param value
-     * @param requireNonEmpty `bolean` `default` = `true`
+     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
      * @returns
      */
     static string: (value: any, requireNonEmpty?: boolean) => value is string | undefined;
-    static stringArray: (value: any) => value is string[] | undefined;
+    /**
+     * @param value
+     * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
+     * @returns
+     */
+    static stringArray: (value: any, requireNonEmpty?: boolean) => value is string[] | undefined;
     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;
-    static integerArray: (value: any, requireNonNegative?: boolean) => value is number[] | undefined;
+    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;
 }
@@ -195,25 +208,25 @@ export declare function isFunction(value: any): value is Function;
  */
 export declare function isUndefined(value: any): value is undefined;
 export declare function isUndefinedOrNull(value: unknown): value is undefined | null;
-export type NumberKeys<T> = {
-    [K in keyof T]: T[K] extends number | undefined ? K : never;
-}[keyof T];
-export type ArrayKeys<T> = {
-    [K in keyof T]: T[K] extends Array<any> | undefined ? K : never;
-}[keyof T];
-export type ArrayOfTypeKeys<T, U> = {
-    [K in keyof T]: T[K] extends Array<U> | undefined ? K : never;
-}[keyof T];
-export type StringKeys<T> = {
-    [K in keyof T]: T[K] extends string | undefined ? K : never;
-}[keyof T];
-export type PrimitiveKeys<T> = {
-    [K in keyof T]: T[K] extends string | number | boolean | null | undefined ? K : never;
-}[keyof T];
+export type NumberKeys<T, Required extends true | false = false> = {
+    [K in keyof T]: Required extends true ? (T[K] extends number ? K : never) : (T[K] extends number | undefined ? K : never);
+}[keyof T][];
+export type ArrayKeys<T, Required extends true | false = false> = {
+    [K in keyof T]: Required extends true ? (T[K] extends Array<any> ? K : never) : (T[K] extends Array<any> | undefined ? K : never);
+}[keyof T][];
+export type ArrayOfTypeKeys<T, U, Required extends true | false = false> = {
+    [K in keyof T]: Required extends true ? (T[K] extends Array<U> ? K : never) : (T[K] extends Array<U> | undefined ? K : never);
+}[keyof T][];
+export type StringKeys<T, Required extends true | false = false> = {
+    [K in keyof T]: Required extends true ? (T[K] extends string ? K : never) : (T[K] extends string | undefined ? K : never);
+}[keyof T][];
+export type PrimitiveKeys<T, Required extends true | false = false> = {
+    [K in keyof T]: Required extends true ? (T[K] extends string | number | boolean | null ? K : never) : (T[K] extends string | number | boolean | null | undefined ? K : never);
+}[keyof T][];
 export type Primitive = string | number | boolean | null | undefined;
 /** Get the union of all values of `T` (like `valueof T`) */
 export type ValueOf<T> = T[keyof T];
 /** Keys of `T` whose values extend a given type `U` */
 export type KeysOfType<T, U> = {
     [K in keyof T]: T[K] extends U ? K : never;
-}[keyof T];
+}[keyof T][];

package/dist/utils/typeValidation.js

@@ -92,25 +92,29 @@ function isEmptyArray(value) {
 }
 /**
  * @param value `any`
+ * @param requireNonNegative `boolean` `default = false`
+ * @param requireNonEmpty `boolean` `default = true`
+ * - `if` `true` then `value` must be array with at least 1 element
+ * - `if` `false` then `value` can be empty array
  * @returns **`isIntegerArray`** `boolean` = `value is Array<number> & { length: number }`
- * - **`true`** if `value` is an array with `length > 0` and each of its elements is an `integer`
- * - **`false`** `otherwise`
  */
-function isIntegerArray(value, requireNonNegative = false) {
-    return (value
-        && isNonEmptyArray(value)
-        && value.every(arrElement => isInteger(arrElement, requireNonNegative)));
+function isIntegerArray(value, requireNonNegative = false, requireNonEmpty = true) {
+    return (requireNonEmpty
+        ? isNonEmptyArray(value) && value.every(el => isInteger(el, requireNonNegative))
+        : isEmptyArray(value));
 }
 /**
  * @consideration add param to allow for empty strings?
  * @param value `any`
+ * @param requireNonEmpty `boolean` `default = true`
+ * - `if` `true` then `value` must be array with at least 1 element
+ * - `if` `false` then `value` can be empty array
  * @returns **`isStringArray`** `boolean` = `value is Array<string> & { length: number }`
- * - **`true`** if `value` is an array with `length > 0` and each of its elements is a **non-empty** `string`
- * - **`false`** `otherwise`
  */
-function isStringArray(value) {
-    return (isNonEmptyArray(value)
-        && value.every(el => isNonEmptyString(el)));
+function isStringArray(value, requireNonEmpty = true) {
+    return (requireNonEmpty
+        ? isNonEmptyArray(value) && value.every(el => isNonEmptyString(el))
+        : isEmptyArray(value));
 }
 /**
  * @note **passing in an array will return `false`.**
@@ -305,14 +309,19 @@ isOptional.type = (value, guard, ...args) => {
 };
 /**
  * @param value
- * @param requireNonEmpty `bolean` `default` = `true`
+ * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
  * @returns
  */
 isOptional.string = (value, requireNonEmpty = true) => {
     return isUndefinedOrNull(value) || requireNonEmpty ? isNonEmptyString(value) : typeof value === "string";
 };
-isOptional.stringArray = (value) => {
-    return isUndefinedOrNull(value) || isStringArray(value);
+/**
+ * @param value
+ * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
+ * @returns
+ */
+isOptional.stringArray = (value, requireNonEmpty = true) => {
+    return isUndefinedOrNull(value) || isStringArray(value, requireNonEmpty);
 };
 isOptional.numeric = (value, requireInteger = false, requireNonNegative = false) => {
     return isUndefinedOrNull(value) || isNumeric(value, requireInteger, requireNonNegative);
@@ -324,8 +333,8 @@ isOptional.number = (value, requireInteger = false, requireNonNegative = false)
 isOptional.positiveInteger = (value) => {
     return (isUndefinedOrNull(value) || isPositveInteger(value));
 };
-isOptional.integerArray = (value, requireNonNegative = false) => {
-    return isUndefinedOrNull(value) || isIntegerArray(value, requireNonNegative);
+isOptional.integerArray = (value, requireNonNegative = false, requireNonEmpty = true) => {
+    return isUndefinedOrNull(value) || isIntegerArray(value, requireNonNegative, requireNonEmpty);
 };
 isOptional.boolean = (value) => {
     return isUndefinedOrNull(value) || isBoolean(value);
@@ -341,14 +350,19 @@ isUndefinedOr.type = (value, guard, ...args) => {
 };
 /**
  * @param value
- * @param requireNonEmpty `bolean` `default` = `true`
+ * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that string have at least 1 non-whitespace character)
  * @returns
  */
 isUndefinedOr.string = (value, requireNonEmpty = true) => {
     return isUndefined(value) || requireNonEmpty ? isNonEmptyString(value) : typeof value === "string";
 };
-isUndefinedOr.stringArray = (value) => {
-    return isUndefined(value) || isStringArray(value);
+/**
+ * @param value
+ * @param requireNonEmpty `boolean` `default` = `true` (if `true`, require that array have at least 1 element)
+ * @returns
+ */
+isUndefinedOr.stringArray = (value, requireNonEmpty = true) => {
+    return isUndefined(value) || isStringArray(value, requireNonEmpty);
 };
 isUndefinedOr.numeric = (value, requireInteger = false, requireNonNegative = false) => {
     return isUndefined(value) || isNumeric(value, requireInteger, requireNonNegative);
@@ -360,8 +374,8 @@ isUndefinedOr.number = (value, requireInteger = false, requireNonNegative = fals
 isUndefinedOr.positiveInteger = (value) => {
     return (isUndefined(value) || isPositveInteger(value));
 };
-isUndefinedOr.integerArray = (value, requireNonNegative = false) => {
-    return isUndefined(value) || isIntegerArray(value, requireNonNegative);
+isUndefinedOr.integerArray = (value, requireNonNegative = false, requireNonEmpty = true) => {
+    return isUndefined(value) || isIntegerArray(value, requireNonNegative, requireNonEmpty);
 };
 isUndefinedOr.boolean = (value) => {
     return isUndefined(value) || isBoolean(value);

package/package.json

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