valgen 6.2.2 → 7.0.1

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

@@ -1,7 +1,8 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if value is a "Date" instance or ISO 8601 formatted date string.
- *  if a `coerce` option is `true`, converts input value to Date instance
+ * Validates if value is a "Date" instance. If the `coerce` option is `true`,
+ * also accepts an ISO 8601 formatted date string or a numeric timestamp and
+ * converts it to a Date instance.
  * @validator isDate
  */
 export declare function isDate(options?: isDate.Options): import("../../core/validator.js").Validator<Date, string | number | Date, import("../../core/types.js").ExecutionOptions>;

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

@@ -2,8 +2,9 @@ import * as datefns from 'date-fns';
 import {} from 'ts-gems';
 import { validator, } from '../../core/index.js';
 /**
- * Validates if value is a "Date" instance or ISO 8601 formatted date string.
- *  if a `coerce` option is `true`, converts input value to Date instance
+ * Validates if value is a "Date" instance. If the `coerce` option is `true`,
+ * also accepts an ISO 8601 formatted date string or a numeric timestamp and
+ * converts it to a Date instance.
  * @validator isDate
  */
 export function isDate(options) {
@@ -73,6 +74,8 @@ function coerceDateString(input, options = {}) {
     let detectedPrecision;
     if (input instanceof Date || typeof input === 'number') {
         const d = typeof input === 'number' ? new Date(input) : input;
+        if (!datefns.isValid(d))
+            return;
         dateParts = [
             String(d.getFullYear()).padStart(4, '0'),
             String(d.getMonth() + 1).padStart(2, '0'),
@@ -88,12 +91,10 @@ function coerceDateString(input, options = {}) {
                 dateParts.push('');
         if (precisionIndex >= 8) {
             const tzOffset = d.getTimezoneOffset();
-            const tz = tzOffset > 0
-                ? '-'
-                : '+' +
-                    String(Math.floor(Math.abs(tzOffset) / 60)).padStart(2, '0') +
-                    ':' +
-                    String(Math.abs(tzOffset) % 60).padStart(2, '0');
+            const tz = (tzOffset > 0 ? '-' : '+') +
+                String(Math.floor(Math.abs(tzOffset) / 60)).padStart(2, '0') +
+                ':' +
+                String(Math.abs(tzOffset) % 60).padStart(2, '0');
             dateParts.push(tz);
         }
     }
@@ -151,7 +152,7 @@ const PRECISION_INDEX = {
     month: 2,
     mo: 2,
     day: 3,
-    d: 4,
+    d: 3,
     hours: 4,
     hr: 4,
     minutes: 5,
@@ -166,29 +167,35 @@ const PRECISION_INDEX_KEYS = Object.keys(PRECISION_INDEX);
 const PRECISION_INDEX_VALUES = Object.values(PRECISION_INDEX);
 function setPrecision(d, precision) {
     switch (precision) {
-        case 'year': {
+        case 'year':
+        case 'yr': {
             d.setMonth(0, 1);
             d.setHours(0, 0, 0, 0);
             break;
         }
-        case 'month': {
+        case 'month':
+        case 'mo': {
             d.setDate(1);
             d.setHours(0, 0, 0, 0);
             break;
         }
-        case 'day': {
+        case 'day':
+        case 'd': {
             d.setHours(0, 0, 0, 0);
             break;
         }
-        case 'hours': {
+        case 'hours':
+        case 'hr': {
             d.setMinutes(0, 0, 0);
             break;
         }
-        case 'minutes': {
+        case 'minutes':
+        case 'min': {
             d.setSeconds(0, 0);
             break;
         }
-        case 'seconds': {
+        case 'seconds':
+        case 'sec': {
             d.setMilliseconds(0);
             break;
         }

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

@@ -2,7 +2,7 @@ import type { Type } from 'ts-gems';
 import { type ValidationOptions } from '../../core/index.js';
 /**
  * Validates if the value instance of given class or classes
- * @validator isUndefined
+ * @validator isInstanceOf
  */
 export declare function isInstanceOf<T extends object>(clazz: Type<T>, options?: isInstanceOf.Options): import("../../core/validator.js").Validator<T, unknown, import("../../core/types.js").ExecutionOptions>;
 export declare namespace isInstanceOf {

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

@@ -2,7 +2,7 @@ import { isPlainObject } from '@jsopen/objects';
 import { validator, } from '../../core/index.js';
 /**
  * Validates if the value instance of given class or classes
- * @validator isUndefined
+ * @validator isInstanceOf
  */
 export function isInstanceOf(clazz, options) {
     return validator(isInstanceOf.name, (input, context, _this) => {

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

@@ -12,9 +12,12 @@ export function isInteger(options) {
             if (typeof input === 'string')
                 output = parseFloat(input);
             else if (typeof input === 'bigint') {
-                output = Number(input);
-                if (input === BigInt(output))
-                    input = output;
+                const n = Number(input);
+                if (input !== BigInt(n)) {
+                    context.fail(_this, `Value must be a valid integer value`, input);
+                    return;
+                }
+                output = n;
             }
         }
         if (typeof output === 'number' &&

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

@@ -12,9 +12,12 @@ export function isNumber(options) {
             if (typeof input === 'string')
                 output = parseFloat(input);
             else if (typeof input === 'bigint') {
-                output = Number(input);
-                if (input === BigInt(output))
-                    return output;
+                const n = Number(input);
+                if (input !== BigInt(n)) {
+                    context.fail(_this, `Value must be a number`, input);
+                    return;
+                }
+                output = n;
             }
         }
         if (typeof output === 'number' && !isNaN(output))

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

@@ -1,7 +1,12 @@
 import { type Type, type ValidationOptions, type Validator as Validator_ } from '../../core/index.js';
 /**
- * Validates the object according to schema
- * Converts properties according to schema rules if the coerce option is set to 'true'.
+ * Validates the object according to schema. Converts properties according to
+ * schema rules if the coerce option is set to 'true'. Supports
+ * `additionalFields` (allow/strip/reject/validate unknown properties -
+ * defaults to allowing them when no schema is given, and rejecting them
+ * otherwise), `caseInSensitive` (match property names ignoring case), and
+ * `detectCircular` (guard against circular references when the schema
+ * validates itself, e.g. via `forwardRef`).
  * @validator isObject
  */
 export declare function isObject<T extends object = object, I = object | string>(schema?: isObject.Schema, options?: isObject.Options<T>): isObject.Validator<T, I>;

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

@@ -1,8 +1,13 @@
 import { postValidation, preValidation } from '../../constants.js';
 import { isValidator, validator, } from '../../core/index.js';
 /**
- * Validates the object according to schema
- * Converts properties according to schema rules if the coerce option is set to 'true'.
+ * Validates the object according to schema. Converts properties according to
+ * schema rules if the coerce option is set to 'true'. Supports
+ * `additionalFields` (allow/strip/reject/validate unknown properties -
+ * defaults to allowing them when no schema is given, and rejecting them
+ * otherwise), `caseInSensitive` (match property names ignoring case), and
+ * `detectCircular` (guard against circular references when the schema
+ * validates itself, e.g. via `forwardRef`).
  * @validator isObject
  */
 export function isObject(schema, options) {
@@ -66,6 +71,14 @@ export function isObject(schema, options) {
             context.root = context.root || ctorName || '';
         const location = context.location || '';
         const processedSchemaKeys = {};
+        // Reused across every property instead of allocated per-property.
+        // `scope`/`context` never change between properties, so they're set
+        // once; `location`/`property` are reassigned every iteration, and
+        // `label` is reassigned-or-deleted every iteration (see below) so no
+        // field can leak from a previous property into the next one.
+        const subCtx = context.extend();
+        subCtx.scope = output;
+        subCtx.context = ctorName;
         // Iterate object keys and perform rules
         for (i = 0; i < l; i++) {
             inputKey = keys[i];
@@ -78,21 +91,25 @@ export function isObject(schema, options) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
                 processedSchemaKeys[schemaKey] = true;
-                const subCtx = context.extend();
-                subCtx.scope = output;
-                subCtx.context = ctorName;
                 subCtx.location = location + (location ? '.' : '') + schemaKey;
                 subCtx.property = schemaKey;
-                if (propertyOptions[schemaKey]?.label) {
-                    subCtx.label = propertyOptions[schemaKey]?.label;
-                }
-                v = _propRule(v, subCtx);
+                const propLabel = propertyOptions[schemaKey]?.label;
+                // Assign (not just skip) when there's no per-property label, so a
+                // label left over from a previous property can't leak in - but
+                // `delete` rather than `= undefined`, so the lookup still falls
+                // through to an inherited label from the parent context, exactly
+                // like the original per-iteration `context.extend()` did.
+                if (propLabel)
+                    subCtx.label = propLabel;
+                else
+                    delete subCtx.label;
+                v = _propRule(v, undefined, subCtx);
             }
             else if (v !== undefined) {
                 if (!additionalFields)
                     continue;
                 if (additionalFields === 'error') {
-                    context.fail(_propRule, `${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`, v);
+                    context.fail(_this, `${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`, v);
                 }
             }
             if (v !== undefined) {

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

@@ -19,19 +19,23 @@ export function isRecord(keyRule, valueRule, options) {
         let k;
         let v;
         const out = {};
+        // Set directly on the (already reused) context instead of passed as
+        // a fresh {onFail} options object on every call - `k` is read at call
+        // time (synchronously, before it's reassigned below), so a single
+        // closure works for the whole loop. This also lets both calls below
+        // pass `undefined` for options, which the validator wrapper needs in
+        // order to skip a needless context.extend() when the key/value rule
+        // has no options of its own.
+        keyContext.onFail = (issue) => `${k} is not a valid key. ` + issue.message;
         for (i = 0; i < l; i++) {
             k = keys[i];
             v = input[k];
             // Validate key
-            k = keyRule(k, {
-                onFail(issue) {
-                    return `${k} is not a valid key. ` + issue.message;
-                },
-            }, keyContext);
+            k = keyRule(k, undefined, keyContext);
             // Validate value
             valueContext.property = k;
             valueContext.location = location + (location ? '.' : '') + k;
-            v = valueRule(v, valueContext);
+            v = valueRule(v, undefined, valueContext);
             out[k] = v;
         }
         return context.errors.length ? undefined : out;

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

@@ -1,7 +1,7 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
  * Validates if the value is a string.
- * Converts input value to string if the oerce option is set to 'true'.
+ * Converts input value to string if the coerce option is set to 'true'.
  * @validator isString
  */
 export declare function isString(options?: isString.Options): import("../../core/validator.js").Validator<string, unknown, import("../../core/types.js").ExecutionOptions>;

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

@@ -1,7 +1,7 @@
 import { validator, } from '../../core/index.js';
 /**
  * Validates if the value is a string.
- * Converts input value to string if the oerce option is set to 'true'.
+ * Converts input value to string if the coerce option is set to 'true'.
  * @validator isString
  */
 export function isString(options) {

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

@@ -5,29 +5,29 @@ export function isTuple(items, options) {
         let output = input;
         if (output != null && coerce && !Array.isArray(output))
             output = [output];
-        if (!Array.isArray(input)) {
+        if (!Array.isArray(output)) {
             context.fail(_this, `Value must be a tuple`, input);
             return;
         }
+        const nl = items.length;
+        if (output.length !== nl) {
+            context.fail(_this, `Value must be a tuple of length ${nl}`, input);
+            return;
+        }
         const location = context.location || '';
         let itemRule;
         let i;
         let v;
-        const l = output.length;
         const out = [];
-        const nl = items.length;
         const itemContext = context.extend();
-        for (i = 0; i < l && i < nl; i++) {
+        for (i = 0; i < nl; i++) {
             itemRule = items[i];
             itemContext.scope = output;
-            itemContext.label = context.label
-                ? context.label + `[${i}]`
-                : undefined;
             itemContext.index = i;
             itemContext.location = location + '[' + i + ']';
             itemContext.label =
-                (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
-            v = itemRule(output[i], itemContext);
+                (context.label || context.property || 'Value at ') + `[${i}]`;
+            v = itemRule(output[i], undefined, itemContext);
             out.push(v);
         }
         return context.errors.length ? undefined : out;

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

@@ -1,6 +1,9 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if the value is undefined
+ * Validates if the value is undefined.
+ * If `coerce` is `true`, always succeeds and returns `undefined` regardless
+ * of the input value - "coerce" here means "force to undefined", not
+ * "convert values that merely look like undefined".
  * @validator isUndefined
  */
 export declare function isUndefined(options?: isUndefined.Options): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;

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

@@ -1,6 +1,9 @@
 import { validator, } from '../../core/index.js';
 /**
- * Validates if the value is undefined
+ * Validates if the value is undefined.
+ * If `coerce` is `true`, always succeeds and returns `undefined` regardless
+ * of the input value - "coerce" here means "force to undefined", not
+ * "convert values that merely look like undefined".
  * @validator isUndefined
  */
 export function isUndefined(options) {

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

@@ -10,8 +10,9 @@ export function allOf(rules, options) {
         const l = rules.length;
         for (i = 0; i < l; i++) {
             c = rules[i];
-            c(input, context || options);
+            // See pipe.ts for why context goes in the 3rd slot, not the 2nd.
+            c(input, undefined, context);
         }
         return input;
-    });
+    }, options);
 }

package/rules/utility-rules/exists.js

@@ -7,7 +7,8 @@ export function exists(options) {
     return validator(exists.name, (input, context, _this) => {
         if (input !== undefined ||
             (context.scope &&
-                Object.getOwnPropertyDescriptor(context.scope, input))) {
+                context.property != null &&
+                Object.getOwnPropertyDescriptor(context.scope, context.property))) {
             return input;
         }
         context.fail(_this, `{{label}} must exist`, input);

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

@@ -1,5 +1,5 @@
 /**
- * Check if value is not nullish before calling nested rule
- * @validator required
+ * Ignores the input and always returns the given constant value.
+ * @validator fixed
  */
 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

@@ -1,7 +1,7 @@
 import { validator } from '../../core/index.js';
 /**
- * Check if value is not nullish before calling nested rule
- * @validator required
+ * Ignores the input and always returns the given constant value.
+ * @validator fixed
  */
 export function fixed(value) {
     return validator(fixed.name, () => {

package/rules/utility-rules/get-length.d.ts

@@ -4,7 +4,8 @@ type ExtractLengthInput = string | any[] | ArrayBuffer | {
     size: number;
 };
 /**
- * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * Returns length of an Array, String, ArrayBuffer, Buffer, Set, Map, or any
+ * object with a "length" or "size" property.
  * @validator getLength
  */
 export declare function getLength(): import("../../core/validator.js").Validator<number, ExtractLengthInput, import("../../core/types.js").ExecutionOptions>;

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

@@ -1,6 +1,7 @@
 import { validator } from '../../core/index.js';
 /**
- * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * Returns length of an Array, String, ArrayBuffer, Buffer, Set, Map, or any
+ * object with a "length" or "size" property.
  * @validator getLength
  */
 export function getLength() {

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

@@ -1,8 +1,8 @@
 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
+ * Makes the sub-rule nullable (accepts undefined or null)
+ * @validator nullable
  */
 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 {

package/rules/utility-rules/nullable.js

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

package/rules/utility-rules/one-of.d.ts

@@ -1,7 +1,10 @@
 import type { ValidationOptions, Validator } from '../../core/index.js';
 type DiscriminatorRecord = Record<string, Validator>;
 /**
- *
+ * Tries each rule against the input in order and returns the first one that
+ * passes. An optional discriminator record narrows which rule to try based
+ * on a distinguishing field of the input.
+ * @validator oneOf
  */
 export declare function oneOf(rules: (Validator | [Validator, DiscriminatorRecord])[], options?: oneOf.Options): Validator<any, any, import("../../core/types.js").ExecutionOptions>;
 export declare namespace oneOf {

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

@@ -1,6 +1,9 @@
 import { validator } from '../../core/index.js';
 /**
- *
+ * Tries each rule against the input in order and returns the first one that
+ * passes. An optional discriminator record narrows which rule to try based
+ * on a distinguishing field of the input.
+ * @validator oneOf
  */
 export function oneOf(rules, options) {
     const l = rules.length;
@@ -10,8 +13,21 @@ export function oneOf(rules, options) {
         let discriminator;
         let v;
         let passed = false;
-        // Mock fail method to prevent errors
-        context.fail = () => (passed = false);
+        // Every candidate failing is normal control flow here (that's how
+        // "try the next one" works), so a candidate's own context.fail must
+        // not throw or accumulate into the real error list. But swallowing it
+        // completely would hide the *reason* every candidate failed - including
+        // a genuine bug in a candidate rule, which would otherwise look
+        // identical to "the input just didn't match". So the mock still
+        // records the last failure's message, and it's reported directly as
+        // the final error (oneOf can only report one message anyway) instead
+        // of being discarded in favor of a generic one.
+        let lastFailMessage;
+        context.fail = (_rule, message) => {
+            passed = false;
+            lastFailMessage =
+                message instanceof Error ? message.message : String(message);
+        };
         for (i = 0; i < l; i++) {
             passed = true;
             if (Array.isArray(rules[i])) {
@@ -23,15 +39,29 @@ export function oneOf(rules, options) {
                     continue;
                 }
                 try {
-                    for (const k of Object.keys(discriminator)) {
-                        discriminator[k](input[k], context || options);
+                    const keys = Object.keys(discriminator);
+                    const len = keys.length;
+                    let j;
+                    let k;
+                    for (j = 0; j < len; j++) {
+                        k = keys[j];
+                        discriminator[k](input[k], undefined, context);
                         if (!passed)
                             break;
                     }
                     if (!passed)
                         continue;
                 }
-                catch {
+                catch (e) {
+                    // A discriminator/rule that throws directly (bypassing
+                    // context.fail entirely, e.g. a plain function rather than one
+                    // built with validator()) must still count as "this candidate
+                    // failed" - otherwise `passed` is left at its top-of-loop `true`
+                    // and, if this is the last candidate, oneOf would silently
+                    // return an unvalidated value instead of failing.
+                    passed = false;
+                    lastFailMessage =
+                        e?.message != null ? String(e.message) : String(e);
                     continue;
                 }
             }
@@ -39,18 +69,20 @@ export function oneOf(rules, options) {
                 c = rules[i];
             if (passed)
                 try {
-                    v = c(input, context || options);
+                    v = c(input, undefined, context);
                     if (passed)
                         break;
                 }
-                catch {
-                    //
+                catch (e) {
+                    passed = false;
+                    lastFailMessage =
+                        e?.message != null ? String(e.message) : String(e);
                 }
         }
         // Restore fail method
         delete context.fail;
         if (passed)
             return v;
-        context.fail(_this, `Value didn't match one of required rules`, input);
-    });
+        context.fail(_this, lastFailMessage || `Value didn't match one of required rules`, input);
+    }, options);
 }

package/rules/utility-rules/optional.js

@@ -7,6 +7,6 @@ export function optional(nested, options) {
     return validator(optional.name, (input, context) => {
         if (input === undefined)
             return input;
-        return nested(input, context);
+        return nested(input, undefined, context);
     }, options);
 }

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

@@ -1,6 +1,6 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 /**
- *
+ * Chains rules so each one's output becomes the next one's input.
  * @validator pipe
  */
 export declare function pipe<T>(rules: Validator[], options?: pipe.Options): Validator<T>;

package/rules/utility-rules/pipe.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- *
+ * Chains rules so each one's output becomes the next one's input.
  * @validator pipe
  */
 export function pipe(rules, options) {
@@ -14,7 +14,13 @@ export function pipe(rules, options) {
         const oldErrors = context.errors.length;
         for (i = 0; i < l; i++) {
             c = rules[i];
-            v = c(v, context);
+            // Pass context in its own (3rd) slot, not the 2nd (options) slot.
+            // The validator wrapper only extends the context when there's an
+            // actual options object to merge in - passing context as "options"
+            // instead makes it match `instanceof Context` and forces an
+            // unconditional (and needless, most of the time) extend() on every
+            // step.
+            v = c(v, undefined, context);
             if (returnIndex == null || i <= returnIndex)
                 returnValue = v;
             if (context.errors.length > oldErrors)

package/rules/utility-rules/required.js

@@ -11,6 +11,6 @@ export function required(nested, options) {
             context.fail(_this, `Value required`, input);
             return;
         }
-        return nested(input, context);
+        return nested(input, undefined, context);
     }, options);
 }

package/factories.d.ts

@@ -1 +0,0 @@
-export * from './rules/index.js';

package/factories.js

@@ -1 +0,0 @@
-export * from './rules/index.js';

package/helpers/object.utils.d.ts

@@ -1,2 +0,0 @@
-export declare function omitKeys<T extends object, K extends keyof T>(o: T, keys: K[]): Omit<T, K>;
-export declare function pickKeys<T extends object, K extends keyof T>(o: T, keys: K[]): Pick<T, K>;

package/helpers/object.utils.js

@@ -1,14 +0,0 @@
-export function omitKeys(o, keys) {
-    return Object.keys(o).reduce((a, k) => {
-        if (!keys.includes(k))
-            a[k] = o[k];
-        return a;
-    }, {});
-}
-export function pickKeys(o, keys) {
-    return Object.keys(o).reduce((a, k) => {
-        if (keys.includes(k))
-            a[k] = o[k];
-        return a;
-    }, {});
-}