objectmodel 4.3.0 → 4.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objectmodel",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Strong Dynamically Typed Object Modeling for JavaScript",
   "author": "Sylvain Pollet-Villard",
   "license": "MIT",
@@ -18,21 +18,24 @@
     "watch:js": "npm run build:js -- --watch",
     "watch:min": "npm run build:min -- --watch",
     "info": "npm-run-all info:*",
-    "info:banner": "node build/add-banner.cjs",
-    "info:docs": "node build/update-docs.cjs",
+    "info:banner": "node build/add-banner.js",
+    "info:docs": "node build/update-docs.js",
     "lint": "eslint . --fix",
-    "test": "qunit test/index.cjs"
+    "test": "npm-run-all test:*",
+    "test:unit": "qunit test/index.cjs",
+    "test:tsd": "tsd"
   },
   "devDependencies": {
     "cjyes": "^0.3.1",
-    "eslint": "^7.28.0",
+    "eslint": "^8.18.0",
     "esm": "^3.2.25",
-    "filesize": "^6.3.0",
-    "gzip-size": "^6.0.0",
+    "gzip-size": "^7.0.0",
     "npm-run-all": "^4.1.5",
-    "qunit": "^2.16.0",
-    "rollup": "^2.51.2",
-    "rollup-plugin-terser": "^7.0.2"
+    "pretty-bytes": "^6.0.0",
+    "qunit": "^2.19.1",
+    "rollup": "^2.75.6",
+    "rollup-plugin-terser": "^7.0.2",
+    "tsd": "^0.24.1"
   },
   "type": "module",
   "main": "dist/object-model.js",
@@ -41,6 +44,13 @@
     "require": "./dist/object-model.cjs"
   },
   "types": "types/index.d.ts",
+  "tsd": {
+		"directory": "test"
+	},
+  "engines": {
+    "npm": ">=7.0.0",
+    "node": ">=17.5.0"
+  },
   "keywords": [
     "typed",
     "types",

package/rollup.config.js

@@ -1,14 +1,14 @@
-import { terser } from "rollup-plugin-terser";
-
-const isProduction = process.env.BUILD === 'production';
-
-export default {
-	input: 'build/bundle-entry' + (isProduction ? '.js' : '.dev.js'),
-	output: {
-		file: 'dist/object-model' + (isProduction ? '.min.js' : '.js'),
-		format: 'esm',
-		sourcemap: true,
-		extend: true
-	},
-	plugins: isProduction ? [terser()] : []
+import { terser } from "rollup-plugin-terser";
+
+const isProduction = process.env.BUILD === 'production';
+
+export default {
+	input: 'build/bundle-entry' + (isProduction ? '.js' : '.dev.js'),
+	output: {
+		file: 'dist/object-model' + (isProduction ? '.min.js' : '.js'),
+		format: 'esm',
+		sourcemap: true,
+		extend: true
+	},
+	plugins: isProduction ? [terser()] : []
 };

package/src/array-model.d.ts

@@ -0,0 +1,16 @@
+import { ModelDefinition, FromDefinition } from "../types/definitions";
+import { Model } from "./object-model";
+
+export interface ArrayModel<D> extends Model<D> {	
+	(array: FromDefinition<D>[]): FromDefinition<D>[];
+	new(array: FromDefinition<D>[]): FromDefinition<D>[];
+
+	extend<E extends ModelDefinition[]>(...extensions: E): ArrayModel<E extends [] ? D : [D, ...E]>
+}
+
+export interface ArrayModelConstructor {
+	<D extends ModelDefinition>(itemDefinition: D): ArrayModel<D>;
+	new<D extends ModelDefinition>(itemDefinition: D): ArrayModel<D>;
+}
+
+export const ArrayModel: ArrayModelConstructor;

package/src/array-model.js

@@ -1,69 +1,69 @@
-import {
-	_original, _check, cast, checkAssertions, checkDefinition,
-	extendDefinition, extendModel, formatDefinition, Model, stackError, unstackErrors
-} from "./object-model.js"
-import { initListModel } from "./list-model.js"
-import { extend } from "./helpers.js"
-
-export default function ArrayModel(initialDefinition) {
-	const model = initListModel(
-		Array,
-		ArrayModel,
-		initialDefinition,
-		a => Array.isArray(a) ? a.map(arg => cast(arg, model.definition)) : a,
-		a => [...a],
-		{
-			"copyWithin": [],
-			"fill": [0, 0],
-			"pop": [],
-			"push": [0],
-			"reverse": [],
-			"shift": [],
-			"sort": [],
-			"splice": [2],
-			"unshift": [0]
-		},
-		{
-			set(arr, key, val) {
-				return controlMutation(model, arr, key, val, (a, v) => a[key] = v, true)
-			},
-
-			deleteProperty(arr, key) {
-				return controlMutation(model, arr, key, undefined, a => delete a[key])
-			}
-		}
-	)
-
-	return model
-}
-
-extend(ArrayModel, Model, {
-	toString(stack) {
-		return "Array of " + formatDefinition(this.definition, stack)
-	},
-
-	[_check](arr, path, errors, stack) {
-		if (Array.isArray(arr))
-			(arr[_original] || arr).forEach((a, i) => checkDefinition(a, this.definition, `${path || "Array"}[${i}]`, errors, stack))
-		else stackError(errors, this, arr, path)
-
-		checkAssertions(arr, this, path, errors)
-	},
-
-	extend(...newParts) {
-		return extendModel(new ArrayModel(extendDefinition(this.definition, newParts)), this)
-	}
-})
-
-const controlMutation = (model, array, key, value, applyMutation, canBeExtended) => {
-	const path = `Array[${key}]`
-	const isInDef = (+key >= 0 && (canBeExtended || key in array))
-	if (isInDef) value = checkDefinition(value, model.definition, path, model.errors, [], true)
-
-	const testArray = [...array]
-	applyMutation(testArray)
-	checkAssertions(testArray, model, path)
-	const isSuccess = !unstackErrors(model)
-	if (isSuccess) applyMutation(array, value)
-	return isSuccess
+import {
+	_original, _check, cast, checkAssertions, checkDefinition,
+	extendDefinition, extendModel, formatDefinition, Model, stackError, unstackErrors
+} from "./object-model.js"
+import { initListModel } from "./list-model.js"
+import { extend } from "./helpers.js"
+
+export default function ArrayModel(initialDefinition) {
+	const model = initListModel(
+		Array,
+		ArrayModel,
+		initialDefinition,
+		a => Array.isArray(a) ? a.map(arg => cast(arg, model.definition)) : a,
+		a => [...a],
+		{
+			"copyWithin": [],
+			"fill": [0, 0],
+			"pop": [],
+			"push": [0],
+			"reverse": [],
+			"shift": [],
+			"sort": [],
+			"splice": [2],
+			"unshift": [0]
+		},
+		{
+			set(arr, key, val) {
+				return controlMutation(model, arr, key, val, (a, v) => a[key] = v, true)
+			},
+
+			deleteProperty(arr, key) {
+				return controlMutation(model, arr, key, undefined, a => delete a[key])
+			}
+		}
+	)
+
+	return model
+}
+
+extend(ArrayModel, Model, {
+	toString(stack) {
+		return "Array of " + formatDefinition(this.definition, stack)
+	},
+
+	[_check](arr, path, errors, stack) {
+		if (Array.isArray(arr))
+			(arr[_original] || arr).forEach((a, i) => checkDefinition(a, this.definition, `${path || "Array"}[${i}]`, errors, stack))
+		else stackError(errors, this, arr, path)
+
+		checkAssertions(arr, this, path, errors)
+	},
+
+	extend(...newParts) {
+		return extendModel(new ArrayModel(extendDefinition(this.definition, newParts)), this)
+	}
+})
+
+const controlMutation = (model, array, key, value, applyMutation, canBeExtended) => {
+	const path = `Array[${key}]`
+	const isInDef = (+key >= 0 && (canBeExtended || key in array))
+	if (isInDef) value = checkDefinition(value, model.definition, path, model.errors, [], true)
+
+	const testArray = [...array]
+	applyMutation(testArray)
+	checkAssertions(testArray, model, path)
+	const isSuccess = !unstackErrors(model)
+	if (isSuccess) applyMutation(array, value)
+	return isSuccess
 }

package/src/devtool-formatter.js

@@ -1,199 +1,199 @@
-import { _original, Model, Any, BasicModel, ObjectModel } from "./object-model.js"
-import ArrayModel from "./array-model.js"
-import SetModel from "./set-model.js"
-import MapModel from "./map-model.js"
-import FunctionModel from "./function-model.js"
-import { getProto, has, is, isFunction, isPlainObject } from "./helpers.js"
-
-const styles = {
-	list: "list-style-type: none; padding: 0; margin: 0;",
-	listItem: "padding: 0 0 0 1em;",
-	model: "color: #3e999f;",
-	instance: "color: #718c00; font-style: italic",
-	function: "color: #4271AE",
-	string: "color: #C41A16",
-	number: "color: #1C00CF",
-	boolean: "color: #AA0D91",
-	property: "color: #8959a8",
-	private: "color: #C19ED8",
-	constant: "color: #8959a8; font-weight: bold",
-	privateConstant: "color: #C19ED8; font-weight: bold",
-	null: "color: #8e908c",
-	undeclared: "color: #C0C0C0;",
-	proto: "color: #B871BD; font-style: italic"
-};
-
-const getModel = (instance) => {
-	if (instance === undefined || instance === null)
-		return null
-
-	const proto = getProto(instance);
-	if (!proto || !proto.constructor || !is(Model, proto.constructor))
-		return null
-
-	return proto.constructor
-}
-
-const span = (style, ...children) => ["span", { style }, ...children]
-
-const format = (x, config = {}) => {
-	if (x === null || x === undefined)
-		return span(styles.null, "" + x);
-
-	if (typeof x === "boolean")
-		return span(styles.boolean, x);
-
-	if (typeof x === "number")
-		return span(styles.number, x);
-
-	if (typeof x === "string")
-		return span(styles.string, `"${x}"`);
-
-	if (Array.isArray(x) && config.isModelDefinition) {
-		return span("", ...x.flatMap(part => [format(part, config), " or "]).slice(0, -1))
-	}
-
-	if (isPlainObject(x))
-		return formatObject(x, getModel(x), config)
-
-	if (isFunction(x) && !is(Model, x) && config.isModelDefinition)
-		return span(styles.function, x.name || x.toString());
-
-	return ["object", { object: x, config }]
-}
-
-const formatObject = (o, model, config) => span("",
-	"{",
-	["ol", { style: styles.list }, ...Object.keys(o).map(prop =>
-		["li", { style: styles.listItem }, span(styles.property, prop), ": ", format(o[prop], config)])
-	],
-	"}"
-)
-
-const formatModel = model => {
-	const
-		cfg = { isModelDefinition: true },
-		def = model.definition,
-		formatList = (list, map) => list.flatMap(e => [map(e), ", "]).slice(0, -1);
-	let parts = []
-
-	if (is(BasicModel, model)) parts = [format(def, cfg)]
-	if (is(ArrayModel, model)) parts = ["Array of ", format(def, cfg)]
-	if (is(SetModel, model)) parts = ["Set of ", format(def, cfg)]
-	if (is(MapModel, model)) parts = ["Map of ", format(def.key, cfg), " : ", format(def.value, cfg)]
-	if (is(FunctionModel, model)) {
-		parts = ["Function(", ...formatList(def.arguments, arg => format(arg, cfg)), ")"]
-		if ("return" in def) parts.push(" => ", format(def.return, cfg))
-	}
-
-	if (model.assertions.length > 0) {
-		parts.push("\n(assertions: ", ...formatList(model.assertions, f => ["object", { object: f }]), ")")
-	}
-
-	return span(styles.model, ...parts)
-}
-
-const ModelFormatter = {
-	header(x, config = {}) {
-		if (x === Any)
-			return span(styles.model, "Any")
-
-		if (is(Any.remaining, x))
-			return span(styles.model, "...", format(x.definition, { isModelDefinition: true }))
-
-		if (is(ObjectModel, x))
-			return span(styles.model, x.name)
-
-		if (is(Model, x)) {
-			return formatModel(x)
-		}
-
-		if (config.isModelDefinition && isPlainObject(x))
-			return format(x, config)
-
-		return null;
-	},
-	hasBody(x) {
-		return is(ObjectModel, x)
-	},
-	body(model) {
-		return span("",
-			"{",
-			["ol", { style: styles.list }, ...Object.keys(model.definition).map(prop => {
-				const isPrivate = model.conventionForPrivate(prop)
-				const isConstant = model.conventionForConstant(prop)
-				const hasDefault = model.default && has(model.default, prop);
-				let style = styles.property;
-
-				if (isPrivate) {
-					style = isConstant ? styles.privateConstant : styles.private
-				} else if (isConstant) {
-					style = styles.constant
-				}
-
-				return ["li", { style: styles.listItem },
-					span(style, prop), ": ", format(model.definition[prop], { isModelDefinition: true }),
-					hasDefault ? span(styles.proto, " = ", format(model.default[prop])) : ""
-				]
-			})],
-			"}"
-		)
-	}
-}
-
-const ModelInstanceFormatter = {
-	header(x, config = {}) {
-		if (config.isInstanceProperty && isPlainObject(x)) {
-			return format(x, config)
-		}
-
-		const model = getModel(x);
-		if (is(Model, model)) {
-			const parts = is(ObjectModel, model) ? [model.name] : [["object", { object: x[_original] }], ` (${model.name})`];
-			return span(styles.instance, ...parts)
-		}
-
-		return null;
-	},
-	hasBody(x) {
-		return x && is(ObjectModel, getModel(x))
-	},
-	body(x) {
-		const model = getModel(x)
-		const o = x[_original] || x;
-		return span("",
-			"{",
-			[
-				"ol",
-				{ style: styles.list },
-				...Object.keys(o).map(prop => {
-					const isPrivate = model.conventionForPrivate(prop)
-					const isConstant = model.conventionForConstant(prop)
-					const isDeclared = prop in model.definition;
-					let style = styles.property;
-
-					if (!isDeclared) {
-						style = styles.undeclared
-					} else if (isPrivate) {
-						style = isConstant ? styles.privateConstant : styles.private
-					} else if (isConstant) {
-						style = styles.constant
-					}
-
-					return ["li", { style: styles.listItem },
-						span(style, prop), ": ", format(o[prop], { isInstanceProperty: true })
-					]
-				}),
-				["li", { style: styles.listItem },
-					span(styles.proto, "__proto__", ": ", ["object", { object: getProto(x) }])
-				]
-			],
-			"}"
-		)
-	}
-}
-
-if (typeof window !== "undefined") {
-	window.devtoolsFormatters = (window.devtoolsFormatters || [])
-		.concat(ModelFormatter, ModelInstanceFormatter);
+import { _original, Model, Any, BasicModel, ObjectModel } from "./object-model.js"
+import ArrayModel from "./array-model.js"
+import SetModel from "./set-model.js"
+import MapModel from "./map-model.js"
+import FunctionModel from "./function-model.js"
+import { getProto, has, is, isFunction, isPlainObject } from "./helpers.js"
+
+const styles = {
+	list: "list-style-type: none; padding: 0; margin: 0;",
+	listItem: "padding: 0 0 0 1em;",
+	model: "color: #3e999f;",
+	instance: "color: #718c00; font-style: italic",
+	function: "color: #4271AE",
+	string: "color: #C41A16",
+	number: "color: #1C00CF",
+	boolean: "color: #AA0D91",
+	property: "color: #8959a8",
+	private: "color: #C19ED8",
+	constant: "color: #8959a8; font-weight: bold",
+	privateConstant: "color: #C19ED8; font-weight: bold",
+	null: "color: #8e908c",
+	undeclared: "color: #C0C0C0;",
+	proto: "color: #B871BD; font-style: italic"
+};
+
+const getModel = (instance) => {
+	if (instance === undefined || instance === null)
+		return null
+
+	const proto = getProto(instance);
+	if (!proto || !proto.constructor || !is(Model, proto.constructor))
+		return null
+
+	return proto.constructor
+}
+
+const span = (style, ...children) => ["span", { style }, ...children]
+
+const format = (x, config = {}) => {
+	if (x === null || x === undefined)
+		return span(styles.null, "" + x);
+
+	if (typeof x === "boolean")
+		return span(styles.boolean, x);
+
+	if (typeof x === "number")
+		return span(styles.number, x);
+
+	if (typeof x === "string")
+		return span(styles.string, `"${x}"`);
+
+	if (Array.isArray(x) && config.isModelDefinition) {
+		return span("", ...x.flatMap(part => [format(part, config), " or "]).slice(0, -1))
+	}
+
+	if (isPlainObject(x))
+		return formatObject(x, getModel(x), config)
+
+	if (isFunction(x) && !is(Model, x) && config.isModelDefinition)
+		return span(styles.function, x.name || x.toString());
+
+	return ["object", { object: x, config }]
+}
+
+const formatObject = (o, model, config) => span("",
+	"{",
+	["ol", { style: styles.list }, ...Object.keys(o).map(prop =>
+		["li", { style: styles.listItem }, span(styles.property, prop), ": ", format(o[prop], config)])
+	],
+	"}"
+)
+
+const formatModel = model => {
+	const
+		cfg = { isModelDefinition: true },
+		def = model.definition,
+		formatList = (list, map) => list.flatMap(e => [map(e), ", "]).slice(0, -1);
+	let parts = []
+
+	if (is(BasicModel, model)) parts = [format(def, cfg)]
+	if (is(ArrayModel, model)) parts = ["Array of ", format(def, cfg)]
+	if (is(SetModel, model)) parts = ["Set of ", format(def, cfg)]
+	if (is(MapModel, model)) parts = ["Map of ", format(def.key, cfg), " : ", format(def.value, cfg)]
+	if (is(FunctionModel, model)) {
+		parts = ["Function(", ...formatList(def.arguments, arg => format(arg, cfg)), ")"]
+		if ("return" in def) parts.push(" => ", format(def.return, cfg))
+	}
+
+	if (model.assertions.length > 0) {
+		parts.push("\n(assertions: ", ...formatList(model.assertions, f => ["object", { object: f }]), ")")
+	}
+
+	return span(styles.model, ...parts)
+}
+
+const ModelFormatter = {
+	header(x, config = {}) {
+		if (x === Any)
+			return span(styles.model, "Any")
+
+		if (is(Any.remaining, x))
+			return span(styles.model, "...", format(x.definition, { isModelDefinition: true }))
+
+		if (is(ObjectModel, x))
+			return span(styles.model, x.name)
+
+		if (is(Model, x)) {
+			return formatModel(x)
+		}
+
+		if (config.isModelDefinition && isPlainObject(x))
+			return format(x, config)
+
+		return null;
+	},
+	hasBody(x) {
+		return is(ObjectModel, x)
+	},
+	body(model) {
+		return span("",
+			"{",
+			["ol", { style: styles.list }, ...Object.keys(model.definition).map(prop => {
+				const isPrivate = model.conventionForPrivate(prop)
+				const isConstant = model.conventionForConstant(prop)
+				const hasDefault = model.default && has(model.default, prop);
+				let style = styles.property;
+
+				if (isPrivate) {
+					style = isConstant ? styles.privateConstant : styles.private
+				} else if (isConstant) {
+					style = styles.constant
+				}
+
+				return ["li", { style: styles.listItem },
+					span(style, prop), ": ", format(model.definition[prop], { isModelDefinition: true }),
+					hasDefault ? span(styles.proto, " = ", format(model.default[prop])) : ""
+				]
+			})],
+			"}"
+		)
+	}
+}
+
+const ModelInstanceFormatter = {
+	header(x, config = {}) {
+		if (config.isInstanceProperty && isPlainObject(x)) {
+			return format(x, config)
+		}
+
+		const model = getModel(x);
+		if (is(Model, model)) {
+			const parts = is(ObjectModel, model) ? [model.name] : [["object", { object: x[_original] }], ` (${model.name})`];
+			return span(styles.instance, ...parts)
+		}
+
+		return null;
+	},
+	hasBody(x) {
+		return x && is(ObjectModel, getModel(x))
+	},
+	body(x) {
+		const model = getModel(x)
+		const o = x[_original] || x;
+		return span("",
+			"{",
+			[
+				"ol",
+				{ style: styles.list },
+				...Object.keys(o).map(prop => {
+					const isPrivate = model.conventionForPrivate(prop)
+					const isConstant = model.conventionForConstant(prop)
+					const isDeclared = prop in model.definition;
+					let style = styles.property;
+
+					if (!isDeclared) {
+						style = styles.undeclared
+					} else if (isPrivate) {
+						style = isConstant ? styles.privateConstant : styles.private
+					} else if (isConstant) {
+						style = styles.constant
+					}
+
+					return ["li", { style: styles.listItem },
+						span(style, prop), ": ", format(o[prop], { isInstanceProperty: true })
+					]
+				}),
+				["li", { style: styles.listItem },
+					span(styles.proto, "__proto__", ": ", ["object", { object: getProto(x) }])
+				]
+			],
+			"}"
+		)
+	}
+}
+
+if (typeof window !== "undefined") {
+	window.devtoolsFormatters = (window.devtoolsFormatters || [])
+		.concat(ModelFormatter, ModelInstanceFormatter);
 }

package/src/function-model.d.ts

@@ -0,0 +1,24 @@
+import { FromDefinition, ModelDefinition } from "../types/definitions";
+import { Model } from "./object-model";
+
+type FromArgsDef<T> = T extends [infer A, ...infer Rest] ? [FromDefinition<A>, ...FromArgsDef<Rest>] : T
+
+export type FunctionSignature<Args extends any[], Return> = {
+	(...args: FromArgsDef<Args>): FromDefinition<Return>
+} 
+
+export interface FunctionModel<Args extends ModelDefinition[], Return extends ModelDefinition> extends Model<{ arguments: Args, return: Return }> {
+	(): FunctionSignature<Args, Return>;
+	(fn: FunctionSignature<Args, Return>): FunctionSignature<Args, Return>;
+	new (fn: FunctionSignature<Args, Return>): FunctionSignature<Args, Return>;
+	definition: { arguments: Args, return: Return };
+
+	return<R extends ModelDefinition>(returnValueDefinition: R): FunctionModel<Args, R>;
+}
+
+export interface FunctionModelConstructor {
+	<Args extends ModelDefinition[]>(...argumentsDefinitions: Args): FunctionModel<Args, any>;
+	new<Args extends ModelDefinition[]>(...argumentsDefinitions: Args): FunctionModel<Args, any>;
+}
+
+export const FunctionModel: FunctionModelConstructor;