objectmodel 4.3.1 → 4.4.0

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/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)
+	}
 })