objectmodel 4.3.1 → 4.4.1

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.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/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];

package/types/index.d.ts

@@ -1,132 +1,10 @@
 // TypeScript definition file for ObjectModel
 
-export interface Model {
-	(value?: any): any;
-
-	definition: any;
-	assertions: Assertion[];
-	default: any;
-	name: string;
-
-	conventionForConstant(variableName: string): boolean;
-	conventionForPrivate(variableName: string): boolean;
-
-	toString(stack?: any[]): string;
-
-	as(name: string): this;
-
-	defaultTo(defaultValue: any): this;
-
-	test(value: any, errorCollector?: (errors: ModelError[]) => void): boolean;
-
-	errorCollector(errors: ModelError[]): void;
-
-	assert(assertion: Assertion, description?: string | Function): this;
-
-}
-
-export interface ModelConstructor {
-	(definition: any): ObjectModel;
-	new(definition: any): ObjectModel;
-	CHECK_ONCE: symbol;
-}
-
-export interface BasicModel extends Model {
-	(): any;
-	new(): any;
-	(value: any): any
-	new(value: any): any
-
-	extend(...otherDefinitions: Array<any>): this;
-}
-
-export interface BasicModelConstructor {
-	(definition: any): BasicModel
-	new(definition: any): BasicModel;
-}
-
-export interface ObjectModel extends Model {
-	(): Object;
-	new(): Object;
-	(object: object): Object;
-	new(object: object): Object;
-
-	extend(...otherDefinitions: Array<Object | ObjectModel>): this;
-}
-
-export interface ObjectModelConstructor {
-	(definition: Object): ObjectModel;
-	new(definition: Object): ObjectModel;
-}
-
-export interface ArrayModel extends Model {
-	<T>(): Array<T>;
-	new <T>(): Array<T>;
-	<T>(array: Array<T>): Array<T>;
-	new <T>(array: Array<T>): Array<T>;
-
-	extend(...otherElementDefinitions: Array<any>): this;
-}
-
-export interface ArrayModelConstructor {
-	(itemDefinition: any): ArrayModel;
-	new(itemDefinition: any): ArrayModel;
-}
-
-export interface FunctionModel extends Model {
-	(): Function;
-	new(): Function;
-	(fn: Function): Function;
-	new(fn: Function): Function;
-
-	definition: { arguments: any[], return: any };
-
-	return(returnValueDefinition: any): FunctionModel;
-
-	extend(otherArgsDefinitions: Array<any>, otherReturnValuesDefinitions: Array<any>): this;
-}
-
-export interface FunctionModelConstructor {
-	(...argumentsDefinitions: any[]): FunctionModel;
-	new(...argumentsDefinitions: any[]): FunctionModel;
-}
-
-export interface MapModel extends Model {
-	(): Map<any, any>;
-	new(): Map<any, any>;
-	(iterable: Map<any, any> | Array<[any, any]>): Map<any, any>;
-	new(iterable: Map<any, any> | Array<[any, any]>): Map<any, any>;
-
-	extend(otherKeyDefinitions: Array<any>, otherValueDefinitions: Array<any>): this;
-}
-
-export interface MapModelConstructor {
-	(keyDefinition: any, valueDefinition: any): MapModel;
-	new(keyDefinition: any, valueDefinition: any): MapModel;
-}
-
-export interface SetModel extends Model {
-	(): Set<any>;
-	new(): Set<any>;
-	(set: Set<any> | Array<any>): Set<any>;
-	new(set: Set<any> | Array<any>): Set<any>;
-
-	extend(...otherElementDefinitions: Array<any>): this;
-}
-
-export interface SetModelConstructor {
-	(itemDefinition: any): SetModel;
-	new(itemDefinition: any): SetModel;
-}
-
-export type Assertion = (variable: any) => boolean
-
-export interface ModelError {
-	message: string;
-	expected: any;
-	received: any;
-	path: string;
-}
+import { ArrayModelConstructor } from "../src/array-model";
+import { FunctionModelConstructor } from "../src/function-model";
+import { MapModelConstructor } from "../src/map-model";
+import { ModelConstructor, BasicModelConstructor, ObjectModelConstructor } from "../src/object-model";
+import { SetModelConstructor } from "../src/set-model";
 
 export const Any: any;
 export const Model: ModelConstructor;
@@ -135,4 +13,4 @@ export const ObjectModel: ObjectModelConstructor;
 export const ArrayModel: ArrayModelConstructor;
 export const FunctionModel: FunctionModelConstructor;
 export const MapModel: MapModelConstructor;
-export const SetModel: SetModelConstructor;
+export const SetModel: SetModelConstructor;

package/.travis.yml

@@ -1,3 +0,0 @@
-language: node_js
-node_js:
-  - "13"