valgen 4.0.0-alpha.6 → 4.0.0

package/CHANGELOG.md

@@ -1,6 +1,17 @@
-# v4.0.0-alpha.1
-[2023-06-04]
+# v4.0.0
+[2023-08-17]
 
 ### Changes
 
 * Initial release of v4.0.0-alpha.1 ([`499af8e`](https://github.com/panates/valgen/commit/499af8eed81feeacb4bba5c254fbf1ede3933564))
+* Implemented all initial validators and tests ([`0ff5c5c`](https://github.com/panates/valgen/commit/0ff5c5c28aa59b44de90d016e8c056c26b3b479d))
+* Updated dependencies ([`804e00c`](https://github.com/panates/valgen/commit/804e00c3fcf344f4dcdb96efe0fc94ea3521cb92))
+* Better error handling ([`91dae2f`](https://github.com/panates/valgen/commit/91dae2f260f1d02ff5ed418f3247b452c1fed214))
+* Updated deps ([`df1cb70`](https://github.com/panates/valgen/commit/df1cb700a3799f09305af774c05ca534e5f88870))
+* Added isBigint validator ([`87ba007`](https://github.com/panates/valgen/commit/87ba00753dc018a4bd06492ec99fa37967046c58))
+* Fixed isObject coerce issue ([`47c7d4e`](https://github.com/panates/valgen/commit/47c7d4ed2d0e483788e939b357995a156ac3b7bc))
+* Improved isDateString ([`59d0d14`](https://github.com/panates/valgen/commit/59d0d14909132a502a9880cc11b9303897a3c79a))
+* Updated dayjs ([`e212dd2`](https://github.com/panates/valgen/commit/e212dd2834a07015fcceede3bf211f2a9db11eb6))
+* Updated deps ([`d20588e`](https://github.com/panates/valgen/commit/d20588eaa51be7547655d3494bb42e35cb6effa8))
+* Updated deps ([`82a2c0d`](https://github.com/panates/valgen/commit/82a2c0dc36c9cc54667231e88dfec6521097a157))
+* Fixed isObject coerce issue ([`b79833b`](https://github.com/panates/valgen/commit/b79833ba032494a18a91b1569da2d244f3c4c4b9))

package/cjs/core/context.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
+const omit_undefined_js_1 = require("../helpers/omit-undefined.js");
 const constants_js_1 = require("./constants.js");
 const validation_error_js_1 = require("./validation-error.js");
 const VARIABLE_REPLACE_PATTERN = /{{([^}]*)}}/g;
 const OPTIONAL_VAR_PATTERN = /^([^?]+)(?:\||(.*))?$/;
 class Context {
-    constructor(rule, options) {
+    constructor(options) {
         this.errors = [];
-        this.input = {};
-        this.rule = rule;
         if (options?.maxErrors != null)
             this.maxErrors = options.maxErrors;
         if (typeof options?.onFail === 'function')
@@ -17,34 +16,43 @@ class Context {
         if (options?.coerce != null)
             this.coerce = options?.coerce;
     }
-    failure(message) {
-        const issue = (typeof message === 'object'
-            ? { ...message, message: message.message }
-            : { message: '' + message });
-        issue.rule = this.rule.id;
-        Object.assign(issue, this.input);
-        if (this.onFail) {
+    fail(rule, message, value, details) {
+        const issue = (0, omit_undefined_js_1.omitUndefined)({
+            message: message instanceof Error ? message.message : String(message),
+            rule: rule.id,
+            root: this.root,
+            location: this.location,
+            context: this.context,
+            property: this.property,
+            index: this.index,
+            label: this.label,
+            value,
+            ...details
+        });
+        issue.value = value;
+        const onFail = this.onFail || rule[constants_js_1.kOptions].onFail;
+        if (onFail) {
             const proto = Object.getPrototypeOf(this);
-            const x = this.onFail(issue, this, proto.onFail);
+            const superOnFail = proto.onFail !== onFail ? proto.onFail : undefined;
+            const x = onFail(issue, this, superOnFail);
             if (!x)
                 return;
-            if (typeof x === 'object') {
-                delete x.id;
-                delete x.input;
+            if (typeof x === 'object')
                 Object.assign(issue, x);
-            }
             else
                 issue.message = String(x);
         }
-        issue.message = ('' + issue.message).replace(VARIABLE_REPLACE_PATTERN, (x, g) => {
+        issue.message = ('' + issue.message)
+            .replace(VARIABLE_REPLACE_PATTERN, (x, g) => {
             const m = OPTIONAL_VAR_PATTERN.exec(g);
             if (!m)
                 return x;
             const k = m[1];
-            const v = this.input[k] ??
-                (m[1] === 'label' ? this.input.property : undefined);
+            let v = issue[k];
+            if (!v && m[1] === 'label' && (this.label || this.property))
+                v = '`' + (this.label || this.property) + '`';
             if (v != null)
-                return '`' + v + '`';
+                return v;
             if (m[2])
                 return m[2];
             return m[1] === 'label' ? 'Value' : x;
@@ -53,12 +61,10 @@ class Context {
         if (this.errors.length >= (this.maxErrors ?? Infinity))
             throw new validation_error_js_1.ValidationError(this.errors);
     }
-    extend(rule, options) {
-        const extended = new Context(rule, { onFail: undefined, ...rule[constants_js_1.kOptions], ...options });
+    extend(options) {
+        const extended = new Context({ onFail: undefined, ...options });
         Object.setPrototypeOf(extended, this);
         delete extended.errors;
-        extended.parent = this;
-        extended.root = this.root || this;
         return extended;
     }
 }

package/cjs/core/validator.js

@@ -23,20 +23,21 @@ function validator(arg0, arg1, arg2) {
     id = id || fn.name || 'unnamed-rule';
     const name = fn.name || (0, string_utils_js_1.camelCase)(id);
     const _rule = ({
-        [name](input, options, parent) {
-            const ctx = parent ? parent.extend(_rule, options) : new context_js_1.Context(_rule, options);
+        [name](input, options) {
+            const ctx = options instanceof context_js_1.Context ? options : undefined;
+            const opts = (ctx ? undefined : options);
+            const context = ctx || new context_js_1.Context(opts);
             let value;
             try {
-                ctx.input.value = input;
-                value = fn(input, ctx, _rule);
+                value = fn(input, context, _rule);
             }
             catch (e) {
-                if (!parent && e instanceof validation_error_js_1.ValidationError)
+                if (e instanceof validation_error_js_1.ValidationError)
                     throw e;
-                ctx.failure(e);
+                context.fail(_rule, e, input);
             }
-            if (!parent && ctx.errors.length)
-                throw new validation_error_js_1.ValidationError(ctx.errors);
+            if (!ctx && context.errors.length)
+                throw new validation_error_js_1.ValidationError(context.errors);
             return value;
         }
     })[name];

package/cjs/helpers/omit-undefined.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omitUndefined = void 0;
+function omitUndefined(obj, recursive) {
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    for (const k of Object.keys(obj)) {
+        if (obj[k] === undefined)
+            delete obj[k];
+        else if (recursive && typeof obj[k] === 'object')
+            omitUndefined(obj[k]);
+    }
+    return obj;
+}
+exports.omitUndefined = omitUndefined;

package/cjs/rules/is-array.js

@@ -8,29 +8,31 @@ const index_js_1 = require("../core/index.js");
  * @validator isArray
  */
 function isArray(itemValidator, options) {
-    return (0, index_js_1.validator)('isArray', function (input, context) {
+    return (0, index_js_1.validator)('isArray', function (input, context, _this) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.failure(`{{label}} is not an array`);
+            context.fail(_this, `{{label}} is not an array`, input);
             return;
         }
         if (!itemValidator)
             return input;
-        const location = context.input.location || '';
-        const itemContext = context.extend(itemValidator);
+        const location = context.location || '';
+        const itemContext = context.extend();
         let i;
         let v;
         const l = input.length;
         const out = [];
         for (i = 0; i < l; i++) {
             v = input[i];
-            itemContext.input.value = v;
-            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
-                `[${i}]`;
-            itemContext.input.property = i;
-            itemContext.input.location = location + '[' + i + ']';
-            out.push(itemValidator[index_js_1.kValidatorFn](v, itemContext, itemValidator));
+            itemContext.scope = input;
+            itemContext.location = location + '[' + i + ']';
+            itemContext.label = context.label
+                ? context.label + `[${i}]`
+                : `Item at (${i})`;
+            itemContext.index = i;
+            v = itemValidator(v, itemContext);
+            out.push(v);
         }
         return out;
     }, options);

package/cjs/rules/is-bigint.js

@@ -8,14 +8,14 @@ const index_js_1 = require("../core/index.js");
  * @validator isNumber
  */
 function isBigint(options) {
-    return (0, index_js_1.validator)('isBigint', function (input, context) {
+    return (0, index_js_1.validator)('isBigint', function (input, context, _this) {
         if (input != null && typeof input !== 'bigint' && context.coerce) {
             if (typeof input === 'string' || typeof input === 'number')
                 input = BigInt(input);
         }
         if (typeof input === 'bigint')
             return input;
-        context.failure(`{{label}} is not a valid BigInt`);
+        context.fail(_this, `{{label}} is not a valid BigInt`, input);
     }, options);
 }
 exports.isBigint = isBigint;

package/cjs/rules/is-boolean.js

@@ -10,7 +10,7 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  * @validator isBoolean
  */
 function isBoolean(options) {
-    return (0, index_js_1.validator)('isBoolean', function (input, context) {
+    return (0, index_js_1.validator)('isBoolean', function (input, context, _this) {
         if (input != null && typeof input !== 'boolean' && context.coerce) {
             if (typeof input === 'string') {
                 if (TRUE_PATTERN.test(input))
@@ -24,7 +24,7 @@ function isBoolean(options) {
         }
         if (typeof input === 'boolean')
             return input;
-        context.failure(`{{label}} is not a valid boolean`);
+        context.fail(_this, `{{label}} is not a valid boolean`, input);
     }, options);
 }
 exports.isBoolean = isBoolean;

package/cjs/rules/is-date.js

@@ -15,7 +15,7 @@ dayjs_1.default.extend(customParseFormat_1.default);
  * @validator isDate
  */
 function isDate(options) {
-    return (0, index_js_1.validator)('isDate', function (input, context) {
+    return (0, index_js_1.validator)('isDate', function (input, context, _this) {
         if (input != null && !(input instanceof Date) && context.coerce) {
             if (typeof input === 'string') {
                 const d = (0, dayjs_1.default)(input, options?.format);
@@ -27,13 +27,10 @@ function isDate(options) {
         }
         if (input && input instanceof Date && !isNaN(input.getTime()))
             return input;
-        context.failure({
-            message: `{{label}} is not a valid Date instance` +
-                (context.coerce
-                    ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
-                    : ''),
-            format: options?.format
-        });
+        context.fail(_this, `{{label}} is not a valid Date instance` +
+            (context.coerce
+                ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
+                : ''), input, { format: options?.format });
     }, (0, object_utils_js_1.omitKeys)(options || {}, ['format']));
 }
 exports.isDate = isDate;
@@ -45,7 +42,7 @@ exports.isDate = isDate;
 function isDateString(options) {
     const inputFormat = options?.format;
     const coerceFormat = Array.isArray(options?.format) ? options?.format[0] : options?.format;
-    return (0, index_js_1.validator)('isDateString', function (input, context) {
+    return (0, index_js_1.validator)('isDateString', function (input, context, _this) {
         if (input instanceof Date) {
             const d = (0, dayjs_1.default)(input);
             if (d.isValid())
@@ -59,10 +56,7 @@ function isDateString(options) {
                 return input;
             }
         }
-        context.failure({
-            message: `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`,
-            format: options?.format
-        });
+        context.fail(_this, `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`, input, { format: options?.format });
     }, (0, object_utils_js_1.omitKeys)(options || {}, ['format']));
 }
 exports.isDateString = isDateString;

package/cjs/rules/is-empty.js

@@ -7,7 +7,7 @@ const index_js_1 = require("../core/index.js");
  * @validator isEmpty
  */
 function isEmpty(options) {
-    return (0, index_js_1.validator)('isEmpty', function (input, context) {
+    return (0, index_js_1.validator)('isEmpty', function (input, context, _this) {
         if (input != null) {
             if (typeof input === 'string') {
                 if (!input)
@@ -30,7 +30,7 @@ function isEmpty(options) {
                     return input;
             }
         }
-        context.failure(`{{label}} is not empty`);
+        context.fail(_this, `{{label}} is not empty`, input);
     }, options);
 }
 exports.isEmpty = isEmpty;
@@ -39,7 +39,7 @@ exports.isEmpty = isEmpty;
  * @validator isNotEmpty
  */
 function isNotEmpty(options) {
-    return (0, index_js_1.validator)('isNotEmpty', function (input, context) {
+    return (0, index_js_1.validator)('isNotEmpty', function (input, context, _this) {
         if (input != null) {
             if (typeof input === 'string') {
                 if (input)
@@ -62,7 +62,7 @@ function isNotEmpty(options) {
                     return input;
             }
         }
-        context.failure(`{{label}} is empty`);
+        context.fail(_this, `{{label}} is empty`, input);
     }, options);
 }
 exports.isNotEmpty = isNotEmpty;

package/cjs/rules/is-enum.js

@@ -18,13 +18,10 @@ function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return (0, index_js_1.validator)('isEnum', function (input, context) {
+    return (0, index_js_1.validator)('isEnum', function (input, context, _this) {
         if (input != null && valObj[typeof input === 'string' && caseInSensitive ? input.toUpperCase() : input])
             return input;
-        context.failure({
-            message: `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`,
-            enum: enumName
-        });
+        context.fail(_this, `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`, input, { enum: enumName });
     }, options);
 }
 exports.isEnum = isEnum;

package/cjs/rules/is-integer.js

@@ -8,7 +8,7 @@ const index_js_1 = require("../core/index.js");
  * @validator isInteger
  */
 function isInteger(options) {
-    return (0, index_js_1.validator)('isInteger', function (input, context) {
+    return (0, index_js_1.validator)('isInteger', function (input, context, _this) {
         if (input != null && typeof input !== 'number' && context.coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
@@ -20,7 +20,7 @@ function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.failure(`{{label}} is not a valid integer number`);
+        context.fail(_this, `{{label}} is not a valid integer number`, input);
     }, options);
 }
 exports.isInteger = isInteger;

package/cjs/rules/is-matches.js

@@ -9,16 +9,12 @@ const index_js_1 = require("../core/index.js");
 function isMatches(format, options) {
     const regExp = format instanceof RegExp ? format : new RegExp(format);
     const formatName = options?.formatName;
-    return (0, index_js_1.validator)('matches', function (input, context) {
+    return (0, index_js_1.validator)('matches', function (input, context, _this) {
         if (input == null)
             return;
         if (typeof input === 'string' && regExp.test(input))
             return input;
-        context.failure({
-            message: `{{label}} does not match ${formatName || 'requested'} format`,
-            format,
-            formatName
-        });
+        context.fail(_this, `{{label}} does not match ${formatName || 'requested'} format`, input, { format, formatName });
     }, options);
 }
 exports.isMatches = isMatches;

package/cjs/rules/is-null.js

@@ -7,10 +7,10 @@ const index_js_1 = require("../core/index.js");
  * @validator isNull
  */
 function isNull(options) {
-    return (0, index_js_1.validator)('isNull', function (input, context) {
+    return (0, index_js_1.validator)('isNull', function (input, context, _this) {
         if (input === null)
             return input;
-        context.failure(`{{label}} is not null`);
+        context.fail(_this, `{{label}} is not null`, input);
     }, options);
 }
 exports.isNull = isNull;
@@ -19,10 +19,10 @@ exports.isNull = isNull;
  * @validator isDefined
  */
 function isDefined(options) {
-    return (0, index_js_1.validator)('is-defined', function (input, context) {
+    return (0, index_js_1.validator)('is-defined', function (input, context, _this) {
         if (input !== undefined)
             return input;
-        context.failure(`{{label}} is not defined`);
+        context.fail(_this, `{{label}} is not defined`, input);
     }, options);
 }
 exports.isDefined = isDefined;
@@ -31,10 +31,10 @@ exports.isDefined = isDefined;
  * @validator isNotDefined
  */
 function isUndefined(options) {
-    return (0, index_js_1.validator)('isUndefined', function (input, context) {
+    return (0, index_js_1.validator)('isUndefined', function (input, context, _this) {
         if (input === undefined)
             return;
-        context.failure(`{{label}} defined`);
+        context.fail(_this, `{{label}} defined`, input);
     }, options);
 }
 exports.isUndefined = isUndefined;

package/cjs/rules/is-number.js

@@ -8,7 +8,7 @@ const index_js_1 = require("../core/index.js");
  * @validator isNumber
  */
 function isNumber(options) {
-    return (0, index_js_1.validator)('isNumber', function (input, context) {
+    return (0, index_js_1.validator)('isNumber', function (input, context, _this) {
         if (input != null && typeof input !== 'number' && context.coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
@@ -20,7 +20,7 @@ function isNumber(options) {
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.failure(`{{label}} is not a valid number`);
+        context.fail(_this, `{{label}} is not a valid number`, input);
     }, options);
 }
 exports.isNumber = isNumber;

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

@@ -11,14 +11,14 @@ const index_js_1 = require("../core/index.js");
  * @validator isObjectId
  */
 function isObjectId(options) {
-    return (0, index_js_1.validator)('isObjectId', function (input, context) {
+    return (0, index_js_1.validator)('isObjectId', function (input, context, _this) {
         if (input != null &&
             (_isObjectIdValue(input) ||
                 (typeof input === 'object' &&
                     typeof input.toHexString === 'function' &&
                     _isObjectIdValue(input.toHexString()))))
             return input;
-        context.failure(`{{label}} is not a valid ObjectId`);
+        context.fail(_this, `{{label}} is not a valid ObjectId`, input);
     }, options);
 }
 exports.isObjectId = isObjectId;

package/cjs/rules/is-object.js

@@ -31,9 +31,9 @@ function isObject(schema, options) {
         else
             throw new TypeError(`Invalid definition in validation schema (${k})`);
     });
-    const _rule = (0, index_js_1.validator)('isObject', function (input, context) {
+    const _rule = (0, index_js_1.validator)('isObject', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.failure(`{{label}} must be an object`);
+            context.fail(_this, `{{label}} is not an object`, input);
             return;
         }
         const keys = [...Object.keys(input), ...Object.keys(schema)];
@@ -52,8 +52,9 @@ function isObject(schema, options) {
                 return context.circMap.get(input);
             context.circMap.set(input, out);
         }
-        const rootName = context.root?.input.context;
-        const location = context.input.location || '';
+        if (context.root == null)
+            context.root = context.root || ctorName || '';
+        const location = context.location || '';
         const processedSchemaKeys = {};
         // Iterate object keys and perform rules
         for (i = 0; i < l; i++) {
@@ -66,23 +67,20 @@ function isObject(schema, options) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
                 processedSchemaKeys[schemaKey] = true;
-                const subCtx = context.extend(_propRule);
-                if (ctorName) {
-                    if (rootName && rootName !== ctorName)
-                        subCtx.input.root = rootName;
-                    subCtx.input.context = ctorName;
-                }
-                subCtx.input.value = v;
-                subCtx.input.label = propertyOptions[schemaKey]?.label || schemaKey;
-                subCtx.input.location = location + (location ? '.' : '') + schemaKey;
-                subCtx.input.property = schemaKey;
-                v = _propRule[index_js_1.kValidatorFn](v, subCtx, _propRule);
+                const subCtx = context.extend();
+                subCtx.scope = input;
+                subCtx.context = ctorName;
+                subCtx.location = location + (location ? '.' : '') + schemaKey;
+                subCtx.property = schemaKey;
+                if (propertyOptions[schemaKey]?.label)
+                    subCtx.label = propertyOptions[schemaKey]?.label;
+                v = _propRule(v, subCtx);
             }
             else if (v !== undefined) {
-                if (additionalFields === 'ignore')
-                    continue;
                 if (!additionalFields)
-                    context.failure(`${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`);
+                    continue;
+                if (additionalFields === 'error')
+                    context.fail(_propRule, `${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`, v);
             }
             if (v !== undefined)
                 out[propertyOptions[schemaKey]?.as || schemaKey] = v;

package/cjs/rules/is-record.js

@@ -8,14 +8,14 @@ const index_js_1 = require("../core/index.js");
  * @validator isRecord
  */
 function isRecord(keyRule, valueRule, options) {
-    return (0, index_js_1.validator)('isRecord', function (input, context) {
+    return (0, index_js_1.validator)('isRecord', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.failure(`{{label}} is not an object`);
+            context.fail(_this, `{{label}} is not an object`, input);
             return;
         }
-        const location = context.input.location || '';
-        const keyContext = context.extend(keyRule);
-        const valueContext = context.extend(valueRule);
+        const keyContext = context.extend();
+        const valueContext = context.extend();
+        const location = context.location || '';
         const keys = Object.keys(input);
         const l = keys.length;
         let i;
@@ -25,14 +25,14 @@ function isRecord(keyRule, valueRule, options) {
         for (i = 0; i < l; i++) {
             k = keys[i];
             v = input[k];
-            keyContext.input.value = k;
-            keyContext.input.property = '@' + k;
-            keyContext.input.location = location + (location ? '.@' : '@') + k;
-            k = keyRule[index_js_1.kValidatorFn](k, keyContext, keyRule);
-            valueContext.input.value = v;
-            valueContext.input.property = k;
-            valueContext.input.location = location + (location ? '.' : '') + k;
-            v = valueRule[index_js_1.kValidatorFn](v, valueContext, valueRule);
+            // Validate key
+            keyContext.property = '@' + k;
+            keyContext.location = location + (location ? '.@' : '@') + k;
+            k = keyRule(k, keyContext);
+            // Validate value
+            valueContext.property = k;
+            valueContext.location = location + (location ? '.' : '') + k;
+            v = valueRule(v, valueContext);
             out[k] = v;
         }
         return context.errors.length ? undefined : out;

package/cjs/rules/is-string.js

@@ -8,7 +8,7 @@ const index_js_1 = require("../core/index.js");
  * @validator isString
  */
 function isString(options) {
-    return (0, index_js_1.validator)('isString', function (input, context) {
+    return (0, index_js_1.validator)('isString', function (input, context, _this) {
         if (input != null && typeof input !== 'string' && context.coerce) {
             if (typeof input === 'object') {
                 if (typeof input.toJSON === 'function')
@@ -21,7 +21,7 @@ function isString(options) {
         }
         if (typeof input === 'string')
             return input;
-        context.failure(`{{label}} is not a string`);
+        context.fail(_this, `{{label}} is not a string`, input);
     }, options);
 }
 exports.isString = isString;

package/cjs/rules/is-tuple.js

@@ -3,28 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTuple = void 0;
 const index_js_1 = require("../core/index.js");
 function isTuple(items, options) {
-    return (0, index_js_1.validator)('isTuple', function (input, context) {
+    return (0, index_js_1.validator)('isTuple', function (input, context, _this) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.failure(`{{label}} is not a valid tuple`);
+            context.fail(_this, `{{label}} is not a tuple`, input);
             return;
         }
-        const location = context.input.location || '';
+        const location = context.location || '';
         let itemRule;
         let i;
+        let v;
         const l = input.length;
         const out = [];
         const nl = items.length;
+        const itemContext = context.extend();
         for (i = 0; i < l && i < nl; i++) {
             itemRule = items[i];
-            const itemContext = context.extend(itemRule);
-            itemContext.input.value = input[i];
-            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
+            itemContext.scope = input;
+            itemContext.label = context.label ? context.label + `[${i}]` : undefined;
+            itemContext.index = i;
+            itemContext.location = location + '[' + i + ']';
+            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') +
                 `[${i}]`;
-            itemContext.input.property = i;
-            itemContext.input.location = location + '[' + i + ']';
-            out.push(itemRule[index_js_1.kValidatorFn](input[i], itemContext, itemRule) ?? null);
+            v = itemRule(input[i], itemContext);
+            out.push(v);
         }
         return context.errors.length ? undefined : out;
     }, options);

package/cjs/rules/length.js

@@ -10,7 +10,7 @@ const range_js_1 = require("./range.js");
  */
 const extractLength = () => extractLengthRule;
 exports.extractLength = extractLength;
-const extractLengthRule = (0, index_js_1.validator)('extractLength', function (input, context) {
+const extractLengthRule = (0, index_js_1.validator)('extractLength', function (input, context, _this) {
     if (typeof input === 'string')
         return input.length;
     if (Array.isArray(input))
@@ -21,7 +21,7 @@ const extractLengthRule = (0, index_js_1.validator)('extractLength', function (i
         return input.length;
     if (input && typeof input === 'object' && typeof input.size === 'number')
         return input.size;
-    context.failure(`Unable to extract length of {{label}}`);
+    context.fail(_this, `Unable to extract length of {{label}}`, input);
 });
 /**
  * Checks the length is at least "minValue"