compose can now directly compose model types as well

Author: mweststrate

README.md

@@ -529,6 +529,7 @@ These are the types available in MST. All types can be found in the `types` name
 * `types.maybe(type)` makes a type optional and nullable, shorthand for `types.optional(types.union(type, types.literal(null)), null)`.
 * `types.late(() => type)` can be used to create recursive or circular types, or types that are spread over files in such a way that circular dependencies between files would be an issue otherwise.
 * `types.frozen` Accepts any kind of serializable value (both primitive and complex), but assumes that the value itself is immutable.
+* `types.compose(name?, type1...typeX)`, creates a new model type by taking a bunch of existing types and combining it into a new one
 * `types.compose(name?, baseType, props, volatileState?, actions?)`, creates a new model type by taking an existing type and introducing additional properties, state and actions
 
 ## Property types

src/types/complex-types/object.ts

@@ -273,6 +273,26 @@ export function model(...args: any[]) {
     return new ObjectType(name, props, volatileState, actions)
 }
 
+export function compose<T1, S1, A1, T2, S2, A2>(
+    name: string,
+    t1: IModelType<T1, S1, A1>,
+    t2: IModelType<T2, S2, A2>
+): IModelType<T1 & T2, S1 & S2, A1 & A2>
+export function compose<T1, S1, A1, T2, S2, A2>(
+    t1: IModelType<T1, S1, A1>,
+    t2: IModelType<T2, S2, A2>
+): IModelType<T1 & T2, S1 & S2, A1 & A2>
+export function compose<T1, S1, A1, T2, S2, A2>(
+    name: string,
+    t1: IModelType<T1, S1, A1>,
+    t2: IModelType<T2, S2, A2>
+): IModelType<T1 & T2, S1 & S2, A1 & A2>
+export function compose<T1, S1, A1, T2, S2, A2, T3, S3, A3>(
+    name: string,
+    t1: IModelType<T1, S1, A1>,
+    t2: IModelType<T2, S2, A2>,
+    t3: IModelType<T3, S3, A3>
+): IModelType<T1 & T2 & T3, S1 & S2 & S3, A1 & A2 & A3> // ...and so forth...
 export function compose<BASE_T, BASE_S, BASE_A, T, S, A>(
     baseType: IModelType<BASE_T, BASE_S, BASE_A>,
     properties: IModelProperties<T> & ThisType<T & BASE_T>
@@ -306,8 +326,21 @@ export function compose<BASE_T, BASE_S, BASE_A, T, S, A>(
     volatileState: IModelVolatileState<S> & ThisType<BASE_T & T & BASE_S & S>,
     operations: A & ThisType<BASE_T & T & BASE_S & S & BASE_A & A>
 ): IModelType<BASE_T & T, BASE_S & S, BASE_A & A>
+export function compose<T1, S1, A1, T2, S2, A2, T3, S3, A3>(
+    t1: IModelType<T1, S1, A1>,
+    t2: IModelType<T2, S2, A2>,
+    t3: IModelType<T3, S3, A3>
+): IModelType<T1 & T2 & T3, S1 & S2 & S3, A1 & A2 & A3> // ...and so forth...
 export function compose(...args: any[]) {
     const typeName = typeof args[0] === "string" ? args.shift() : "AnonymousModel"
+
+    if (args.every(arg => isType(arg))) {
+        // compose types
+        return (args as IModelType<any, any, any>[]).reduce((prev, cur) =>
+            compose(typeName, prev, cur.properties, cur.state, cur.actions)
+        )
+    }
+
     const baseType = args.shift()
     const props = args.shift() || fail("types.compose must specify properties or `{}`")
     const volatileState = (args.length > 1 && args.shift()) || {}

test/object.ts

@@ -305,6 +305,16 @@ test("it should compose factories with computed properties", t => {
     t.is(typeof store.setHeight, "function")
 })
 
+test("it should compose multiple types with computed properties", t => {
+    const { ComputedFactory2, ColorFactory } = createTestFactories()
+    const ComposedFactory = types.compose(ColorFactory, ComputedFactory2)
+    const store = ComposedFactory.create({ props: { width: 100, height: 200 } })
+    t.deepEqual(getSnapshot(store), { props: { width: 100, height: 200 }, color: "#FFFFFF" })
+    t.is(store.area, 20000)
+    t.is(typeof store.setWidth, "function")
+    t.is(typeof store.setHeight, "function")
+})
+
 test("methods get overridden by compose", t => {
     const A = types.model(
         {