objectmodel 4.3.0 → 4.4.0

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/helpers.js

@@ -1,44 +1,44 @@
-export const
-	ObjectProto = Object.prototype,
-	bettertypeof = x => ObjectProto.toString.call(x).match(/\s([a-zA-Z]+)/)[1],
-	getProto = Object.getPrototypeOf,
-	setProto = Object.setPrototypeOf,
-
-	has = (o, prop) => ObjectProto.hasOwnProperty.call(o, prop),
-	is = (Constructor, obj) => obj instanceof Constructor,
-	isFunction = f => typeof f === "function",
-	isObject = o => o && typeof o === "object",
-	isString = s => typeof s === "string",
-	isPlainObject = o => isObject(o) && getProto(o) === ObjectProto,
-	isIterable = x => x && isFunction(x[Symbol.iterator]),
-
-	proxify = (val, traps) => new Proxy(val, traps),
-
-	merge = (target, src = {}) => {
-		for (let key in src) {
-			if (isPlainObject(src[key])) {
-				const o = {}
-				merge(o, target[key])
-				merge(o, src[key])
-				target[key] = o
-			} else {
-				target[key] = src[key]
-			}
-		}
-		return target
-	},
-
-	define = (obj, key, value, enumerable = false) => {
-		Object.defineProperty(obj, key, { value, enumerable, writable: true, configurable: true })
-	},
-
-	extend = (child, parent, props) => {
-		child.prototype = Object.assign(Object.create(parent.prototype, {
-			constructor: {
-				value: child,
-				writable: true,
-				configurable: true
-			}
-		}), props)
-		setProto(child, parent)
+export const
+	ObjectProto = Object.prototype,
+	bettertypeof = x => ObjectProto.toString.call(x).match(/\s([a-zA-Z]+)/)[1],
+	getProto = Object.getPrototypeOf,
+	setProto = Object.setPrototypeOf,
+
+	has = (o, prop) => ObjectProto.hasOwnProperty.call(o, prop),
+	is = (Constructor, obj) => obj instanceof Constructor,
+	isFunction = f => typeof f === "function",
+	isObject = o => o && typeof o === "object",
+	isString = s => typeof s === "string",
+	isPlainObject = o => isObject(o) && getProto(o) === ObjectProto,
+	isIterable = x => x && isFunction(x[Symbol.iterator]),
+
+	proxify = (val, traps) => new Proxy(val, traps),
+
+	merge = (target, src = {}) => {
+		for (let key in src) {
+			if (isPlainObject(src[key])) {
+				const o = {}
+				merge(o, target[key])
+				merge(o, src[key])
+				target[key] = o
+			} else {
+				target[key] = src[key]
+			}
+		}
+		return target
+	},
+
+	define = (obj, key, value, enumerable = false) => {
+		Object.defineProperty(obj, key, { value, enumerable, writable: true, configurable: true })
+	},
+
+	extend = (child, parent, props) => {
+		child.prototype = Object.assign(Object.create(parent.prototype, {
+			constructor: {
+				value: child,
+				writable: true,
+				configurable: true
+			}
+		}), props)
+		setProto(child, parent)
 	}

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/list-model.js

@@ -1,44 +1,44 @@
-
-import { _original, checkAssertions, checkDefinition, initModel, unstackErrors } from "./object-model.js"
-import { has, isFunction, proxify } from "./helpers.js"
-
-export const initListModel = (base, constructor, def, init, clone, mutators, otherTraps) => {
-
-	return initModel(def, constructor, base, init, model => Object.assign({
-		getPrototypeOf: () => model.prototype,
-		get(l, key) {
-			if (key === _original) return l
-
-			const val = l[key]
-			return isFunction(val) ? proxify(val, {
-				apply(fn, ctx, args) {
-					if (has(mutators, key)) {
-						// indexes of arguments to check def + cast
-						const [begin, end = args.length - 1, getArgDef] = mutators[key]
-						for (let i = begin; i <= end; i++) {
-							const argDef = getArgDef ? getArgDef(i) : model.definition
-							args[i] = checkDefinition(
-								args[i],
-								argDef,
-								`${base.name}.${key} arguments[${i}]`,
-								model.errors,
-								[],
-								true
-							)
-						}
-
-						if (model.assertions.length > 0) {
-							const testingClone = clone(l)
-							fn.apply(testingClone, args)
-							checkAssertions(testingClone, model, `after ${key} mutation`)
-						}
-
-						unstackErrors(model)
-					}
-
-					return fn.apply(l, args)
-				}
-			}) : val
-		}
-	}, otherTraps))
+
+import { _original, checkAssertions, checkDefinition, initModel, unstackErrors } from "./object-model.js"
+import { has, isFunction, proxify } from "./helpers.js"
+
+export const initListModel = (base, constructor, def, init, clone, mutators, otherTraps) => {
+
+	return initModel(def, constructor, base, init, model => Object.assign({
+		getPrototypeOf: () => model.prototype,
+		get(l, key) {
+			if (key === _original) return l
+
+			const val = l[key]
+			return isFunction(val) ? proxify(val, {
+				apply(fn, ctx, args) {
+					if (has(mutators, key)) {
+						// indexes of arguments to check def + cast
+						const [begin, end = args.length - 1, getArgDef] = mutators[key]
+						for (let i = begin; i <= end; i++) {
+							const argDef = getArgDef ? getArgDef(i) : model.definition
+							args[i] = checkDefinition(
+								args[i],
+								argDef,
+								`${base.name}.${key} arguments[${i}]`,
+								model.errors,
+								[],
+								true
+							)
+						}
+
+						if (model.assertions.length > 0) {
+							const testingClone = clone(l)
+							fn.apply(testingClone, args)
+							checkAssertions(testingClone, model, `after ${key} mutation`)
+						}
+
+						unstackErrors(model)
+					}
+
+					return fn.apply(l, args)
+				}
+			}) : val
+		}
+	}, otherTraps))
 }

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;

package/src/map-model.js

@@ -1,49 +1,49 @@
-import {
-	_check, cast, checkAssertions, checkDefinition,
-	extendDefinition, extendModel, format, formatDefinition, Model, stackError
-} from "./object-model.js"
-import { initListModel } from "./list-model.js"
-import { extend, is, isIterable } from "./helpers.js"
-
-export default function MapModel(initialKeyDefinition, initialValueDefinition) {
-	const getDef = i => i === 0 ? model.definition.key : model.definition.value;
-	const model = initListModel(
-		Map,
-		MapModel,
-		{ key: initialKeyDefinition, value: initialValueDefinition },
-		it => isIterable(it) ? new Map([...it].map(pair => pair.map((x, i) => cast(x, getDef(i))))) : it,
-		map => new Map(map),
-		{
-			"set": [0, 1, getDef],
-			"delete": [],
-			"clear": []
-		}
-	)
-
-	return model
-}
-
-extend(MapModel, Model, {
-	toString(stack) {
-		return `Map of ${formatDefinition(this.definition.key, stack)} : ${formatDefinition(this.definition.value, stack)}`
-	},
-
-	[_check](map, path, errors, stack) {
-		if (is(Map, map)) {
-			path = path || "Map"
-			for (let [key, value] of map) {
-				checkDefinition(key, this.definition.key, `${path} key`, errors, stack)
-				checkDefinition(value, this.definition.value, `${path}[${format(key)}]`, errors, stack)
-			}
-		} else stackError(errors, this, map, path)
-
-		checkAssertions(map, this, path, errors)
-	},
-
-	extend(keyParts, valueParts) {
-		return extendModel(new MapModel(
-			extendDefinition(this.definition.key, keyParts),
-			extendDefinition(this.definition.value, valueParts)
-		), this)
-	}
+import {
+	_check, cast, checkAssertions, checkDefinition,
+	extendDefinition, extendModel, format, formatDefinition, Model, stackError
+} from "./object-model.js"
+import { initListModel } from "./list-model.js"
+import { extend, is, isIterable } from "./helpers.js"
+
+export default function MapModel(initialKeyDefinition, initialValueDefinition) {
+	const getDef = i => i === 0 ? model.definition.key : model.definition.value;
+	const model = initListModel(
+		Map,
+		MapModel,
+		{ key: initialKeyDefinition, value: initialValueDefinition },
+		it => isIterable(it) ? new Map([...it].map(pair => pair.map((x, i) => cast(x, getDef(i))))) : it,
+		map => new Map(map),
+		{
+			"set": [0, 1, getDef],
+			"delete": [],
+			"clear": []
+		}
+	)
+
+	return model
+}
+
+extend(MapModel, Model, {
+	toString(stack) {
+		return `Map of ${formatDefinition(this.definition.key, stack)} : ${formatDefinition(this.definition.value, stack)}`
+	},
+
+	[_check](map, path, errors, stack) {
+		if (is(Map, map)) {
+			path = path || "Map"
+			for (let [key, value] of map) {
+				checkDefinition(key, this.definition.key, `${path} key`, errors, stack)
+				checkDefinition(value, this.definition.value, `${path}[${format(key)}]`, errors, stack)
+			}
+		} else stackError(errors, this, map, path)
+
+		checkAssertions(map, this, path, errors)
+	},
+
+	extend(keyParts, valueParts) {
+		return extendModel(new MapModel(
+			extendDefinition(this.definition.key, keyParts),
+			extendDefinition(this.definition.value, valueParts)
+		), this)
+	}
 })

package/src/object-model.d.ts

@@ -0,0 +1,74 @@
+import { ExtendObjectDefinition, FromDefinition, FromObjectModelDefinition, ModelDefinition, ObjectModelDefinition } from '../types/definitions';
+
+export type Assertion = (variable: unknown) => boolean
+
+export interface ModelError {
+	message: string;
+	expected: any;
+	received: any;
+	path: string;
+}
+
+export interface Model<D> {	
+	definition: D;
+	assertions: Assertion[];
+	name: string;
+
+	conventionForConstant(variableName: string): boolean;
+	conventionForPrivate(variableName: string): boolean;
+
+	toString(stack?: any[]): string;
+
+	as(name: string): this;
+
+	defaultTo<Default>(defaultValue: Default): ModelWithDefault<D,Default>;
+
+	test(value: any, errorCollector?: (errors: ModelError[]) => void): boolean;
+
+	errorCollector(errors: ModelError[]): void;
+
+	assert(assertion: Assertion, description?: string | Function): this;
+
+}
+
+export interface ModelWithDefault<D,Default> extends Model<D> {
+	default: Default
+
+	(): Default
+	new(): Default
+}
+
+export interface ModelConstructor {
+	<D>(definition: D): D extends ObjectModelDefinition ? ObjectModel<D> : BasicModel<D>;
+	new<D>(definition: D): D extends ObjectModelDefinition ? ObjectModel<D> : BasicModel<D>;
+	CHECK_ONCE: symbol;
+}
+
+export interface BasicModel<D> extends Model<D> {
+	(value: FromDefinition<D>): FromDefinition<D>
+	new(value: FromDefinition<D>): FromDefinition<D>
+	
+	extend<E extends ModelDefinition[]>(...extensions: E): BasicModel<E extends [] ? D : [D, ...E]>;
+}
+
+export interface BasicModelConstructor {
+	<D>(definition: D): BasicModel<D>
+	new<D>(definition: D): BasicModel<D>;
+}
+
+export interface ObjectModel<D extends ObjectModelDefinition> extends Model<D> {
+	(value: Partial<FromObjectModelDefinition<D>>): FromObjectModelDefinition<D>;
+	new(value: Partial<FromObjectModelDefinition<D>>): FromObjectModelDefinition<D>;
+
+	extend<Extensions extends (ObjectModelDefinition | ObjectModel<any>)[]>(...ext: Extensions) : ObjectModel<ExtendObjectDefinition<D, Extensions>>;
+}
+
+export interface ObjectModelConstructor {
+	<D extends ObjectModelDefinition>(definition: D): ObjectModel<D>;
+	new<D extends ObjectModelDefinition>(definition: D): ObjectModel<D>;
+}
+
+export const Any: any;
+export const Model: ModelConstructor;
+export const BasicModel: BasicModelConstructor;
+export const ObjectModel: ObjectModelConstructor;

package/src/object-model.js

@@ -33,7 +33,8 @@ export const
 		if (is(model, obj)) return obj
 
 		if (!isObject(obj) && !isFunction(obj) && obj !== undefined) {
-			stackError(model.errors, Object, obj)
+			// short circuit validation if not receiving an object as expected
+			return obj
 		}
 
 		merge(_this, model.default)
@@ -325,8 +326,8 @@ export const
 	}
 
 
-export function Model(def, params) {
-	return isPlainObject(def) ? new ObjectModel(def, params) : new BasicModel(def)
+export function Model(def) {
+	return isPlainObject(def) ? new ObjectModel(def) : new BasicModel(def)
 }
 
 Object.assign(Model.prototype, {

package/src/set-model.d.ts

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

package/src/set-model.js

@@ -1,42 +1,42 @@
-import {
-	_check, cast, checkAssertions, checkDefinition,
-	extendDefinition, extendModel, formatDefinition, Model, stackError
-} from "./object-model.js"
-import { initListModel } from "./list-model.js"
-import { extend, is, isIterable } from "./helpers.js"
-
-export default function SetModel(initialDefinition) {
-	const model = initListModel(
-		Set,
-		SetModel,
-		initialDefinition,
-		it => isIterable(it) ? new Set([...it].map(val => cast(val, model.definition))) : it,
-		set => new Set(set),
-		{
-			"add": [0, 0],
-			"delete": [],
-			"clear": []
-		}
-	)
-
-	return model
-}
-
-extend(SetModel, Model, {
-	toString(stack) {
-		return "Set of " + formatDefinition(this.definition, stack)
-	},
-
-	[_check](set, path, errors, stack) {
-		if (is(Set, set)) {
-			for (let item of set.values()) {
-				checkDefinition(item, this.definition, `${path || "Set"} value`, errors, stack)
-			}
-		} else stackError(errors, this, set, path)
-		checkAssertions(set, this, path, errors)
-	},
-
-	extend(...newParts) {
-		return extendModel(new SetModel(extendDefinition(this.definition, newParts)), this)
-	}
+import {
+	_check, cast, checkAssertions, checkDefinition,
+	extendDefinition, extendModel, formatDefinition, Model, stackError
+} from "./object-model.js"
+import { initListModel } from "./list-model.js"
+import { extend, is, isIterable } from "./helpers.js"
+
+export default function SetModel(initialDefinition) {
+	const model = initListModel(
+		Set,
+		SetModel,
+		initialDefinition,
+		it => isIterable(it) ? new Set([...it].map(val => cast(val, model.definition))) : it,
+		set => new Set(set),
+		{
+			"add": [0, 0],
+			"delete": [],
+			"clear": []
+		}
+	)
+
+	return model
+}
+
+extend(SetModel, Model, {
+	toString(stack) {
+		return "Set of " + formatDefinition(this.definition, stack)
+	},
+
+	[_check](set, path, errors, stack) {
+		if (is(Set, set)) {
+			for (let item of set.values()) {
+				checkDefinition(item, this.definition, `${path || "Set"} value`, errors, stack)
+			}
+		} else stackError(errors, this, set, path)
+		checkAssertions(set, this, path, errors)
+	},
+
+	extend(...newParts) {
+		return extendModel(new SetModel(extendDefinition(this.definition, newParts)), this)
+	}
 })