Merge branch 'transformer-not-memorize-outside' of https://github.com…

…/upsuper/mobx-utils into upsuper-transformer-not-memorize-outside

.watchmanconfig

@@ -0,0 +1 @@
+{}

src/create-transformer.ts

@@ -1,14 +1,19 @@
-import { computed, onBecomeUnobserved, IComputedValue, IComputedValueOptions } from "mobx"
+import {
+    computed,
+    onBecomeUnobserved,
+    IComputedValue,
+    _isComputingDerivation,
+    IComputedValueOptions
+} from "mobx"
 import { invariant, addHiddenProp } from "./utils"
 
 export type ITransformer<A, B> = (object: A) => B
 
-export type ITransformerParams<A, B> =
-    | {
-          onCleanup?: (resultObject: B | undefined, sourceObject?: A) => void
-          debugNameGenerator?: (sourceObject?: A) => string
-      }
-    | Omit<IComputedValueOptions<B>, "name">
+export type ITransformerParams<A, B> = {
+    onCleanup?: (resultObject: B | undefined, sourceObject?: A) => void
+    debugNameGenerator?: (sourceObject?: A) => string
+    keepAlive?: boolean
+} & Omit<IComputedValueOptions<B>, "name">
 
 let memoizationId = 0
 
@@ -38,7 +43,15 @@ export function createTransformer<A, B>(
     // Memoizes: object id -> reactive view that applies transformer to the object
     let views: { [id: number]: IComputedValue<B> } = {}
     let onCleanup: Function = undefined
+    let keepAlive: boolean = false
     let debugNameGenerator: Function = undefined
+    if (typeof arg2 === "object") {
+        onCleanup = arg2.onCleanup
+        keepAlive = arg2.keepAlive !== undefined ? arg2.keepAlive : false
+        debugNameGenerator = arg2.debugNameGenerator
+    } else if (typeof arg2 === "function") {
+        onCleanup = arg2
+    }
 
     function createView(sourceIdentifier: number, sourceObject: A) {
         let latestValue: B
@@ -65,18 +78,33 @@ export function createTransformer<A, B>(
                 name: prettifiedName
             }
         )
-        const disposer = onBecomeUnobserved(expr, () => {
-            delete views[sourceIdentifier]
-            disposer()
-            if (onCleanup) onCleanup(latestValue, sourceObject)
-        })
+        if (!keepAlive) {
+            const disposer = onBecomeUnobserved(expr, () => {
+                delete views[sourceIdentifier]
+                disposer()
+                if (onCleanup) onCleanup(latestValue, sourceObject)
+            })
+        }
         return expr
     }
 
+    let memoWarned = false
     return (object: A) => {
         const identifier = getMemoizationId(object)
         let reactiveView = views[identifier]
         if (reactiveView) return reactiveView.get()
+        if (!keepAlive && !_isComputingDerivation()) {
+            if (!memoWarned) {
+                console.warn(
+                    "invoking a transformer from outside a reactive context won't memorized " +
+                        "and is cleaned up immediately, unless keepAlive is set"
+                )
+                memoWarned = true
+            }
+            const value = transformer(object)
+            if (onCleanup) onCleanup(value, object)
+            return value
+        }
         // Not in cache; create a reactive view
         reactiveView = views[identifier] = createView(identifier, object)
         return reactiveView.get()

test/create-transformer.ts

@@ -1369,3 +1369,21 @@ test("supports computed value options", () => {
     xs.push(4)
     expect(events).toEqual([])
 })
+
+test("should not memorize outside reactive context", () => {
+    let transformer = jest.fn((input: string) => input.toLowerCase())
+    let onCleanup = jest.fn()
+    let stubTransformer = createTransformer(transformer, onCleanup)
+
+    stubTransformer("HELLO")
+    expect(transformer).toHaveBeenCalledWith("HELLO")
+    expect(onCleanup).toHaveBeenCalledWith("hello", "HELLO")
+    transformer.mockClear()
+    onCleanup.mockClear()
+
+    stubTransformer("HELLO")
+    expect(transformer).toHaveBeenCalledWith("HELLO")
+    expect(onCleanup).toHaveBeenCalledWith("hello", "HELLO")
+    transformer.mockClear()
+    onCleanup.mockClear()
+})