objectmodel 4.2.3 → 4.3.1

package/test/any-model.spec.cjs

@@ -1,69 +1,69 @@
-/* global QUnit, Any, Model, BasicModel, FunctionModel */
-
-QUnit.module("Any Model");
-
-QUnit.test("any model validation", function (assert) {
-	assert.ok(Any instanceof Model, "Any is instance of Model")
-	assert.ok(Any instanceof BasicModel, "Any is instance of BasicModel")
-	assert.ok(Any.test(undefined), "testing undefined")
-	assert.ok(Any.test(null), "testing null")
-	assert.ok(Any.test(0), "testing 0")
-	assert.ok(Any.test(1), "testing 1")
-	assert.ok(Any.test(""), "testing empty string")
-	assert.ok(Any.test("test"), "testing string")
-	assert.ok(Any.test(false), "testing false")
-	assert.ok(Any.test(true), "testing true")
-	assert.ok(Any.test({}), "testing object")
-	assert.ok(Any.test([]), "testing array")
-	assert.ok(Any.test(function () { }), "testing function")
-	assert.ok(Any.test(Symbol()), "testing symbol")
-})
-
-QUnit.test("any as objectmodel property", function (assert) {
-	let M = Model({ x: Any })
-	assert.ok(M({}) instanceof M, "testing no prop")
-	assert.ok(M({ x: undefined }).x === undefined, "testing undefined prop")
-	assert.ok(M({ x: null }).x === null, "testing null prop")
-	assert.ok(M({ x: 0 }).x === 0, "testing 0 prop")
-	assert.ok(M({ x: 1 }).x === 1, "testing 1 prop")
-	assert.ok(M({ x: false }).x === false, "testing false prop")
-	assert.ok(M({ x: "" }).x === "", "testing empty string prop")
-})
-
-QUnit.test("any for remaining function models arguments", function (assert) {
-	let Operation = FunctionModel(...Any).return(Number)
-	let add = Operation((...args) => args.reduce((total, n) => total + n, 0))
-	assert.strictEqual(add(), 0, "testing 0 args")
-	assert.strictEqual(add(1), 1, "testing 1 arg")
-	assert.strictEqual(add(1, 2), 3, "testing 2 args")
-	assert.strictEqual(add(1, 2, 3, 4, 5), 15, "testing N args")
-
-	let TwoArgsOrMore = FunctionModel(Number, Number, ...Any)
-	add = TwoArgsOrMore((...args) => args.reduce((total, n) => total + n, 0))
-	assert.throws(() => { add() }, /TypeError.*arguments\[0]/, 1, "testing 0 args with 2 required")
-	assert.throws(() => { add(1) }, /TypeError.*arguments\[1]/, 1, "testing 1 arg with 2 required")
-	assert.strictEqual(add(1, 2), 3, "testing 2 args with 2 required")
-	assert.strictEqual(add(1, 2, 3, 4, 5), 15, "testing N args with 2 required")
-})
-
-QUnit.test("any for typed remaining function models arguments", function (assert) {
-	let Operation = FunctionModel(...Any(Number)).return(Number)
-	let add = Operation((...args) => args.reduce((total, n) => total + n, 0))
-	assert.strictEqual(add(), 0, "testing 0 args")
-	assert.strictEqual(add(1), 1, "testing 1 arg")
-	assert.strictEqual(add(1, 2), 3, "testing 2 args")
-	assert.strictEqual(add(1, 2, 3, 4, 5), 15, "testing N args")
-	assert.throws(() => { add(1, 2, 3, "4") }, /TypeError.*arguments\[3]/, "testing invalid typed remaining arg")
-})
-
-QUnit.test("any model formatter", function (assert) {
-	assert.strictEqual(Any.toString(), "Any", "Any toString")
-	let Operation = FunctionModel(...Any).return(Number)
-	assert.strictEqual(Operation.toString(), "Function(...Any) => Number", "Any remaining toString")
-
-	let TwoArgsOrMore = FunctionModel(Number, Number, ...Any)
-	assert.strictEqual(TwoArgsOrMore.toString(), "Function(Number, Number, ...Any)", "Any remaining with other args toString")
-
-	Operation = FunctionModel(...Any(Number)).return(Number)
-	assert.strictEqual(Operation.toString(), "Function(...Number) => Number", "Any remaining with definition toString")
+/* global QUnit, Any, Model, BasicModel, FunctionModel */
+
+QUnit.module("Any Model");
+
+QUnit.test("any model validation", function (assert) {
+	assert.ok(Any instanceof Model, "Any is instance of Model")
+	assert.ok(Any instanceof BasicModel, "Any is instance of BasicModel")
+	assert.ok(Any.test(undefined), "testing undefined")
+	assert.ok(Any.test(null), "testing null")
+	assert.ok(Any.test(0), "testing 0")
+	assert.ok(Any.test(1), "testing 1")
+	assert.ok(Any.test(""), "testing empty string")
+	assert.ok(Any.test("test"), "testing string")
+	assert.ok(Any.test(false), "testing false")
+	assert.ok(Any.test(true), "testing true")
+	assert.ok(Any.test({}), "testing object")
+	assert.ok(Any.test([]), "testing array")
+	assert.ok(Any.test(function () { }), "testing function")
+	assert.ok(Any.test(Symbol()), "testing symbol")
+})
+
+QUnit.test("any as objectmodel property", function (assert) {
+	let M = Model({ x: Any })
+	assert.ok(M({}) instanceof M, "testing no prop")
+	assert.ok(M({ x: undefined }).x === undefined, "testing undefined prop")
+	assert.ok(M({ x: null }).x === null, "testing null prop")
+	assert.ok(M({ x: 0 }).x === 0, "testing 0 prop")
+	assert.ok(M({ x: 1 }).x === 1, "testing 1 prop")
+	assert.ok(M({ x: false }).x === false, "testing false prop")
+	assert.ok(M({ x: "" }).x === "", "testing empty string prop")
+})
+
+QUnit.test("any for remaining function models arguments", function (assert) {
+	let Operation = FunctionModel(...Any).return(Number)
+	let add = Operation((...args) => args.reduce((total, n) => total + n, 0))
+	assert.strictEqual(add(), 0, "testing 0 args")
+	assert.strictEqual(add(1), 1, "testing 1 arg")
+	assert.strictEqual(add(1, 2), 3, "testing 2 args")
+	assert.strictEqual(add(1, 2, 3, 4, 5), 15, "testing N args")
+
+	let TwoArgsOrMore = FunctionModel(Number, Number, ...Any)
+	add = TwoArgsOrMore((...args) => args.reduce((total, n) => total + n, 0))
+	assert.throws(() => { add() }, /TypeError.*arguments\[0]/, 1, "testing 0 args with 2 required")
+	assert.throws(() => { add(1) }, /TypeError.*arguments\[1]/, 1, "testing 1 arg with 2 required")
+	assert.strictEqual(add(1, 2), 3, "testing 2 args with 2 required")
+	assert.strictEqual(add(1, 2, 3, 4, 5), 15, "testing N args with 2 required")
+})
+
+QUnit.test("any for typed remaining function models arguments", function (assert) {
+	let Operation = FunctionModel(...Any(Number)).return(Number)
+	let add = Operation((...args) => args.reduce((total, n) => total + n, 0))
+	assert.strictEqual(add(), 0, "testing 0 args")
+	assert.strictEqual(add(1), 1, "testing 1 arg")
+	assert.strictEqual(add(1, 2), 3, "testing 2 args")
+	assert.strictEqual(add(1, 2, 3, 4, 5), 15, "testing N args")
+	assert.throws(() => { add(1, 2, 3, "4") }, /TypeError.*arguments\[3]/, "testing invalid typed remaining arg")
+})
+
+QUnit.test("any model formatter", function (assert) {
+	assert.strictEqual(Any.toString(), "Any", "Any toString")
+	let Operation = FunctionModel(...Any).return(Number)
+	assert.strictEqual(Operation.toString(), "Function(...Any) => Number", "Any remaining toString")
+
+	let TwoArgsOrMore = FunctionModel(Number, Number, ...Any)
+	assert.strictEqual(TwoArgsOrMore.toString(), "Function(Number, Number, ...Any)", "Any remaining with other args toString")
+
+	Operation = FunctionModel(...Any(Number)).return(Number)
+	assert.strictEqual(Operation.toString(), "Function(...Number) => Number", "Any remaining with definition toString")
 })

package/test/array-model.spec.cjs

@@ -16,7 +16,6 @@ QUnit.test("constructor && proto", function (assert) {
 	assert.ok(Arr.definition === Number, "test Array model prop definition");
 	assert.ok(typeof Arr.assertions === "object", "test Array model prop assertions");
 
-
 	assert.ok(ArrayModel(undefined) instanceof ArrayModel, "ArrayModel can receive undefined as argument");
 });
 

package/test/index.html

@@ -1,28 +1,28 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-	<meta charset="utf-8">
-	<title>QUnit - ObjectModel unit tests</title>
-	<link rel="stylesheet" href="lib/qunit.css">
-	<script src="lib/qunit.js"></script>
-	<script type="module">
-		import * as globals from "../dist/object-model.min.js"
-		Object.assign(window, globals)
-	</script>
-	<script src="model.spec.cjs"></script>
-	<script src="basic-model.spec.cjs"></script>
-	<script src="any-model.spec.cjs"></script>
-	<script src="object-model.spec.cjs"></script>
-	<script src="array-model.spec.cjs"></script>
-	<script src="function-model.spec.cjs"></script>
-	<script src="map-model.spec.cjs"></script>
-	<script src="set-model.spec.cjs"></script>
-</head>
-
-<body>
-	<div id="qunit"></div>
-	<div id="qunit-fixture"></div>
-</body>
-
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+	<meta charset="utf-8">
+	<title>QUnit - ObjectModel unit tests</title>
+	<link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-2.17.2.css">
+	<script src="https://code.jquery.com/qunit/qunit-2.17.2.js"></script>
+	<script type="module">
+		import * as globals from "../dist/object-model.min.js"
+		Object.assign(window, globals)
+	</script>
+	<script src="model.spec.cjs"></script>
+	<script src="basic-model.spec.cjs"></script>
+	<script src="any-model.spec.cjs"></script>
+	<script src="object-model.spec.cjs"></script>
+	<script src="array-model.spec.cjs"></script>
+	<script src="function-model.spec.cjs"></script>
+	<script src="map-model.spec.cjs"></script>
+	<script src="set-model.spec.cjs"></script>
+</head>
+
+<body>
+	<div id="qunit"></div>
+	<div id="qunit-fixture"></div>
+</body>
+
 </html>

package/test/object-model.spec.cjs

@@ -1305,4 +1305,43 @@ QUnit.test("Null-safe object traversal", function (assert) {
 	assert.strictEqual(config.local.time.format, undefined, "null-safe object traversal getter")
 	config.local.time.format = "12h";
 	assert.strictEqual(config.local.time.format, "12h", "null-safe object traversal setter")
+})
+
+QUnit.test("Check once mode", function(assert){
+	const Address = Model({ city: String, street: { name: String, number: Number }})
+	assert.throws(function () {
+		Address({ city: "Paris", street: { name: null, number: 12 }}, Model.CHECK_ONCE)
+	}, /TypeError.*expecting street.name to be String/, "check once mode still checks at instanciation")
+	const a = new Address({ city: "Paris", street: { name: "Champs-Elysees", number: 12 }}, Model.CHECK_ONCE)
+	a.street.name = null;
+	assert.strictEqual(a.street.name, null, "check once mode does not check future mutations")
+
+	class Person extends Model({ name: String, age: Number }) {
+		constructor({ name, age }) {
+			super({ name, age }, Model.CHECK_ONCE)
+		}
+	}
+
+	const john = new Person({ name: "John", age: 32 })
+	john.age = "twelve";
+	assert.strictEqual(john.age, "twelve", "check once mode does not check future mutations for extended class-based models")
+})
+
+QUnit.test("Short-circuit validation when not receiving an object as expected", function(assert){
+	const PersonModel = new ObjectModel({
+		FirstName: String,
+		LastName: String,
+	  })
+	const errorsCollected = []
+	PersonModel.errorCollector = function(errors){
+		errorsCollected.push(...errors)
+	}
+	  
+	PersonModel(42)
+	console.log({ errorsCollected})
+	assert.equal(errorsCollected.length, 1, "should only have 1 error")
+	assert.equal(errorsCollected[0].message, `expecting {
+	FirstName: String, 
+	LastName: String 
+}, got Number 42`)
 })

package/test/umd.html

@@ -8,14 +8,14 @@
 	<script src="lib/qunit.js"></script>
 	<script src="https://umd.cdn.pika.dev/objectmodel/v4"></script>
 	<script>const { Model, BasicModel, ObjectModel, ArrayModel, FunctionModel, MapModel, SetModel, Any } = objectmodel</script>
-	<script src="model.spec.js"></script>
-	<script src="basic-model.spec.js"></script>
-	<script src="any-model.spec.js"></script>
-	<script src="object-model.spec.js"></script>
-	<script src="array-model.spec.js"></script>
-	<script src="function-model.spec.js"></script>
-	<script src="map-model.spec.js"></script>
-	<script src="set-model.spec.js"></script>
+	<script src="model.spec.cjs"></script>
+	<script src="basic-model.spec.cjs"></script>
+	<script src="any-model.spec.cjs"></script>
+	<script src="object-model.spec.cjs"></script>
+	<script src="array-model.spec.cjs"></script>
+	<script src="function-model.spec.cjs"></script>
+	<script src="map-model.spec.cjs"></script>
+	<script src="set-model.spec.cjs"></script>
 </head>
 
 <body>

package/types/index.d.ts

@@ -1,136 +1,138 @@
-// TypeScript definition file for ObjectModel
-
-export interface Model {
-	(value?: any): any;
-
-	definition: any;
-	assertions: Assertion[];
-	default: any;
-	name: string;
-
-	conventionForConstant(variableName: string): boolean;
-	conventionForPrivate(variableName: string): boolean;
-
-	toString(stack?: any[]): string;
-
-	as(name: string): this;
-
-	defaultTo(defaultValue: any): this;
-
-	test(value: any, errorCollector?: (errors: ModelError[]) => void): boolean;
-
-	errorCollector(errors: ModelError[]): void;
-
-	assert(assertion: Assertion, description?: string | Function): this;
-
-}
-
-export interface ModelConstructor {
-	(definition: any): ObjectModel;
-	new(definition: any): ObjectModel;
-}
-
-export interface BasicModel extends Model {
-	(): any;
-	new(): any;
-	(value: any): any
-	new(value: any): any
-
-	extend(...otherDefinitions: Array<any>): this;
-}
-
-export interface BasicModelConstructor {
-	(definition: any): BasicModel
-	new(definition: any): BasicModel;
-}
-
-export interface ObjectModel extends Model {
-	(): Object;
-	new(): Object;
-	(object: object): Object;
-	new(object: object): Object;
-
-	extend(...otherDefinitions: Array<Object | ObjectModel>): this;
-}
-
-export interface ObjectModelConstructor {
-	(definition: Object): ObjectModel;
-	new(definition: Object): ObjectModel;
-}
-
-export interface ArrayModel extends Model {
-	<T>(): Array<T>;
-	new <T>(): Array<T>;
-	<T>(array: Array<T>): Array<T>;
-	new <T>(array: Array<T>): Array<T>;
-
-	extend(...otherElementDefinitions: Array<any>): this;
-}
-
-export interface ArrayModelConstructor {
-	(itemDefinition: any): ArrayModel;
-	new(itemDefinition: any): ArrayModel;
-}
-
-export interface FunctionModel extends Model {
-	(): Function;
-	new(): Function;
-	(fn: Function): Function;
-	new(fn: Function): Function;
-
-	definition: { arguments: any[], return: any };
-
-	return(returnValueDefinition: any): FunctionModel;
-
-	extend(otherArgsDefinitions: Array<any>, otherReturnValuesDefinitions: Array<any>): this;
-}
-
-export interface FunctionModelConstructor {
-	(...argumentsDefinitions: any[]): FunctionModel;
-	new(...argumentsDefinitions: any[]): FunctionModel;
-}
-
-export interface MapModel extends Model {
-	(): Map<any, any>;
-	new(): Map<any, any>;
-	(iterable: Map<any, any> | Array<[any, any]>): Map<any, any>;
-	new(iterable: Map<any, any> | Array<[any, any]>): Map<any, any>;
-
-	extend(otherKeyDefinitions: Array<any>, otherValueDefinitions: Array<any>): this;
-}
-
-export interface MapModelConstructor {
-	(keyDefinition: any, valueDefinition: any): MapModel;
-	new(keyDefinition: any, valueDefinition: any): MapModel;
-}
-
-export interface SetModel extends Model {
-	(): Set<any>;
-	new(): Set<any>;
-	(set: Set<any> | Array<any>): Set<any>;
-	new(set: Set<any> | Array<any>): Set<any>;
-
-	extend(...otherElementDefinitions: Array<any>): this;
-}
-
-export interface SetModelConstructor {
-	(itemDefinition: any): SetModel;
-	new(itemDefinition: any): SetModel;
-}
-
-export type Assertion = (variable: any) => boolean
-
-export interface ModelError {
-	message: string;
-	expected: any;
-	received: any;
-	path: string;
-}
-
-export const Model: ModelConstructor;
-export const BasicModel: BasicModelConstructor;
-export const ObjectModel: ObjectModelConstructor;
-export const ArrayModel: ArrayModelConstructor;
-export const FunctionModel: FunctionModelConstructor;
-export const MapModel: MapModelConstructor;
-export const SetModel: SetModelConstructor;
+// TypeScript definition file for ObjectModel
+
+export interface Model {
+	(value?: any): any;
+
+	definition: any;
+	assertions: Assertion[];
+	default: any;
+	name: string;
+
+	conventionForConstant(variableName: string): boolean;
+	conventionForPrivate(variableName: string): boolean;
+
+	toString(stack?: any[]): string;
+
+	as(name: string): this;
+
+	defaultTo(defaultValue: any): this;
+
+	test(value: any, errorCollector?: (errors: ModelError[]) => void): boolean;
+
+	errorCollector(errors: ModelError[]): void;
+
+	assert(assertion: Assertion, description?: string | Function): this;
+
+}
+
+export interface ModelConstructor {
+	(definition: any): ObjectModel;
+	new(definition: any): ObjectModel;
+	CHECK_ONCE: symbol;
+}
+
+export interface BasicModel extends Model {
+	(): any;
+	new(): any;
+	(value: any): any
+	new(value: any): any
+
+	extend(...otherDefinitions: Array<any>): this;
+}
+
+export interface BasicModelConstructor {
+	(definition: any): BasicModel
+	new(definition: any): BasicModel;
+}
+
+export interface ObjectModel extends Model {
+	(): Object;
+	new(): Object;
+	(object: object): Object;
+	new(object: object): Object;
+
+	extend(...otherDefinitions: Array<Object | ObjectModel>): this;
+}
+
+export interface ObjectModelConstructor {
+	(definition: Object): ObjectModel;
+	new(definition: Object): ObjectModel;
+}
+
+export interface ArrayModel extends Model {
+	<T>(): Array<T>;
+	new <T>(): Array<T>;
+	<T>(array: Array<T>): Array<T>;
+	new <T>(array: Array<T>): Array<T>;
+
+	extend(...otherElementDefinitions: Array<any>): this;
+}
+
+export interface ArrayModelConstructor {
+	(itemDefinition: any): ArrayModel;
+	new(itemDefinition: any): ArrayModel;
+}
+
+export interface FunctionModel extends Model {
+	(): Function;
+	new(): Function;
+	(fn: Function): Function;
+	new(fn: Function): Function;
+
+	definition: { arguments: any[], return: any };
+
+	return(returnValueDefinition: any): FunctionModel;
+
+	extend(otherArgsDefinitions: Array<any>, otherReturnValuesDefinitions: Array<any>): this;
+}
+
+export interface FunctionModelConstructor {
+	(...argumentsDefinitions: any[]): FunctionModel;
+	new(...argumentsDefinitions: any[]): FunctionModel;
+}
+
+export interface MapModel extends Model {
+	(): Map<any, any>;
+	new(): Map<any, any>;
+	(iterable: Map<any, any> | Array<[any, any]>): Map<any, any>;
+	new(iterable: Map<any, any> | Array<[any, any]>): Map<any, any>;
+
+	extend(otherKeyDefinitions: Array<any>, otherValueDefinitions: Array<any>): this;
+}
+
+export interface MapModelConstructor {
+	(keyDefinition: any, valueDefinition: any): MapModel;
+	new(keyDefinition: any, valueDefinition: any): MapModel;
+}
+
+export interface SetModel extends Model {
+	(): Set<any>;
+	new(): Set<any>;
+	(set: Set<any> | Array<any>): Set<any>;
+	new(set: Set<any> | Array<any>): Set<any>;
+
+	extend(...otherElementDefinitions: Array<any>): this;
+}
+
+export interface SetModelConstructor {
+	(itemDefinition: any): SetModel;
+	new(itemDefinition: any): SetModel;
+}
+
+export type Assertion = (variable: any) => boolean
+
+export interface ModelError {
+	message: string;
+	expected: any;
+	received: any;
+	path: string;
+}
+
+export const Any: any;
+export const Model: ModelConstructor;
+export const BasicModel: BasicModelConstructor;
+export const ObjectModel: ObjectModelConstructor;
+export const ArrayModel: ArrayModelConstructor;
+export const FunctionModel: FunctionModelConstructor;
+export const MapModel: MapModelConstructor;
+export const SetModel: SetModelConstructor;