arstotzka 0.12.0 → 0.13.0

package/index.js

@@ -7,7 +7,8 @@ export const ERRORS = {
 	notArray: "Tried using ARRAY_OF constraint on non-array value",
 	targetIsNull: "Passed object or array item is null",
 	functionExpected: "Expected function as dynamic constraint",
-	objectExpected: "Expected object"
+	objectExpected: "Expected object",
+	anyFailed: "None of ANY_OF constraints are met"
 };
 
 export const OPTIONAL = Symbol();
@@ -17,6 +18,18 @@ export function ARRAY_OF(constraints){
 	}
 	return constraint(FC_ARRAY, null, constraints);
 }
+export function ANY_OF(constraints){
+	if (arguments.length > 1){
+		return constraint(FC_ANY, null, Array.from(arguments));
+	} else {
+		if (Array.isArray(constraints)){
+			return constraint(FC_ANY, null, constraints);
+		} else {
+			return constraint(FC_ANY, null, [constraints]);
+		}
+	}
+	
+}
 export function DYNAMIC(constraints){
 	return constraint(FC_DYNAMIC, null, constraints);
 }
@@ -25,6 +38,7 @@ const TYPE = t => x => typeof x == t;
 
 const CONSTRAINT = Symbol();
 const FC_ARRAY = Symbol(); // https://www.youtube.com/watch?v=qSqXGeJJBaI
+const FC_ANY = Symbol();
 const FC_DYNAMIC = Symbol();
 const FC_NESTED = Symbol();
 
@@ -159,6 +173,28 @@ function checkValue(propertyName, value, constraints, options){
 
 				break;
 			}
+			case FC_ANY: {
+				const subSchemas = constraint.expected;
+
+				const subErrors = [];
+				let passed = false;
+				let counter = 0;
+
+				for (let subSchema of subSchemas){
+					const [subConstraints, flags] = parseSchema(subSchema);
+					const caseErrors = checkValue(`${propertyName}.<any#${counter}>`, value, subConstraints, options);
+					++counter;
+					subErrors.push(caseErrors);
+					if (caseErrors.length == 0) {
+						passed = true;
+						break;
+					}
+				}
+
+				if (!passed) errors.push(error(propertyName, "anyFailed", undefined, subErrors));
+
+				break;
+			}
 			case FC_DYNAMIC: {
 				const constraintCallback = constraint.expected;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arstotzka",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "JS validation utility",
   "main": "index.js",
   "type": "module",

package/readme.md

@@ -32,12 +32,17 @@ console.log(Arstotzka.validate(goodData, schema, {allowExtraProperties: false}))
 
 ### Import:
 Arstotzka is an ES6 module, so:
-`import * as Arstotzka from "arstotzka";`
+```
+import * as Arstotzka from "arstotzka";
+```
 or, if you are okay with polluting namespace:
-`import { validate, OPTIONAL, ARRAY_OF, DYNAMIC } from "arstotzka";`
+```
+import { validate, OPTIONAL, ARRAY_OF, ANY_OF, DYNAMIC } from "arstotzka";
+```
+
 
 ### Schema format:
-Schema is a value that can be a
+Schema is a value that can be either of
 - **string**: such schema will make validator check coresponding value's type with [typeof operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof), with exception of "array" constraint -- validator will [treat this type](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) as special case;
 `"string"`, `"number"`, `"array"`
 
@@ -51,17 +56,24 @@ Schema is a value that can be a
 `["string", x => x != x.trim()]`, `["number", x => x >= 0, x => x % 1 === 0]`
 
 - **Arstotzka.ARRAY_OF()**: the function accepts any of above and returns a special constraint appliable to an array of values;
-- `Arstotzka.ARRAY_OF("number")`, `Arstotzka.ARRAY_OF({id: "number", text: "string"})`, `Arstotzka.ARRAY_OF(["number", x => x > 0])`, `Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number"))`
+`Arstotzka.ARRAY_OF("number")`, `Arstotzka.ARRAY_OF({id: "number", text: "string"})`, `Arstotzka.ARRAY_OF(["number", x => x > 0])`, `Arstotzka.ARRAY_OF(Arstotzka.ARRAY_OF("number"))`
+
+- **Arstotzka.ANY_OF()**: the function accepts array or vararg of schemas and returns a special constraint, which will produce a specific error only if every provided schema is violated;
+`Arstotzka.ANY_OF(["number", ["string", x => !isNaN(parseInt(x))]])`
 
 - **Arstotzka.DYNAMIC()**: the function accepts a callback that should return a valid schema, allowing to define schema at runtime;
-- `Arstotzka.DYNAMIC(x => dynSchema[x.type])`
+`Arstotzka.DYNAMIC(x => dynSchema[x.type])`
+
+- **Arstotzka.OPTIONAL**: unlike others, this schema doesn't imply any requirements, but prevents validator from logging an error in case it's property is not present in target object;
+
+Applying a schema to a property that is an object can be done by combining **object** schema with anything via **array** schema;
 
-Applying a schema to a property that is an object can be done by combining **object** schema with anything via **array** schema:
 
 ### Available options:
 - **allErrors** (default is `true`) : If false, will return errors as soon as encountered, interrupting validation
 - **allowExtraProperties** (default is `true`) : If false, adds specific error to a list for every property of target object not present in schema
 
+
 ### Error format
 ```
 { // Example error item:
@@ -75,5 +87,6 @@ Applying a schema to a property that is an object can be done by combining **obj
 
 All error ids and messages can be found at `Arstotzka.ERRORS`
 
+
 ## License
 Shared under WTFPL license.

package/usage.js

@@ -91,13 +91,19 @@ const testSubject2 = {
 	zero: "0"
 };
 
+const parseableIntSchema = Arstotzka.ANY_OF(
+	"number",
+	["string", x => !isNaN(parseInt(x))]
+);
+
 const tests = [
 	[null, {x: "number"}],
 	[testSubject0, schema], // Only an error caused by invalid validator
 	[testSubject1, schema], // Full of errors
 	["miles", "string"],    // Any value can be validated, not only objects
 	[7, "string"],
-	[testSubject2, schema1]
+	[testSubject2, schema1],
+	["7", parseableIntSchema]
 ];
 
 const TEST_SELECTOR = 0;