objectmodel 4.3.1 → 4.4.0

package/test/object-model.test-d.ts

@@ -0,0 +1,53 @@
+import {expectType} from 'tsd';
+import { Model, ObjectModel } from "../src/object-model"
+
+expectType<{ a: number, b: "b" }>(Model({ a: Number, b: <const>"b" })({ a: 1, b: "b" }))
+
+expectType<{
+    product: {
+        name: string,
+        quantity: number
+    },
+    orderDate: Date
+}>(new ObjectModel({
+	product: {
+		name: String,
+		quantity: Number,
+	},
+	orderDate: Date
+})({
+    product: { name: "Apple Pie", quantity: 1 },
+	orderDate: new Date()
+}))
+
+const Person = ObjectModel({ name: String, female: Boolean })
+const Man = Person.extend({ female: false })
+const Mother = Person.extend({ female: true, child: Person })
+
+let joanna = new Person({ name: "Joanna", female: true })
+let joe = new Man({ name: "Joe" })
+let ann = new Mother({ name: "Ann", child: joanna })
+expectType<{ name: string, female: boolean }>(joanna)
+expectType<{ name: string, female: boolean }>(joe)
+expectType<{ name: string, female: boolean }>(ann.child)
+
+class ClassPerson extends ObjectModel({ name: String, female: Boolean }){
+	constructor({ name, female }: { name: string, female: boolean }){
+		if(!female) name = `Mr ${name}`
+		super({ name, female })
+	}
+}
+
+class ClassMother extends ClassPerson.extend({ female: true, child: ClassPerson }){
+	constructor({ name, child }: { name: string, child: ClassPerson }){
+		super({ name: `Mrs ${name}`, female: true })
+        this.child = child
+	}
+}
+
+joanna = new ClassPerson({ name: "Joanna", female: true })
+ann = new ClassMother({ name: "Ann", child: joanna })
+
+expectType<ClassMother>(ann)
+expectType<string>(ann.name)
+expectType<ClassPerson>(ann.child)

package/test/set-model.spec.cjs

@@ -1,214 +1,214 @@
-/* global QUnit, SetModel, ObjectModel */
-
-QUnit.module("Set Models");
-
-QUnit.test("constructor && proto", function (assert) {
-
-	assert.ok(SetModel instanceof Function, "SetModel instanceof Function");
-
-	const MySet = SetModel(String);
-
-	assert.ok(MySet instanceof SetModel, "Set models can be declared");
-
-	assert.ok(typeof MySet.extend === "function", "test Set model method extend");
-	assert.ok(typeof MySet.assert === "function", "test Set model method assert");
-	assert.ok(typeof MySet.test === "function", "test Set model method test");
-	assert.ok(MySet.definition === String, "test Set model prop definition");
-	assert.ok(typeof MySet.assertions === "object", "test Set model prop assertions");
-
-	assert.ok(SetModel(undefined) instanceof SetModel, "SetModel can receive undefined as argument");
-
-});
-
-QUnit.test("instanciation && mutation methods watchers", function (assert) {
-
-	const S = SetModel(Number).assert(s => s.size >= 2, "minsize assert");
-	const s = S([1, 2]);
-
-	assert.ok(s instanceof S && s instanceof Set, "Set models can be instanciated");
-
-	s.add(3);
-
-	assert.equal(s.add.name, "add", "proxyfied methods keep original properties");
-
-	assert.throws(function () {
-		s.add("four")
-	}, /TypeError.*four/, "add calls are catched");
-
-	assert.equal(s.size, 3, "set size change is ok 1/2");
-
-	s.delete(3);
-	assert.throws(function () {
-		s.delete(2);
-	}, /TypeError.*minsize assert/, "delete calls are catched");
-
-	assert.throws(function () {
-		s.clear();
-	}, /TypeError.*minsize assert/, "clear calls are catched");
-
-	assert.equal(s.size, 2, "set size change is ok 2/2");
-
-});
-
-QUnit.test("validation in constructor", function (assert) {
-
-	const S = SetModel(String)
-	const s = S(["one", "two"]);
-	assert.equal(s.size, 2, "set size is ok");
-
-	assert.throws(function () {
-		S(["one", 2])
-	}, /TypeError/, "validation in set model constructor 1/2");
-
-	assert.throws(function () {
-		S([1, "two"])
-	}, /TypeError/, "validation in set model constructor 2/2");
-
-});
-
-QUnit.test("union types & submodels", function (assert) {
-
-	const Question = ObjectModel({
-		answer: Number
-	});
-
-	const Quiz = SetModel([Question, String, Boolean]);
-	const s = Quiz(["test", true, { answer: 42 }]);
-	s.add("is it real life ?");
-	s.add(true);
-	s.add({ answer: 43 });
-	assert.throws(function () {
-		s.add(42);
-	}, /TypeError[\s\S]*got Number 42/m, "set invalid type on union type");
-
-});
-
-QUnit.test("union types & fixed values", function (assert) {
-
-	const S = SetModel([true, 2, "3"]);
-	assert.throws(function () {
-		S(["3", 4]);
-	}, /TypeError[\s\S]*Set.*Number 4/, "SetModel fixed values");
-
-	S([2, true]);
-	const S2 = S.extend().assert(s => s.size === 2);
-	const s2 = new S2([2, '3']);
-
-	assert.ok(Object.getPrototypeOf(S2.prototype) === S.prototype, "extension respect prototypal chain");
-	assert.ok(s2 instanceof S2 && s2 instanceof S, "set model inheritance");
-	S([2, true]).add("3");
-	assert.throws(function () {
-		S2([2, true]).add("3")
-	}, /TypeError/, "min/max of inherit set model");
-
-	const S3 = S2.extend("new", "val");
-	S3(["val", true]);
-	S3([true, "new"]);
-	assert.throws(function () {
-		S2(["val", true]);
-	}, /TypeError/, "set  model type extension");
-
-})
-
-QUnit.test("Child set models in object models", function (assert) {
-
-	const Child = ObjectModel({ set: SetModel(Number) });
-	const Parent = ObjectModel({ child: Child });
-
-	const childO = Child({ set: new Set([1, 2, 3, 5, 8]) });
-	assert.ok(childO.set instanceof Set, "child set model is instanceof Set");
-	const parentO = Parent({ child: childO });
-	assert.ok(parentO.child.set instanceof Set, "child set model from parent is Set");
-
-	childO.set.add(13);
-	assert.throws(function () {
-		childO.set.add("21");
-	}, /TypeError/, "child array model catches invalid set value");
-
-});
-
-QUnit.test("defaults values", function (assert) {
-
-	const S = SetModel(Number).defaultTo(new Set([1, 2]));
-	const a = S();
-
-	assert.ok(a instanceof Set && a.size === 2, "Set model default value");
-
-	S.default.add(3);
-
-	const b = S();
-
-	assert.ok(b.size === 3 && Array.from(b.values()).sort().join(";") === "1;2;3", "set model default value is mutable");
-
-	S.default = "nope";
-
-	assert.throws(function () {
-		S()
-	}, /TypeError/, "invalid default property still throws TypeError for set models");
-
-})
-
-QUnit.test("assertions", function (assert) {
-
-	const SetMax3 = SetModel(String).assert(function maxEntries(set) {
-		return set.size <= 3;
-	});
-
-	let set = SetMax3(["one", "two"]);
-
-	set.add("three");
-	assert.throws(function () {
-		set.add("four");
-	}, /TypeError[\s\S]*maxEntries/, "test assertion after set method");
-
-	const AssertSet = SetModel(Number).assert(s => s.size > 0, "may throw exception");
-
-	new AssertSet([1, 2]);
-
-	assert.throws(function () { new AssertSet([]); },
-		/assertion "may throw exception" returned false.*for value \[]/,
-		"assertions catch exceptions on Set models"
-	);
-
-})
-
-QUnit.test("Automatic model casting", function (assert) {
-
-	const N = ObjectModel({ x: Number, y: [Number] }).defaultTo({ x: 5, y: 7 });
-	const S = SetModel(N);
-	const s = S([{ x: 9 }]);
-
-	let n = Array.from(s.values())[0];
-	assert.ok(n instanceof N, "test automatic model casting with set init 1/2")
-	assert.equal(n.x * n.y, 63, "test automatic model casting with set init 2/2")
-
-	s.add({ x: 3 });
-	n = Array.from(s.values())[1];
-
-	assert.ok(n instanceof N, "test automatic model casting with array mutator method 1/2")
-	assert.equal(n.x * n.y, 21, "test automatic model casting with array mutator method 2/2")
-});
-
-QUnit.test("toString", function (assert) {
-	assert.equal(SetModel(Number).toString(), "Set of Number", "SetModel toString for basic elements")
-	assert.equal(SetModel([String, 42]).toString(), "Set of String or 42", "SetModel toString for union type elements")
-})
-
-QUnit.test("dynamic definition", function (assert) {
-	let S = SetModel(String);
-	let s1 = S(["hello", "world"])
-	S.definition = Number;
-	let s2 = S([1, 2, 3])
-	assert.equal(S.test(s1), false, "definition can be dynamically changed 1/4")
-	assert.equal(S.test(s2), true, "definition can be dynamically changed 2/4")
-	s1.clear();
-	assert.throws(() => s1.add("hello"), /TypeError/, "definition can be dynamically changed 3/4")
-	s1.add(42);
-	assert.ok(s1.has(42), "definition can be dynamically changed 4/4")
-
-	let OM = ObjectModel({ n: Number });
-	S.definition = OM;
-	s1.clear();
-	s1.add({ n: 42 });
-	assert.ok([...s1][0] instanceof OM, "autocast still works after definition dynamically changed")
+/* global QUnit, SetModel, ObjectModel */
+
+QUnit.module("Set Models");
+
+QUnit.test("constructor && proto", function (assert) {
+
+	assert.ok(SetModel instanceof Function, "SetModel instanceof Function");
+
+	const MySet = SetModel(String);
+
+	assert.ok(MySet instanceof SetModel, "Set models can be declared");
+
+	assert.ok(typeof MySet.extend === "function", "test Set model method extend");
+	assert.ok(typeof MySet.assert === "function", "test Set model method assert");
+	assert.ok(typeof MySet.test === "function", "test Set model method test");
+	assert.ok(MySet.definition === String, "test Set model prop definition");
+	assert.ok(typeof MySet.assertions === "object", "test Set model prop assertions");
+
+	assert.ok(SetModel(undefined) instanceof SetModel, "SetModel can receive undefined as argument");
+
+});
+
+QUnit.test("instanciation && mutation methods watchers", function (assert) {
+
+	const S = SetModel(Number).assert(s => s.size >= 2, "minsize assert");
+	const s = S([1, 2]);
+
+	assert.ok(s instanceof S && s instanceof Set, "Set models can be instanciated");
+
+	s.add(3);
+
+	assert.equal(s.add.name, "add", "proxyfied methods keep original properties");
+
+	assert.throws(function () {
+		s.add("four")
+	}, /TypeError.*four/, "add calls are catched");
+
+	assert.equal(s.size, 3, "set size change is ok 1/2");
+
+	s.delete(3);
+	assert.throws(function () {
+		s.delete(2);
+	}, /TypeError.*minsize assert/, "delete calls are catched");
+
+	assert.throws(function () {
+		s.clear();
+	}, /TypeError.*minsize assert/, "clear calls are catched");
+
+	assert.equal(s.size, 2, "set size change is ok 2/2");
+
+});
+
+QUnit.test("validation in constructor", function (assert) {
+
+	const S = SetModel(String)
+	const s = S(["one", "two"]);
+	assert.equal(s.size, 2, "set size is ok");
+
+	assert.throws(function () {
+		S(["one", 2])
+	}, /TypeError/, "validation in set model constructor 1/2");
+
+	assert.throws(function () {
+		S([1, "two"])
+	}, /TypeError/, "validation in set model constructor 2/2");
+
+});
+
+QUnit.test("union types & submodels", function (assert) {
+
+	const Question = ObjectModel({
+		answer: Number
+	});
+
+	const Quiz = SetModel([Question, String, Boolean]);
+	const s = Quiz(["test", true, { answer: 42 }]);
+	s.add("is it real life ?");
+	s.add(true);
+	s.add({ answer: 43 });
+	assert.throws(function () {
+		s.add(42);
+	}, /TypeError[\s\S]*got Number 42/m, "set invalid type on union type");
+
+});
+
+QUnit.test("union types & fixed values", function (assert) {
+
+	const S = SetModel([true, 2, "3"]);
+	assert.throws(function () {
+		S(["3", 4]);
+	}, /TypeError[\s\S]*Set.*Number 4/, "SetModel fixed values");
+
+	S([2, true]);
+	const S2 = S.extend().assert(s => s.size === 2);
+	const s2 = new S2([2, '3']);
+
+	assert.ok(Object.getPrototypeOf(S2.prototype) === S.prototype, "extension respect prototypal chain");
+	assert.ok(s2 instanceof S2 && s2 instanceof S, "set model inheritance");
+	S([2, true]).add("3");
+	assert.throws(function () {
+		S2([2, true]).add("3")
+	}, /TypeError/, "min/max of inherit set model");
+
+	const S3 = S2.extend("new", "val");
+	S3(["val", true]);
+	S3([true, "new"]);
+	assert.throws(function () {
+		S2(["val", true]);
+	}, /TypeError/, "set  model type extension");
+
+})
+
+QUnit.test("Child set models in object models", function (assert) {
+
+	const Child = ObjectModel({ set: SetModel(Number) });
+	const Parent = ObjectModel({ child: Child });
+
+	const childO = Child({ set: new Set([1, 2, 3, 5, 8]) });
+	assert.ok(childO.set instanceof Set, "child set model is instanceof Set");
+	const parentO = Parent({ child: childO });
+	assert.ok(parentO.child.set instanceof Set, "child set model from parent is Set");
+
+	childO.set.add(13);
+	assert.throws(function () {
+		childO.set.add("21");
+	}, /TypeError/, "child array model catches invalid set value");
+
+});
+
+QUnit.test("defaults values", function (assert) {
+
+	const S = SetModel(Number).defaultTo(new Set([1, 2]));
+	const a = S();
+
+	assert.ok(a instanceof Set && a.size === 2, "Set model default value");
+
+	S.default.add(3);
+
+	const b = S();
+
+	assert.ok(b.size === 3 && Array.from(b.values()).sort().join(";") === "1;2;3", "set model default value is mutable");
+
+	S.default = "nope";
+
+	assert.throws(function () {
+		S()
+	}, /TypeError/, "invalid default property still throws TypeError for set models");
+
+})
+
+QUnit.test("assertions", function (assert) {
+
+	const SetMax3 = SetModel(String).assert(function maxEntries(set) {
+		return set.size <= 3;
+	});
+
+	let set = SetMax3(["one", "two"]);
+
+	set.add("three");
+	assert.throws(function () {
+		set.add("four");
+	}, /TypeError[\s\S]*maxEntries/, "test assertion after set method");
+
+	const AssertSet = SetModel(Number).assert(s => s.size > 0, "may throw exception");
+
+	new AssertSet([1, 2]);
+
+	assert.throws(function () { new AssertSet([]); },
+		/assertion "may throw exception" returned false.*for value \[]/,
+		"assertions catch exceptions on Set models"
+	);
+
+})
+
+QUnit.test("Automatic model casting", function (assert) {
+
+	const N = ObjectModel({ x: Number, y: [Number] }).defaultTo({ x: 5, y: 7 });
+	const S = SetModel(N);
+	const s = S([{ x: 9 }]);
+
+	let n = Array.from(s.values())[0];
+	assert.ok(n instanceof N, "test automatic model casting with set init 1/2")
+	assert.equal(n.x * n.y, 63, "test automatic model casting with set init 2/2")
+
+	s.add({ x: 3 });
+	n = Array.from(s.values())[1];
+
+	assert.ok(n instanceof N, "test automatic model casting with array mutator method 1/2")
+	assert.equal(n.x * n.y, 21, "test automatic model casting with array mutator method 2/2")
+});
+
+QUnit.test("toString", function (assert) {
+	assert.equal(SetModel(Number).toString(), "Set of Number", "SetModel toString for basic elements")
+	assert.equal(SetModel([String, 42]).toString(), "Set of String or 42", "SetModel toString for union type elements")
+})
+
+QUnit.test("dynamic definition", function (assert) {
+	let S = SetModel(String);
+	let s1 = S(["hello", "world"])
+	S.definition = Number;
+	let s2 = S([1, 2, 3])
+	assert.equal(S.test(s1), false, "definition can be dynamically changed 1/4")
+	assert.equal(S.test(s2), true, "definition can be dynamically changed 2/4")
+	s1.clear();
+	assert.throws(() => s1.add("hello"), /TypeError/, "definition can be dynamically changed 3/4")
+	s1.add(42);
+	assert.ok(s1.has(42), "definition can be dynamically changed 4/4")
+
+	let OM = ObjectModel({ n: Number });
+	S.definition = OM;
+	s1.clear();
+	s1.add({ n: 42 });
+	assert.ok([...s1][0] instanceof OM, "autocast still works after definition dynamically changed")
 })

package/test/set-model.test-d.ts

@@ -0,0 +1,17 @@
+import {expectType} from 'tsd';
+import { ObjectModel } from '../src/object-model';
+import { SetModel } from '../src/set-model';
+
+expectType<Set<string>>(SetModel(String)(new Set(["one", "two"])));
+
+const Question = ObjectModel({
+    answer: Number
+});
+
+const Quiz = SetModel([Question, String, Boolean]);
+
+expectType<Set<{ answer: number } | string | boolean>>(Quiz(new Set()));
+
+const SetModel1 = SetModel(String)
+const SetModel2 = SetModel1.extend(Date, Number)
+expectType<Set<string | Date | number>>(SetModel2([1,"2",new Date()]))

package/test/umd.html

@@ -1,26 +1,26 @@
-<!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 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.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>
+
+<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 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.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/types/definitions.d.ts

@@ -0,0 +1,43 @@
+import { ArrayModel } from "../src/array-model"
+import { FunctionModel, FunctionSignature } from "../src/function-model"
+import { MapModel } from "../src/map-model"
+import { SetModel } from "../src/set-model"
+import { BasicModel, ObjectModel } from "../src/object-model"
+import { Class, Prev } from "./helpers"
+
+
+export type ModelDefinition = any
+export type ObjectModelDefinition = Record<string | number | symbol, unknown>
+
+export type FromDefinition<T, Depth extends Prev[number] = 5> =
+    [Depth] extends [never] ? never /* Depth limit reached */
+    : T extends BasicModel<infer U> ? FromDefinition<U, Prev[Depth]>
+    : T extends ArrayModel<infer U> ? FromDefinition<U, Prev[Depth]>[]
+    : T extends ObjectModel<infer D> ? FromObjectModelDefinition<D>
+    : T extends FunctionModel<infer Args, infer Return> ? FunctionSignature<Args, Return>
+    : T extends MapModel<infer Key, infer Value> ? Map<FromDefinition<Key, Prev[Depth]>, FromDefinition<Value, Prev[Depth]>>
+    : T extends SetModel<infer U> ? Set<FromDefinition<U, Prev[Depth]>>
+    : T extends StringConstructor | RegExp ? string
+    : T extends NumberConstructor ? number
+    : T extends BooleanConstructor ? boolean
+    : T extends new () => infer ConstructorType ? ConstructorType
+    : T extends Class ? InstanceType<T>
+    : T extends ObjectModelDefinition ? FromObjectModelDefinition<T>
+    : T extends readonly [...infer U] ? FromUnionDefinition<U>
+    : T extends any[] ? FromDefinition<T[number], Prev[Depth]> // TypeScript can't infer array literals as tuples for now without <const> assertions, see https://github.com/microsoft/TypeScript/issues/16656
+    : T
+
+export type FromObjectModelDefinition<D extends object> = { [K in keyof D]: FromDefinition<D[K]> }
+
+export type FromUnionDefinition<T extends any[]> = T extends [infer X] ? Optional<X>
+                                                 : FromDefinition<T[number]>
+
+export type Optional<T> = FromDefinition<T> | undefined | null
+
+export type ExtendObjectDefinition<D extends ObjectModelDefinition, E extends (ObjectModelDefinition | ObjectModel<any>)[]> = 
+    E extends [infer F, ...infer Rest extends (ObjectModelDefinition | ObjectModel<any>)[]] 
+        ? F extends ObjectModel<infer FD> 
+            ? ExtendObjectDefinition<D & FD, Rest>
+            : F extends ObjectModelDefinition ? ExtendObjectDefinition<D & FromObjectModelDefinition<F>, Rest> 
+            : never
+        : D

package/types/helpers.d.ts

@@ -0,0 +1,4 @@
+export type Class = abstract new (...args: any) => any
+
+/* Used to depth-limit recursive types */
+export type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];