valgen 6.1.0 → 6.2.1

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '6.1.0';
+export const version = '6.2.1';
 export const postValidation = Symbol('postValidation');
 export const preValidation = Symbol('preValidation');
 export const VALIDATE_METADATA = Symbol('VALIDATE_METADATA');

package/index.d.ts

@@ -3,6 +3,7 @@ import { Context, type ExecutionOptions, type Validator } from './core/index.js'
 import * as vg from './rules/index.js';
 export * from './constants.js';
 export * from './core/index.js';
+export * from './core/types.js';
 declare const isAlpha: Validator<string, string, ExecutionOptions>;
 declare const isAlphanumeric: Validator<string, string, ExecutionOptions>;
 declare const isAny: Validator<any, any, ExecutionOptions>;

package/index.js

@@ -2,6 +2,7 @@ import { Context, } from './core/index.js';
 import * as vg from './rules/index.js';
 export * from './constants.js';
 export * from './core/index.js';
+export * from './core/types.js';
 const isInstanceOfCache = new WeakMap();
 const isAlpha = vg.isAlpha();
 const isAlphanumeric = vg.isAlphanumeric();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "6.1.0",
+  "version": "6.2.1",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
     "@browsery/validator": "^13.15.35",
-    "@jsopen/objects": "^2.2.1",
-    "date-fns": "^4.1.0",
+    "@jsopen/objects": "^2.2.2",
+    "date-fns": "^4.2.1",
     "reflect-metadata": "^0.2.2",
     "ts-gems": "^3.12.0",
     "tslib": "^2.8.1"

package/rules/format-rules/is-alpha.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isAlpha
  */
 export function isAlpha(options) {
-    return validator('isAlpha', (input, context, _this) => {
+    return validator(isAlpha.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAlpha(input))
             return input;
         context.fail(_this, `"Value must be an alpha string`, input);

package/rules/format-rules/is-alphanumeric.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isAlphanumeric
  */
 export function isAlphanumeric(options) {
-    return validator('isAlphanumeric', (input, context, _this) => {
+    return validator(isAlphanumeric.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAlphanumeric(input)) {
             return input;
         }

package/rules/format-rules/is-ascii.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isAscii
  */
 export function isAscii(options) {
-    return validator('isAscii', (input, context, _this) => {
+    return validator(isAscii.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAscii(input))
             return input;
         context.fail(_this, `Value must be an ascii string`, input);

package/rules/format-rules/is-base64.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isBase64
  */
 export function isBase64(options) {
-    return validator('isBase64', (input, context, _this) => {
+    return validator(isBase64.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isBase64(input, options)) {
             return input;
         }

package/rules/format-rules/is-btc-address.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isBtcAddress
  */
 export function isBtcAddress(options) {
-    return validator('isBtcAddress', (input, context, _this) => {
+    return validator(isBtcAddress.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isBtcAddress(input)) {
             return input;
         }

package/rules/format-rules/is-credit-card.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isCreditCard
  */
 export function isCreditCard(options) {
-    return validator('isCreditCard', (input, context, _this) => {
+    return validator(isCreditCard.name, (input, context, _this) => {
         if (typeof input === 'string' &&
             validatorJS.isCreditCard(input, options)) {
             return input;

package/rules/format-rules/is-decimal.js

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
  * @validator isDecimal
  */
 export function isDecimal(options) {
-    return validator('isDecimal', (input, context, _this) => {
+    return validator(isDecimal.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isDecimal(input)) {
             return input;
         }

package/rules/format-rules/is-ean.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isEAN
  */
 export function isEAN(options) {
-    return validator('isEAN', (input, context, _this) => {
+    return validator(isEAN.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isEAN(input))
             return input;
         context.fail(_this, `Value must be a valid EAN (European Article Number)`, input);

package/rules/format-rules/is-email.js

@@ -11,7 +11,7 @@ export function isEmail(options) {
         ignore_max_length: true,
         allow_ip_domain: options?.allowIpDomain,
     };
-    return validator('isEmail', (input, context, _this) => {
+    return validator(isEmail.name, (input, context, _this) => {
         if (typeof input === 'string' &&
             validatorJS.isEmail(input, emailOptions)) {
             if (options?.requireDisplayName) {

package/rules/format-rules/is-eth-address.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isETHAddress
  */
 export function isETHAddress(options) {
-    return validator('isETHAddress', (input, context, _this) => {
+    return validator(isETHAddress.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isEthereumAddress(input)) {
             return input;
         }

package/rules/format-rules/is-fqdn.js

@@ -8,7 +8,7 @@ export function isFQDN(options) {
     const opts = {
         allow_wildcard: options?.allowWildcard,
     };
-    return validator('isFQDN', (input, context, _this) => {
+    return validator(isFQDN.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isFQDN(input, opts)) {
             return input;
         }

package/rules/format-rules/is-hash.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isHash
  */
 export function isHash(algorithm, options) {
-    return validator('isHash', (input, context, _this) => {
+    return validator(isHash.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isHash(input, algorithm)) {
             return input;
         }

package/rules/format-rules/is-hex-color.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isHexColor
  */
 export function isHexColor(options) {
-    return validator('isHexColor', (input, context, _this) => {
+    return validator(isHexColor.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isHexColor(input)) {
             return input;
         }

package/rules/format-rules/is-hex.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isHex
  */
 export function isHex(options) {
-    return validator('isHex', (input, context, _this) => {
+    return validator(isHex.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isHexadecimal(input)) {
             return input;
         }

package/rules/format-rules/is-iban.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isIBAN
  */
 export function isIBAN(options) {
-    return validator('isIBAN', (input, context, _this) => {
+    return validator(isIBAN.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isIBAN(input))
             return input;
         context.fail(_this, `Value must be a valid IBAN (International Bank Account Number)`, input);

package/rules/format-rules/is-ip.js

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
  * @validator isIP
  */
 export function isIP(version, options) {
-    return validator('isIP', (input, context, _this) => {
+    return validator(isIP.name, (input, context, _this) => {
         if (input != null &&
             typeof input === 'string' &&
             validatorJS.isIP(input, version)) {
@@ -20,7 +20,7 @@ export function isIP(version, options) {
  * @validator isIPRange
  */
 export function isIPRange(version, options) {
-    return validator('isIPRange', (input, context, _this) => {
+    return validator(isIPRange.name, (input, context, _this) => {
         if (input != null &&
             typeof input === 'string' &&
             validatorJS.isIPRange(input, version)) {

package/rules/format-rules/is-issn.js

@@ -8,7 +8,7 @@ export function isISSN(options) {
     const opts = {
         case_sensitive: options?.caseSensitive,
     };
-    return validator('isISSN', (input, context, _this) => {
+    return validator(isISSN.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isISSN(input, opts)) {
             return input;
         }

package/rules/format-rules/is-jwt.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isJWT
  */
 export function isJWT(options) {
-    return validator('isJWT', (input, context, _this) => {
+    return validator(isJWT.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isJWT(input))
             return input;
         context.fail(_this, `Value must be valid JWT token`, input);

package/rules/format-rules/is-lowercase.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isLowercase
  */
 export function isLowercase(options) {
-    return validator('isLowercase', (input, context, _this) => {
+    return validator(isLowercase.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isLowercase(input)) {
             return input;
         }

package/rules/format-rules/is-mac-address.js

@@ -10,7 +10,7 @@ export function isMACAddress(options) {
         no_separators: options?.noSeparators,
         eui: options?.eui,
     };
-    return validator('isMACAddress', (input, context, _this) => {
+    return validator(isMACAddress.name, (input, context, _this) => {
         if (input != null &&
             typeof input === 'string' &&
             validatorJS.isMACAddress(input, opts)) {

package/rules/format-rules/is-mobile-phone.js

@@ -8,7 +8,7 @@ export function isMobilePhone(options) {
     const opts = {
         strictMode: options?.strictMode,
     };
-    return validator('isMobilePhone', (input, context, _this) => {
+    return validator(isMobilePhone.name, (input, context, _this) => {
         if (typeof input === 'string' &&
             validatorJS.isMobilePhone(input, options?.locale, opts)) {
             return input;

package/rules/format-rules/is-object-id.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isObjectId
  */
 export function isObjectId(options) {
-    return validator('isObjectId', (input, context, _this) => {
+    return validator(isObjectId.name, (input, context, _this) => {
         if (input != null &&
             (_isObjectIdValue(input) ||
                 (typeof input === 'object' &&

package/rules/format-rules/is-passport-number.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isPassportNumber
  */
 export function isPassportNumber(countryCode, options) {
-    return validator('isPassportNumber', (input, context, _this) => {
+    return validator(isPassportNumber.name, (input, context, _this) => {
         if (typeof input === 'string' &&
             validatorJS.isPassportNumber(input, countryCode)) {
             return input;

package/rules/format-rules/is-port.js

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
  * @validator isPort
  */
 export function isPort(options) {
-    return validator('isPort', (input, context, _this) => {
+    return validator(isPort.name, (input, context, _this) => {
         if (typeof input === 'number')
             input = String(input);
         if (input != null &&

package/rules/format-rules/is-swift.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isSWIFT
  */
 export function isSWIFT(options) {
-    return validator('isSWIFT', (input, context, _this) => {
+    return validator(isSWIFT.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isBIC(input))
             return input;
         context.fail(_this, `Value must be a valid a BIC (Bank Identification Code) or SWIFT code`, input);

package/rules/format-rules/is-time.js

@@ -5,7 +5,7 @@ const TIME_PATTERN = /^(\d{2}):?(\d{2})(?::?(\d{2})?(?:\.(\d{1,3}))?)?$/;
  * @validator isTime
  */
 export function isTime(options) {
-    return validator('isTime', (input, context, _this) => {
+    return validator(isTime.name, (input, context, _this) => {
         if (input != null) {
             const coerce = options?.coerce ?? context.coerce;
             let str;

package/rules/format-rules/is-uppercase.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isUppercase
  */
 export function isUppercase(options) {
-    return validator('isUppercase', (input, context, _this) => {
+    return validator(isUppercase.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isUppercase(input)) {
             return input;
         }

package/rules/format-rules/is-url.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isURL
  */
 export function isURL(options) {
-    return validator('isURL', (input, context, _this) => {
+    return validator(isURL.name, (input, context, _this) => {
         if (input != null &&
             typeof input === 'string' &&
             validatorJS.isURL(input, options)) {

package/rules/format-rules/is-uuid.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isUUID
  */
 export function isUUID(version, options) {
-    return validator('isUUID', (input, context, _this) => {
+    return validator(isUUID.name, (input, context, _this) => {
         if (input != null &&
             typeof input === 'string' &&
             validatorJS.isUUID(input, version)) {

package/rules/format-rules/is-vat-number.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isVAT
  */
 export function isVATNumber(countryCode, options) {
-    return validator('isVATNumber', (input, context, _this) => {
+    return validator(isVATNumber.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isVAT(input, countryCode)) {
             return input;
         }

package/rules/format-rules/matches.js

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
 export function matches(format, options) {
     const regExp = format instanceof RegExp ? format : new RegExp(format);
     const formatName = options?.formatName;
-    return validator('matches', (input, context, _this) => {
+    return validator(matches.name, (input, context, _this) => {
         if (input == null)
             return;
         if (typeof input === 'string' && regExp.test(input))

package/rules/index.d.ts

@@ -55,7 +55,9 @@ export * from './type-rules/is-tuple.js';
 export * from './type-rules/is-undefined.js';
 export * from './utility-rules/all-of.js';
 export * from './utility-rules/exists.js';
+export * from './utility-rules/fixed.js';
 export * from './utility-rules/get-length.js';
+export * from './utility-rules/nullable.js';
 export * from './utility-rules/one-of.js';
 export * from './utility-rules/optional.js';
 export * from './utility-rules/pipe.js';

package/rules/index.js

@@ -55,7 +55,9 @@ export * from './type-rules/is-tuple.js';
 export * from './type-rules/is-undefined.js';
 export * from './utility-rules/all-of.js';
 export * from './utility-rules/exists.js';
+export * from './utility-rules/fixed.js';
 export * from './utility-rules/get-length.js';
+export * from './utility-rules/nullable.js';
 export * from './utility-rules/one-of.js';
 export * from './utility-rules/optional.js';
 export * from './utility-rules/pipe.js';

package/rules/logical-rules/is-defined.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isDefined
  */
 export function isDefined(options) {
-    return validator('is-defined', (input, context, _this) => {
+    return validator(isDefined.name, (input, context, _this) => {
         if (input !== undefined)
             return input;
         context.fail(_this, `Value must be defined`, input);

package/rules/logical-rules/is-empty.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isEmpty
  */
 export function isEmpty(options) {
-    return validator('isEmpty', (input, context, _this) => {
+    return validator(isEmpty.name, (input, context, _this) => {
         if (input == null)
             return input;
         if (typeof input === 'string') {

package/rules/logical-rules/is-equal.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isEqual
  */
 export function isEqual(compare, options) {
-    return validator('isEqual', (input, context, _this) => {
+    return validator(isEqual.name, (input, context, _this) => {
         if (input == null)
             return input;
         if (input !== compare)
@@ -17,7 +17,7 @@ export function isEqual(compare, options) {
  * @validator isNotEqual
  */
 export function isNotEqual(compare, options) {
-    return validator('isNotEqual', (input, context, _this) => {
+    return validator(isNotEqual.name, (input, context, _this) => {
         if (input == null)
             return input;
         if (input === compare) {

package/rules/logical-rules/is-gt.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator iGt
  */
 export function isGt(minValue, options) {
-    return validator('isGt', (input, context, _this) => {
+    return validator(isGt.name, (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input > minValue) {

package/rules/logical-rules/is-gte.d.ts

@@ -4,7 +4,7 @@ import type { range } from './range.js';
  * Checks if value is grater than or equal to minValue
  * @validator isGte
  */
-export declare function isGte<T extends range.Input>(minValue: T, options?: isGte.Options): Validator<T, T>;
+export declare function isGte<T extends range.Input>(minValue: T, options?: isGte.Options): Validator<T>;
 export declare namespace isGte {
     interface Options extends ValidationOptions {
         caseInsensitive?: boolean;

package/rules/logical-rules/is-gte.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isGte
  */
 export function isGte(minValue, options) {
-    return validator('isGte', (input, context, _this) => {
+    return validator(isGte.name, (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input >= minValue) {

package/rules/logical-rules/is-lt.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isLt
  */
 export function isLt(maxValue, options) {
-    return validator('isLt', (input, context, _this) => {
+    return validator(isLt.name, (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input < maxValue) {

package/rules/logical-rules/is-lte.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isLte
  */
 export function isLte(maxValue, options) {
-    return validator('isLte', (input, context, _this) => {
+    return validator(isLte.name, (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input <= maxValue) {

package/rules/logical-rules/range.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator range
  */
 export function range(minValue, maxValue, options) {
-    return validator('range', (input, context, _this) => {
+    return validator(range.name, (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&

package/rules/type-rules/is-any.js

@@ -3,4 +3,4 @@ import { validator } from '../../core/index.js';
  * Does nothing, just returns the original input value.
  * @validator isAny
  */
-export const isAny = () => validator('is-any', (input) => input);
+export const isAny = () => validator(isAny.name, (input) => input);

package/rules/type-rules/is-array.js

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isArray
  */
 export function isArray(itemValidator, options) {
-    return validator('isArray', (input, context, _this) => {
+    return validator(isArray.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

package/rules/type-rules/is-bigint.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isNumber
  */
 export function isBigint(options) {
-    return validator('isBigint', (input, context, _this) => {
+    return validator(isBigint.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         if (typeof input === 'bigint')
             return input;

package/rules/type-rules/is-boolean.js

@@ -7,7 +7,7 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  * @validator isBoolean
  */
 export function isBoolean(options) {
-    return validator('isBoolean', (input, context, _this) => {
+    return validator(isBoolean.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'boolean' && coerce) {

package/rules/type-rules/is-date.d.ts

@@ -23,6 +23,6 @@ export declare namespace isDateString {
         precisionMin?: Precision;
         precisionMax?: Precision;
         trim?: boolean;
-        timeZone?: boolean | number;
+        separators?: boolean;
     }
 }

package/rules/type-rules/is-date.js

@@ -8,7 +8,7 @@ import { validator, } from '../../core/index.js';
  */
 export function isDate(options) {
     const trim = options?.trim;
-    return validator('isDate', (input, context, _this) => {
+    return validator(isDate.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let d;
         if (input instanceof Date)
@@ -44,9 +44,12 @@ export function isDateString(options) {
     let precisionMin = options?.precisionMin || 'minutes';
     const precisionMinIdx = Math.min(precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
     precisionMin = (PRECISION_INDEX_KEYS[PRECISION_INDEX_VALUES.indexOf(precisionMinIdx)] || precisionMin);
-    return validator('isDateString', (input, context, _this) => {
+    return validator(isDateString.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
-        const parsed = coerceDateString(input, trim ? precisionMax : undefined);
+        const parsed = coerceDateString(input, {
+            trimPrecision: trim ? precisionMax : undefined,
+            separators: options?.separators,
+        });
         if (parsed) {
             if (parsed.precision < precisionMinIdx) {
                 context.fail(_this, `Minimum date precision should be ${precisionMin}`, input, options);
@@ -62,7 +65,9 @@ export function isDateString(options) {
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const DATE_PATTERN = /^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[T ](?:([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?(?:\.(\d{0,6}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
 const DATE_PATTERN2 = /^(\d{4,14})(?:\.(\d{1,6}))?(?:(?:([+-])(0[0-9]|1[0-2])(\d{2})?)|Z)?$/;
-function coerceDateString(input, trimPrecision) {
+function coerceDateString(input, options = {}) {
+    const { trimPrecision } = options;
+    const separators = options.separators ?? true;
     const precisionIndex = (trimPrecision ? PRECISION_INDEX[trimPrecision] : 9) || 9;
     let dateParts;
     let detectedPrecision;
@@ -122,15 +127,15 @@ function coerceDateString(input, trimPrecision) {
         detectedPrecision = Math.min(dateParts.length, 8);
     let value = dateParts[0] || '0000';
     if (precisionIndex > 1)
-        value += '-' + (dateParts[1] || '01');
+        value += (separators ? '-' : '') + (dateParts[1] || '01');
     if (precisionIndex > 2)
-        value += '-' + (dateParts[2] || '01');
+        value += (separators ? '-' : '') + (dateParts[2] || '01');
     if (precisionIndex > 3)
-        value += 'T' + (dateParts[3] || '00');
+        value += (separators ? 'T' : '') + (dateParts[3] || '00');
     if (precisionIndex > 4)
-        value += ':' + (dateParts[4] || '00');
+        value += (separators ? ':' : '') + (dateParts[4] || '00');
     if (precisionIndex > 5)
-        value += ':' + (dateParts[5] || '00');
+        value += (separators ? ':' : '') + (dateParts[5] || '00');
     if (precisionIndex > 6)
         value += dateParts[6] ? '.' + dateParts[6] : '';
     if (precisionIndex > 7)

package/rules/type-rules/is-enum.js

@@ -22,7 +22,7 @@ export function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return validator('isEnum', (input, context, _this) => {
+    return validator(isEnum.name, (input, context, _this) => {
         if (input != null &&
             valObj[typeof input === 'string' && caseInSensitive
                 ? input.toUpperCase()

package/rules/type-rules/is-instanceof.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isUndefined
  */
 export function isInstanceOf(clazz, options) {
-    return validator('isInstanceOf', (input, context, _this) => {
+    return validator(isInstanceOf.name, (input, context, _this) => {
         if ((options?.coerce ?? context.coerce) && isPlainObject(input)) {
             Object.setPrototypeOf(input, clazz.prototype);
         }

package/rules/type-rules/is-integer.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isInteger
  */
 export function isInteger(options) {
-    return validator('isInteger', (input, context, _this) => {
+    return validator(isInteger.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

package/rules/type-rules/is-null.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isNull
  */
 export function isNull(options) {
-    return validator('isNull', (input, context, _this) => {
+    return validator(isNull.name, (input, context, _this) => {
         if (input === null)
             return input;
         context.fail(_this, `Value must be null`, input);
@@ -15,7 +15,7 @@ export function isNull(options) {
  * @validator isNotNull
  */
 export function isNotNull(options) {
-    return validator('isNotNull', (input, context, _this) => {
+    return validator(isNotNull.name, (input, context, _this) => {
         if (input !== null)
             return input;
         context.fail(_this, `{{label}} is null`, input);
@@ -26,7 +26,7 @@ export function isNotNull(options) {
  * @validator isNullish
  */
 export function isNullish(options) {
-    return validator('isNullish', (input, context, _this) => {
+    return validator(isNullish.name, (input, context, _this) => {
         if (input == null)
             return input;
         context.fail(_this, `{{label}} is not nullish`, input);
@@ -37,7 +37,7 @@ export function isNullish(options) {
  * @validator isNotNullish
  */
 export function isNotNullish(options) {
-    return validator('isNotNullish', (input, context, _this) => {
+    return validator(isNotNullish.name, (input, context, _this) => {
         if (input != null)
             return input;
         if (input === null)

package/rules/type-rules/is-number.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isNumber
  */
 export function isNumber(options) {
-    return validator('isNumber', (input, context, _this) => {
+    return validator(isNumber.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

package/rules/type-rules/is-object.js

@@ -33,7 +33,7 @@ export function isObject(schema, options) {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
         }
     }
-    const _rule = validator('isObject', (input, context, _this) => {
+    const _rule = validator(isObject.name, (input, context, _this) => {
         let output = input;
         if (ctor && ctor[preValidation]) {
             output = ctor[preValidation](output, context, _this);

package/rules/type-rules/is-record.js

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isRecord
  */
 export function isRecord(keyRule, valueRule, options) {
-    return validator('isRecord', (input, context, _this) => {
+    return validator(isRecord.name, (input, context, _this) => {
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `Value must be an object`, input);
             return;

package/rules/type-rules/is-string.js

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isString
  */
 export function isString(options) {
-    return validator('isString', (input, context, _this) => {
+    return validator(isString.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'string' && coerce) {

package/rules/type-rules/is-tuple.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 export function isTuple(items, options) {
-    return validator('isTuple', (input, context, _this) => {
+    return validator(isTuple.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

package/rules/type-rules/is-undefined.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isUndefined
  */
 export function isUndefined(options) {
-    return validator('isUndefined', (input, context, _this) => {
+    return validator(isUndefined.name, (input, context, _this) => {
         if (options?.coerce ?? context.coerce)
             return undefined;
         if (input === undefined)

package/rules/utility-rules/all-of.js

@@ -4,7 +4,7 @@ import { validator } from '../../core/index.js';
  * @validator allOf
  */
 export function allOf(rules, options) {
-    return validator('allOf', (input, context) => {
+    return validator(allOf.name, (input, context) => {
         let i;
         let c;
         const l = rules.length;

package/rules/utility-rules/exists.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator exists
  */
 export function exists(options) {
-    return validator('exists', (input, context, _this) => {
+    return validator(exists.name, (input, context, _this) => {
         if (input !== undefined ||
             (context.scope &&
                 Object.getOwnPropertyDescriptor(context.scope, input))) {

package/rules/utility-rules/fixed.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check if value is not nullish before calling nested rule
+ * @validator required
+ */
+export declare function fixed<T, I>(value: T): import("../../core/validator.js").Validator<T, I, import("../../core/types.js").ExecutionOptions>;

package/rules/utility-rules/fixed.js

@@ -0,0 +1,10 @@
+import { validator } from '../../core/index.js';
+/**
+ * Check if value is not nullish before calling nested rule
+ * @validator required
+ */
+export function fixed(value) {
+    return validator(fixed.name, () => {
+        return value;
+    });
+}

package/rules/utility-rules/get-length.js

@@ -4,7 +4,7 @@ import { validator } from '../../core/index.js';
  * @validator getLength
  */
 export function getLength() {
-    return validator('getLength', (input, context, _this) => {
+    return validator(getLength.name, (input, context, _this) => {
         if (typeof input === 'string')
             return input.length;
         if (Array.isArray(input))

package/rules/utility-rules/nullable.d.ts

@@ -0,0 +1,11 @@
+import type { Nullish } from 'ts-gems';
+import { type ValidationOptions, type Validator } from '../../core/index.js';
+/**
+ * Makes the sub-rule nullable (undefined of null)
+ * @validator optional
+ */
+export declare function nullable<T, I>(nested: Validator<T, I>, options?: nullable.Options): Validator<Nullish<T>, Nullish<I>, import("../../core/types.js").ExecutionOptions>;
+export declare namespace nullable {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/utility-rules/nullable.js

@@ -0,0 +1,12 @@
+import { validator, } from '../../core/index.js';
+/**
+ * Makes the sub-rule nullable (undefined of null)
+ * @validator optional
+ */
+export function nullable(nested, options) {
+    return validator(nullable.name, (input, context) => {
+        if (input == null)
+            return input;
+        return nested(input, context);
+    }, options);
+}

package/rules/utility-rules/one-of.js

@@ -4,7 +4,7 @@ import { validator } from '../../core/index.js';
  */
 export function oneOf(rules, options) {
     const l = rules.length;
-    return validator('union', (input, context, _this) => {
+    return validator(oneOf.name, (input, context, _this) => {
         let i;
         let c;
         let discriminator;

package/rules/utility-rules/optional.d.ts

@@ -1,10 +1,10 @@
-import type { Nullish } from 'ts-gems';
+import type { Maybe } from 'ts-gems';
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 /**
  * Makes the sub-rule optional
  * @validator optional
  */
-export declare function optional<T, I>(nested: Validator<T, I>, options?: optional.Options): Validator<Nullish<T>, Nullish<I>, import("../../core/types.js").ExecutionOptions>;
+export declare function optional<T, I>(nested: Validator<T, I>, options?: optional.Options): Validator<Maybe<T>, Maybe<I>, import("../../core/types.js").ExecutionOptions>;
 export declare namespace optional {
     interface Options extends ValidationOptions {
     }

package/rules/utility-rules/optional.js

@@ -4,8 +4,8 @@ import { validator, } from '../../core/index.js';
  * @validator optional
  */
 export function optional(nested, options) {
-    return validator('optional', (input, context) => {
-        if (input == null)
+    return validator(optional.name, (input, context) => {
+        if (input === undefined)
             return input;
         return nested(input, context);
     }, options);

package/rules/utility-rules/pipe.js

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
 export function pipe(rules, options) {
     const l = rules.length;
     const returnIndex = options?.returnIndex;
-    return validator('pipe', (input, context) => {
+    return validator(pipe.name, (input, context) => {
         let i;
         let c;
         let v = input;

package/rules/utility-rules/required.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator required
  */
 export function required(nested, options) {
-    return validator('required', (input, context, _this) => {
+    return validator(required.name, (input, context, _this) => {
         if (input == null)
             input = options?.default;
         if (input == null) {

package/rules/utility-rules/string-utils.d.ts

@@ -27,9 +27,9 @@ export declare function trim(): import("../../core/validator.js").Validator<stri
  * Removes whitespace from the end of a string
  * @validator trimEnd
  */
-export declare const trimEnd: () => import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function trimEnd(): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
 /**
  * Removes whitespace from the beginning of a string
  * @validator trimStart
  */
-export declare const trimStart: () => import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+export declare function trimStart(): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/rules/utility-rules/string-utils.js

@@ -1,13 +1,13 @@
 import { validator } from '../../core/index.js';
 export function stringReplace(searchValue, replacer) {
-    return validator('stringReplace', (input) => {
+    return validator(stringReplace.name, (input) => {
         if (input == null)
             return input;
         return String(input).replace(searchValue, replacer);
     });
 }
 export function stringSplit(splitter, limit) {
-    return validator('stringSplit', (input) => {
+    return validator(stringSplit.name, (input) => {
         if (input == null)
             return input;
         return String(input).split(splitter, limit);
@@ -18,7 +18,7 @@ export function stringSplit(splitter, limit) {
  * @validator trim
  */
 export function trim() {
-    return validator('trim', (input) => {
+    return validator(trim.name, (input) => {
         if (input == null)
             return input;
         return String(input).trim();
@@ -29,20 +29,22 @@ export function trim() {
  * Removes whitespace from the end of a string
  * @validator trimEnd
  */
-export const trimEnd = () => trimEndRule;
-const trimEndRule = validator('trimEnd', (input) => {
-    if (input == null)
-        return input;
-    return String(input).trimEnd();
-});
+export function trimEnd() {
+    return validator(trimEnd.name, (input) => {
+        if (input == null)
+            return input;
+        return String(input).trimEnd();
+    });
+}
 // *************************************************************
 /**
  * Removes whitespace from the beginning of a string
  * @validator trimStart
  */
-export const trimStart = () => trimStartRule;
-const trimStartRule = validator('trimStart', (input) => {
-    if (input == null)
-        return input;
-    return String(input).trimStart();
-});
+export function trimStart() {
+    return validator(trimStart.name, (input) => {
+        if (input == null)
+            return input;
+        return String(input).trimStart();
+    });
+}