@modulify/validator 0.2.1 → 0.3.1

package/dist/predicates.d.ts

@@ -1,4 +1,4 @@
-import { Intersect, Predicate } from '../types';
+import { Intersect, Predicate } from './types/index.js';
 /** Checks if a value has a property */
 export declare function hasProperty<K extends PropertyKey = PropertyKey>(key: K): (value: unknown) => value is { [k in K]: unknown; };
 /** Checks if a value is an array */
@@ -11,12 +11,16 @@ export declare function isBigInt(value: unknown): value is bigint;
 export declare function isBlob(value: unknown): value is Blob;
 /** Checks if value is Date */
 export declare function isDate(value: unknown): value is Date;
+/** Checks if value is a valid Date */
+export declare function isValidDate(value: unknown): value is Date;
 /** Checks if a value is an email */
 export declare function isEmail(value: unknown): value is string;
 /** Creates a predicate that checks if a value is equal to specified */
 export declare function isExact<T = unknown>(exact: T): (value: unknown) => value is T;
 /** Checks if a value is a File */
 export declare function isFile(value: unknown): value is File;
+/** Checks if a value is an Error */
+export declare function isError(value: unknown): value is Error;
 /** Checks if a value is a function */
 export declare function isFunction<T extends (...args: never[]) => unknown = (...args: never[]) => unknown>(value: unknown): value is T;
 /** Checks if a value is a Map */
@@ -27,10 +31,20 @@ export declare function isNaN(value: unknown): value is number;
 export declare function isNull(value: unknown): value is null;
 /** Checks if a value is a number */
 export declare function isNumber(value: unknown): value is number;
+/** Checks if a value is a finite number */
+export declare function isFiniteNumber(value: unknown): value is number;
+/** Checks if a value is an integer */
+export declare function isInteger(value: unknown): value is number;
 /** Checks if a value is an object, excluding null value */
 export declare function isObject(value: unknown): value is object;
+/** Checks if a value is promise-like */
+export declare function isPromiseLike<T = unknown>(value: unknown): value is PromiseLike<T>;
+/** Checks if a value is a regular expression */
+export declare function isRegExp(value: unknown): value is RegExp;
 /** Check if a value is a record like Record<PropertyKey, unknown> */
 export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+/** Checks if a value is a safe integer */
+export declare function isSafeInteger(value: unknown): value is number;
 /** Checks if a value is a Set */
 export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
 /** Checks if a value is a string */
@@ -49,8 +63,15 @@ export declare function Not<T>(predicate: Predicate<T>): Predicate;
 export type Shape<T extends object> = {
     [K in keyof T]: [Predicate<T[K]>, boolean] | Predicate<T[K]>;
 };
-type ExtractType<T extends Shape<any>> = {
-    [K in keyof T]: T[K] extends [Predicate<infer U>, true] ? U : T[K] extends [Predicate<infer U>, false] ? U | undefined : never;
-} extends infer O ? O : never;
+type ShapePropertyType<Config> = Config extends Predicate<infer U> ? U : Config extends [Predicate<infer U>, boolean] ? U : never;
+type OptionalShapeKeys<T> = {
+    [K in keyof T]: T[K] extends [Predicate, infer Required] ? false extends Required ? K : never : never;
+}[keyof T];
+type ExtractType<T> = {
+    [K in Exclude<keyof T, OptionalShapeKeys<T>>]: ShapePropertyType<T[K]>;
+} & {
+    [K in OptionalShapeKeys<T>]?: ShapePropertyType<T[K]>;
+};
+/** Checks present fields with their predicates; optional fields may be absent. */
 export declare const isShape: <S extends Shape<any>>(shape: S) => (value: unknown) => value is ExtractType<S>;
 export {};

package/dist/predicates.mjs

@@ -1,116 +1,142 @@
+//#region src/predicates.ts
+/** Checks if a value has a property */
 function hasProperty(key) {
-  return (value) => {
-    return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
-  };
+	return (value) => {
+		return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
+	};
 }
+/** Checks if a value is an array */
 function isArray(value) {
-  return Array.isArray(value);
+	return Array.isArray(value);
 }
+/** Checks if a value is a boolean */
 function isBoolean(value) {
-  return typeof value === "boolean";
+	return typeof value === "boolean";
 }
+/** Checks if a value is a bigint */
 function isBigInt(value) {
-  return typeof value === "bigint";
+	return typeof value === "bigint";
 }
+/** Checks if a value is a Blob */
 function isBlob(value) {
-  return typeof Blob !== "undefined" && value instanceof Blob;
+	return typeof Blob !== "undefined" && value instanceof Blob;
 }
+/** Checks if value is Date */
 function isDate(value) {
-  return value instanceof Date;
+	return value instanceof Date;
 }
+/** Checks if value is a valid Date */
+function isValidDate(value) {
+	return isDate(value) && !Number.isNaN(value.getTime());
+}
+/** Checks if a value is an email */
 function isEmail(value) {
-  const pattern = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
-  return isString(value) && pattern.test(value);
+	return isString(value) && /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i.test(value);
 }
+/** Creates a predicate that checks if a value is equal to specified */
 function isExact(exact) {
-  return (value) => value === exact;
+	return (value) => value === exact;
 }
+/** Checks if a value is a File */
 function isFile(value) {
-  return typeof File !== "undefined" && value instanceof File;
+	return typeof File !== "undefined" && value instanceof File;
+}
+/** Checks if a value is an Error */
+function isError(value) {
+	return value instanceof Error;
 }
+/** Checks if a value is a function */
 function isFunction(value) {
-  return typeof value === "function";
+	return typeof value === "function";
 }
+/** Checks if a value is a Map */
 function isMap(value) {
-  return value instanceof Map;
+	return value instanceof Map;
 }
+/** Checks if a value is NaN */
 function isNaN(value) {
-  return typeof value === "number" && Number.isNaN(value);
+	return typeof value === "number" && Number.isNaN(value);
 }
+/** Checks if a value is null */
 function isNull(value) {
-  return value === null;
+	return value === null;
 }
+/** Checks if a value is a number */
 function isNumber(value) {
-  return typeof value === "number" && !isNaN(value);
+	return typeof value === "number" && !isNaN(value);
+}
+/** Checks if a value is a finite number */
+function isFiniteNumber(value) {
+	return isNumber(value) && Number.isFinite(value);
+}
+/** Checks if a value is an integer */
+function isInteger(value) {
+	return isNumber(value) && Number.isInteger(value);
 }
+/** Checks if a value is an object, excluding null value */
 function isObject(value) {
-  return typeof value === "object" && value !== null;
+	return typeof value === "object" && value !== null;
 }
+/** Checks if a value is promise-like */
+function isPromiseLike(value) {
+	return (isObject(value) || isFunction(value)) && "then" in value && isFunction(value.then);
+}
+/** Checks if a value is a regular expression */
+function isRegExp(value) {
+	return value instanceof RegExp;
+}
+/** Check if a value is a record like Record<PropertyKey, unknown> */
 function isRecord(value) {
-  return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+	return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
 }
+/** Checks if a value is a safe integer */
+function isSafeInteger(value) {
+	return isNumber(value) && Number.isSafeInteger(value);
+}
+/** Checks if a value is a Set */
 function isSet(value) {
-  return value instanceof Set;
+	return value instanceof Set;
 }
+/** Checks if a value is a string */
 function isString(value) {
-  return typeof value === "string";
+	return typeof value === "string";
 }
+/** Checks if a value is a symbol */
 function isSymbol(value) {
-  return typeof value === "symbol";
+	return typeof value === "symbol";
 }
+/** Checks if a value is undefined */
 function isUndefined(value) {
-  return typeof value === "undefined";
+	return typeof value === "undefined";
 }
 function constructorOf(value) {
-  return prototypeOf(value).constructor;
+	return prototypeOf(value).constructor;
 }
 function prototypeOf(value) {
-  return Object.getPrototypeOf(value);
+	return Object.getPrototypeOf(value);
 }
 function And(...predicates) {
-  return (value) => {
-    return predicates.every((predicate) => predicate(value));
-  };
+	return (value) => {
+		return predicates.every((predicate) => predicate(value));
+	};
 }
 function Or(...predicates) {
-  return (value) => {
-    return predicates.some((predicate) => predicate(value));
-  };
+	return (value) => {
+		return predicates.some((predicate) => predicate(value));
+	};
 }
 function Not(predicate) {
-  return (value) => !predicate(value);
-}
-const isShape = (shape) => {
-  const properties = Object.keys(shape);
-  return (value) => isObject(value) && properties.every((p) => {
-    const config = shape[p];
-    const [predicate, required] = isArray(config) ? config : [config, true];
-    return p in value && value[p] !== void 0 && predicate(value[p]) || !required;
-  });
-};
-export {
-  And,
-  Not,
-  Or,
-  hasProperty,
-  isArray,
-  isBigInt,
-  isBlob,
-  isBoolean,
-  isDate,
-  isEmail,
-  isExact,
-  isFile,
-  isFunction,
-  isMap,
-  isNaN,
-  isNull,
-  isNumber,
-  isObject,
-  isRecord,
-  isSet,
-  isShape,
-  isString,
-  isSymbol,
-  isUndefined
+	return (value) => !predicate(value);
+}
+/** Checks present fields with their predicates; optional fields may be absent. */
+var isShape = (shape) => {
+	const properties = Object.keys(shape);
+	return (value) => isObject(value) && properties.every((p) => {
+		const config = shape[p];
+		const [predicate, required] = isArray(config) ? config : [config, true];
+		if (!(p in value)) return !required;
+		return predicate(value[p]);
+	});
 };
+//#endregion
+export { And, Not, Or, hasProperty, isArray, isBigInt, isBlob, isBoolean, isDate, isEmail, isError, isExact, isFile, isFiniteNumber, isFunction, isInteger, isMap, isNaN, isNull, isNumber, isObject, isPromiseLike, isRecord, isRegExp, isSafeInteger, isSet, isShape, isString, isSymbol, isUndefined, isValidDate };