fixes for typescript 2.7

Author: xaviergonz

package.json

@@ -1,11 +1,11 @@
 {
 	"private": true,
 	"dependencies": {
-		"lerna": "^2.4.0",
+		"cross-env": "^5.1.1",
 		"husky": "^0.13.4",
-		"prettier": "^1.4.4",
+		"lerna": "^2.4.0",
 		"lint-staged": "^3.6.1",
-		"cross-env":"^5.1.1"
+		"prettier": "^1.4.4"
 	},
 	"scripts": {
 		"clean": "lerna clean",

packages/mobx-state-tree/package.json

@@ -55,7 +55,7 @@
     "tape": "^4.6.0",
     "tslib": "^1.7.1",
     "tslint": "^3.15.1",
-    "typescript": "^2.4.2"
+    "typescript": "^2.7.0"
   },
   "peerDependencies": {
     "mobx": "^3.1.15"

packages/mobx-state-tree/src/core/type/type-checker.ts

@@ -124,7 +124,7 @@ export function typecheckPublic(type: IType<any, any>, value: any): void {
     const errors = type.validate(value, [{ path: "", type }])
 
     if (errors.length > 0) {
-        console.error("Failed to create `${type.name}` from:", value)
+        console.error(`Failed to create "${type.name}" from:`, value)
         fail(
             `Error while converting ${shortenPrintValue(
                 prettyPrintValue(value)

packages/mobx-state-tree/src/types/complex-types/array.ts

@@ -61,11 +61,12 @@ export class ArrayType<S, T> extends ComplexType<S[], IObservableArray<T>> {
         return array
     }
 
-    finalizeNewInstance = (node: ObjectNode, snapshot: any) => {
-        const instance = node.storedValue as IObservableArray<any>
-        extras.getAdministration(instance).dehancer = node.unbox
+    finalizeNewInstance = (node: INode, snapshot: any) => {
+        const objNode = node as ObjectNode
+        const instance = objNode.storedValue as IObservableArray<any>
+        extras.getAdministration(instance).dehancer = objNode.unbox
         intercept(instance, change => this.willChange(change) as any)
-        node.applySnapshot(snapshot)
+        objNode.applySnapshot(snapshot)
         observe(instance, this.didChange)
     }
 

packages/mobx-state-tree/src/types/complex-types/map.ts

@@ -100,11 +100,12 @@ export class MapType<S, T> extends ComplexType<{ [key: string]: S }, IExtendedOb
         return map
     }
 
-    finalizeNewInstance = (node: ObjectNode, snapshot: any) => {
-        const instance = node.storedValue as ObservableMap<any>
-        extras.interceptReads(instance, node.unbox)
+    finalizeNewInstance = (node: INode, snapshot: any) => {
+        const objNode = node as ObjectNode
+        const instance = objNode.storedValue as ObservableMap<any>
+        extras.interceptReads(instance, objNode.unbox)
         intercept(instance, c => this.willChange(c))
-        node.applySnapshot(snapshot)
+        objNode.applySnapshot(snapshot)
         observe(instance, this.didChange)
     }
 

packages/mobx-state-tree/src/types/complex-types/model.ts

@@ -121,7 +121,7 @@ export class ModelType<S, T> extends ComplexType<S, T> implements IModelType<S,
      * The original object definition
      */
     public readonly initializers: ((instance: any) => any)[]
-    public readonly properties: { [K: string]: IType<any, any> }
+    public readonly properties: { [K: string]: IType<any, any> } = {}
     private preProcessor: (snapshot: any) => any | undefined
     private readonly propertiesNames: string[]
 
@@ -190,7 +190,8 @@ export class ModelType<S, T> extends ComplexType<S, T> implements IModelType<S,
     }
 
     props<SP, TP>(
-        properties: { [K in keyof TP]: IType<any, TP[K]> } & { [K in keyof SP]: IType<SP[K], any> }
+        properties: { [K in keyof TP]: IType<any, TP[K]> | TP[K] } &
+            { [K in keyof SP]: IType<SP[K], any> | SP[K] }
     ): IModelType<S & SP, T & TP> {
         return this.cloneAndEnhance({ properties } as any)
     }
@@ -309,15 +310,16 @@ export class ModelType<S, T> extends ComplexType<S, T> implements IModelType<S,
         return instance as Object
     }
 
-    finalizeNewInstance = (node: ObjectNode, snapshot: any) => {
-        const instance = node.storedValue as IStateTreeNode
+    finalizeNewInstance = (node: INode, snapshot: any) => {
+        const objNode = node as ObjectNode
+        const instance = objNode.storedValue as IStateTreeNode
         this.forAllProps((name, type) => {
             extendShallowObservable(instance, {
                 [name]: observable.ref(
-                    type.instantiate(node, name, node._environment, snapshot[name])
+                    type.instantiate(objNode, name, objNode._environment, snapshot[name])
                 )
             })
-            extras.interceptReads(instance, name, node.unbox)
+            extras.interceptReads(instance, name, objNode.unbox)
         })
 
         this.initializers.reduce((self, fn) => fn(self), instance)
@@ -493,10 +495,10 @@ export function model<T = {}>(properties?: IModelProperties<T>): IModelType<Snap
  * @export
  * @alias types.model
  */
-export function model(...args: any[]) {
+export function model<T = {}>(...args: any[]): IModelType<Snapshot<T>, T> {
     const name = typeof args[0] === "string" ? args.shift() : "AnonymousModel"
     const properties = args.shift() || {}
-    return new ModelType({ name, properties })
+    return new ModelType({ name, properties }) as IModelType<Snapshot<T>, T>
 }
 
 export function compose<T1, S1, T2, S2, T3, S3>(

packages/mobx-state-tree/src/utils.ts

@@ -51,7 +51,7 @@ export function extendKeepGetter(a: any, ...b: any[]) {
     for (let i = 0; i < b.length; i++) {
         const current = b[i]
         for (let key in current) {
-            const descriptor = Object.getOwnPropertyDescriptor(current, key)
+            const descriptor = Object.getOwnPropertyDescriptor(current, key)!
             if ("get" in descriptor) {
                 Object.defineProperty(a, key, { ...descriptor, configurable: true })
                 continue

packages/mobx-state-tree/test/action.ts

@@ -258,7 +258,7 @@ test("snapshot should be available and updated during an action", t => {
     const a = Model.create({ x: 2 })
     t.is(a.inc(), 3)
     t.is(a.x, 4)
-    t.is(getSnapshot(a).x, 4)
+    t.is(getSnapshot<typeof Model.SnapshotType>(a).x, 4)
 })
 
 test("indirectly called private functions should be able to modify state", t => {

packages/mobx-state-tree/test/hooks.ts

@@ -242,5 +242,5 @@ test("snapshot processors can be composed", t => {
         }))
     const x = X.create({ x: 25 })
     t.is(x.x, 2)
-    t.is(getSnapshot(x).x, 25)
+    t.is(getSnapshot<typeof X.SnapshotType>(x).x, 25)
 })

packages/mobx-state-tree/test/optimizations.ts

@@ -24,7 +24,7 @@ test("it should avoid processing patch if is exactly the current one in reconcil
     })
     const store = RootModel.create({ a: { a: 1, b: "hello" } })
     unprotect(store)
-    const snapshot = getSnapshot(store)
+    const snapshot = getSnapshot<typeof Model.SnapshotType>(store)
     store.a = snapshot.a
     t.is(getSnapshot(store.a), snapshot.a)
     t.deepEqual(getSnapshot(store), snapshot)