objectmodel 4.3.1 → 4.4.1

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;

package/src/function-model.js

@@ -1,66 +1,59 @@
-import {
-	_check, _original, Any, checkAssertions, checkDefinition, extendDefinition, extendModel,
-	formatDefinition, initModel, Model, stackError, unstackErrors
-} from "./object-model.js"
-import { extend, is, isFunction } from "./helpers.js"
-
-export default function FunctionModel(...argsDef) {
-	return initModel({ arguments: argsDef }, FunctionModel, Function, null, model => ({
-		getPrototypeOf: () => model.prototype,
-
-		get(fn, key) {
-			return key === _original ? fn : fn[key]
-		},
-
-		apply(fn, ctx, args) {
-			const def = model.definition
-			const remainingArgDef = def.arguments.find(argDef => is(Any.remaining, argDef))
-			const nbArgsToCheck = remainingArgDef ? Math.max(args.length, def.arguments.length - 1) : def.arguments.length
-
-			for (let i = 0; i < nbArgsToCheck; i++) {
-				const argDef = remainingArgDef && i >= def.arguments.length - 1 ? remainingArgDef.definition : def.arguments[i]
-				args[i] = checkDefinition(args[i], argDef, `arguments[${i}]`, model.errors, [], true)
-			}
-
-			checkAssertions(args, model, "arguments")
-
-			let result
-			if (!model.errors.length) {
-				result = Reflect.apply(fn, ctx, args)
-				if ("return" in def)
-					result = checkDefinition(result, def.return, "return value", model.errors, [], true)
-			}
-			unstackErrors(model)
-			return result
-		}
-	}))
-}
-
-extend(FunctionModel, Model, {
-	toString(stack = []) {
-		let out = `Function(${this.definition.arguments.map(
-			argDef => formatDefinition(argDef, [...stack])
-		).join(", ")})`
-
-		if ("return" in this.definition) {
-			out += " => " + formatDefinition(this.definition.return, stack)
-		}
-		return out
-	},
-
-	return(def) {
-		this.definition.return = def
-		return this
-	},
-
-	extend(newArgs, newReturns) {
-		const args = this.definition.arguments,
-			  mixedArgs = newArgs.map((a, i) => extendDefinition(i in args ? args[i] : [], newArgs[i])),
-			  mixedReturns = extendDefinition(this.definition.return, newReturns)
-		return extendModel(new FunctionModel(...mixedArgs).return(mixedReturns), this)
-	},
-
-	[_check](f, path, errors) {
-		if (!isFunction(f)) stackError(errors, "Function", f, path)
-	}
+import {
+	_check, _original, Any, checkAssertions, checkDefinition, extendDefinition, extendModel,
+	formatDefinition, initModel, Model, stackError, unstackErrors
+} from "./object-model.js"
+import { extend, is, isFunction } from "./helpers.js"
+
+export default function FunctionModel(...argsDef) {
+	return initModel({ arguments: argsDef }, FunctionModel, Function, null, model => ({
+		getPrototypeOf: () => model.prototype,
+
+		get(fn, key) {
+			return key === _original ? fn : fn[key]
+		},
+
+		apply(fn, ctx, args) {
+			const def = model.definition
+			const remainingArgDef = def.arguments.find(argDef => is(Any.remaining, argDef))
+			const nbArgsToCheck = remainingArgDef ? Math.max(args.length, def.arguments.length - 1) : def.arguments.length
+
+			for (let i = 0; i < nbArgsToCheck; i++) {
+				const argDef = remainingArgDef && i >= def.arguments.length - 1 ? remainingArgDef.definition : def.arguments[i]
+				args[i] = checkDefinition(args[i], argDef, `arguments[${i}]`, model.errors, [], true)
+			}
+
+			checkAssertions(args, model, "arguments")
+
+			let result
+			if (!model.errors.length) {
+				result = Reflect.apply(fn, ctx, args)
+				if ("return" in def)
+					result = checkDefinition(result, def.return, "return value", model.errors, [], true)
+			}
+			unstackErrors(model)
+			return result
+		}
+	}))
+}
+
+extend(FunctionModel, Model, {
+	toString(stack = []) {
+		let out = `Function(${this.definition.arguments.map(
+			argDef => formatDefinition(argDef, [...stack])
+		).join(", ")})`
+
+		if ("return" in this.definition) {
+			out += " => " + formatDefinition(this.definition.return, stack)
+		}
+		return out
+	},
+
+	return(def) {
+		this.definition.return = def
+		return this
+	},
+
+	[_check](f, path, errors) {
+		if (!isFunction(f)) stackError(errors, "Function", f, path)
+	}
 })

package/src/index.js

@@ -1,5 +1,5 @@
-export { Model, BasicModel, ObjectModel, Any } from "./object-model.js"
-export { default as ArrayModel } from "./array-model.js"
-export { default as FunctionModel } from "./function-model.js"
-export { default as MapModel } from "./map-model.js"
+export { Model, BasicModel, ObjectModel, Any } from "./object-model.js"
+export { default as ArrayModel } from "./array-model.js"
+export { default as FunctionModel } from "./function-model.js"
+export { default as MapModel } from "./map-model.js"
 export { default as SetModel } from "./set-model.js"

package/src/map-model.d.ts

@@ -0,0 +1,18 @@
+import { FromDefinition, ModelDefinition } from "../types/definitions";
+import { Model } from "./object-model";
+
+export interface MapModel<Key extends ModelDefinition, Value extends ModelDefinition> extends Model<{ key: Key, value: Value}> {
+	(iterable: Map<FromDefinition<Key>, FromDefinition<Value>> | Array<[FromDefinition<Key>, FromDefinition<Value>]>): Map<FromDefinition<Key>, FromDefinition<Value>>;
+	new(iterable: Map<FromDefinition<Key>, FromDefinition<Value>> | Array<[FromDefinition<Key>, FromDefinition<Value>]>): Map<FromDefinition<Key>, FromDefinition<Value>>;
+
+	definition: { key: Key, value: Value };
+	
+	extend<Keys extends ModelDefinition[], Values extends ModelDefinition[]>(otherKeys: Keys, otherValues: Values): MapModel<[Key, ...Keys], [Value, ...Values]>
+}
+
+export interface MapModelConstructor {
+	<Key extends ModelDefinition, Value extends ModelDefinition>(keyDefinition: Key, valueDefinition: Value): MapModel<Key, Value>;
+	new<Key extends ModelDefinition, Value extends ModelDefinition>(keyDefinition: Key, valueDefinition: Value): MapModel<Key, Value>;
+}
+
+export const MapModel: MapModelConstructor;