mobx 6.3.11 → 6.4.1

package/src/api/when.ts

@@ -25,8 +25,9 @@ export function when(
     opts?: IWhenOptions
 ): IReactionDisposer
 export function when(predicate: any, arg1?: any, arg2?: any): any {
-    if (arguments.length === 1 || (arg1 && typeof arg1 === "object"))
+    if (arguments.length === 1 || (arg1 && typeof arg1 === "object")) {
         return whenPromise(predicate, arg1)
+    }
     return _when(predicate, arg1, arg2 || {})
 }
 
@@ -37,8 +38,11 @@ function _when(predicate: () => boolean, effect: Lambda, opts: IWhenOptions): IR
         timeoutHandle = setTimeout(() => {
             if (!disposer[$mobx].isDisposed_) {
                 disposer()
-                if (opts.onError) opts.onError(error)
-                else throw error
+                if (opts.onError) {
+                    opts.onError(error)
+                } else {
+                    throw error
+                }
             }
         }, opts.timeout)
     }
@@ -54,7 +58,9 @@ function _when(predicate: () => boolean, effect: Lambda, opts: IWhenOptions): IR
         let cond = allowStateChanges(false, predicate)
         if (cond) {
             r.dispose()
-            if (timeoutHandle) clearTimeout(timeoutHandle)
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle)
+            }
             effectAction()
         }
     }, opts)
@@ -65,8 +71,9 @@ function whenPromise(
     predicate: () => boolean,
     opts?: IWhenOptions
 ): Promise<void> & { cancel(): void } {
-    if (__DEV__ && opts && opts.onError)
+    if (__DEV__ && opts && opts.onError) {
         return die(`the options 'onError' and 'promise' cannot be combined`)
+    }
     let cancel
     const res = new Promise((resolve, reject) => {
         let disposer = _when(predicate, resolve as Lambda, { ...opts, onError: reject })

package/src/core/action.ts

@@ -38,9 +38,12 @@ export function createAction(
     ref?: Object
 ): Function {
     if (__DEV__) {
-        if (!isFunction(fn)) die("`action` can only be invoked on functions")
-        if (typeof actionName !== "string" || !actionName)
+        if (!isFunction(fn)) {
+            die("`action` can only be invoked on functions")
+        }
+        if (typeof actionName !== "string" || !actionName) {
             die(`actions should have valid names, got: '${actionName}'`)
+        }
     }
     function res() {
         return executeAction(actionName, autoAction, fn, ref || this, arguments)
@@ -136,7 +139,9 @@ export function _endAction(runInfo: IActionRunInfo) {
     allowStateChangesEnd(runInfo.prevAllowStateChanges_)
     allowStateReadsEnd(runInfo.prevAllowStateReads_)
     endBatch()
-    if (runInfo.runAsAction_) untrackedEnd(runInfo.prevDerivation_)
+    if (runInfo.runAsAction_) {
+        untrackedEnd(runInfo.prevDerivation_)
+    }
     if (__DEV__ && runInfo.notifySpy_) {
         spyReportEnd({ time: Date.now() - runInfo.startTime_ })
     }

package/src/core/computedvalue.ts

@@ -114,7 +114,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
      * This is useful for working with vectors, mouse coordinates etc.
      */
     constructor(options: IComputedValueOptions<T>) {
-        if (!options.get) die(31)
+        if (!options.get) {
+            die(31)
+        }
         this.derivation = options.get!
         this.name_ = options.name || (__DEV__ ? "ComputedValue@" + getNextId() : "ComputedValue")
         if (options.set) {
@@ -157,7 +159,9 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
      * Will evaluate its computation first if needed.
      */
     public get(): T {
-        if (this.isComputing_) die(32, this.name_, this.derivation)
+        if (this.isComputing_) {
+            die(32, this.name_, this.derivation)
+        }
         if (
             globalState.inBatch === 0 &&
             // !globalState.trackingDerivatpion &&
@@ -174,27 +178,37 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
             reportObserved(this)
             if (shouldCompute(this)) {
                 let prevTrackingContext = globalState.trackingContext
-                if (this.keepAlive_ && !prevTrackingContext) globalState.trackingContext = this
-                if (this.trackAndCompute()) propagateChangeConfirmed(this)
+                if (this.keepAlive_ && !prevTrackingContext) {
+                    globalState.trackingContext = this
+                }
+                if (this.trackAndCompute()) {
+                    propagateChangeConfirmed(this)
+                }
                 globalState.trackingContext = prevTrackingContext
             }
         }
         const result = this.value_!
 
-        if (isCaughtException(result)) throw result.cause
+        if (isCaughtException(result)) {
+            throw result.cause
+        }
         return result
     }
 
     public set(value: T) {
         if (this.setter_) {
-            if (this.isRunningSetter_) die(33, this.name_)
+            if (this.isRunningSetter_) {
+                die(33, this.name_)
+            }
             this.isRunningSetter_ = true
             try {
                 this.setter_.call(this.scope_, value)
             } finally {
                 this.isRunningSetter_ = false
             }
-        } else die(34, this.name_)
+        } else {
+            die(34, this.name_)
+        }
     }
 
     trackAndCompute(): boolean {
@@ -287,13 +301,19 @@ export class ComputedValue<T> implements IObservable, IComputedValue<T>, IDeriva
     }
 
     warnAboutUntrackedRead_() {
-        if (!__DEV__) return
+        if (!__DEV__) {
+            return
+        }
         if (this.isTracing_ !== TraceMode.NONE) {
             console.log(
                 `[mobx.trace] Computed value '${this.name_}' is being read outside a reactive context. Doing a full recompute.`
             )
         }
-        if (typeof this.requiresReaction_ === "boolean" ? this.requiresReaction_ : globalState.computedRequiresReaction) {
+        if (
+            typeof this.requiresReaction_ === "boolean"
+                ? this.requiresReaction_
+                : globalState.computedRequiresReaction
+        ) {
             console.warn(
                 `[mobx] Computed value '${this.name_}' is being read outside a reactive context. Doing a full recompute.`
             )

package/src/core/derivation.ts

@@ -137,7 +137,10 @@ export function checkIfStateModificationsAreAllowed(atom: IAtom) {
     }
     const hasObservers = atom.observers_.size > 0
     // Should not be possible to change observed state outside strict mode, except during initialization, see #563
-    if (!globalState.allowStateChanges && (hasObservers || globalState.enforceActions === "always"))
+    if (
+        !globalState.allowStateChanges &&
+        (hasObservers || globalState.enforceActions === "always")
+    ) {
         console.warn(
             "[MobX] " +
                 (globalState.enforceActions
@@ -145,6 +148,7 @@ export function checkIfStateModificationsAreAllowed(atom: IAtom) {
                     : "Side effects like changing state are not allowed at this point. Are you trying to modify state from, for example, a computed value or the render function of a React component? You can wrap side effects in 'runInAction' (or decorate functions with 'action') if needed. Tried to modify: ") +
                 atom.name_
         )
+    }
 }
 
 export function checkIfStateReadsAreAllowed(observable: IObservable) {
@@ -191,9 +195,13 @@ export function trackDerivedFunction<T>(derivation: IDerivation, f: () => T, con
 }
 
 function warnAboutDerivationWithoutDependencies(derivation: IDerivation) {
-    if (!__DEV__) return
+    if (!__DEV__) {
+        return
+    }
 
-    if (derivation.observing_.length !== 0) return
+    if (derivation.observing_.length !== 0) {
+        return
+    }
 
     if (globalState.reactionRequiresObservable || derivation.requiresObservable_) {
         console.warn(
@@ -222,14 +230,16 @@ function bindDependencies(derivation: IDerivation) {
         const dep = observing[i]
         if (dep.diffValue_ === 0) {
             dep.diffValue_ = 1
-            if (i0 !== i) observing[i0] = dep
+            if (i0 !== i) {
+                observing[i0] = dep
+            }
             i0++
         }
 
         // Upcast is 'safe' here, because if dep is IObservable, `dependenciesState` will be undefined,
         // not hitting the condition
-        if (((dep as any) as IDerivation).dependenciesState_ > lowestNewObservingDerivationState) {
-            lowestNewObservingDerivationState = ((dep as any) as IDerivation).dependenciesState_
+        if ((dep as any as IDerivation).dependenciesState_ > lowestNewObservingDerivationState) {
+            lowestNewObservingDerivationState = (dep as any as IDerivation).dependenciesState_
         }
     }
     observing.length = i0
@@ -272,7 +282,9 @@ export function clearObserving(derivation: IDerivation) {
     const obs = derivation.observing_
     derivation.observing_ = []
     let i = obs.length
-    while (i--) removeObserver(obs[i], derivation)
+    while (i--) {
+        removeObserver(obs[i], derivation)
+    }
 
     derivation.dependenciesState_ = IDerivationState_.NOT_TRACKING_
 }
@@ -311,10 +323,14 @@ export function allowStateReadsEnd(prev: boolean) {
  *
  */
 export function changeDependenciesStateTo0(derivation: IDerivation) {
-    if (derivation.dependenciesState_ === IDerivationState_.UP_TO_DATE_) return
+    if (derivation.dependenciesState_ === IDerivationState_.UP_TO_DATE_) {
+        return
+    }
     derivation.dependenciesState_ = IDerivationState_.UP_TO_DATE_
 
     const obs = derivation.observing_
     let i = obs.length
-    while (i--) obs[i].lowestObserverState_ = IDerivationState_.UP_TO_DATE_
+    while (i--) {
+        obs[i].lowestObserverState_ = IDerivationState_.UP_TO_DATE_
+    }
 }

package/src/core/globalstate.ts

@@ -157,9 +157,12 @@ let isolateCalled = false
 
 export let globalState: MobXGlobals = (function () {
     let global = getGlobal()
-    if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals) canMergeGlobalState = false
-    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version)
+    if (global.__mobxInstanceCount > 0 && !global.__mobxGlobals) {
         canMergeGlobalState = false
+    }
+    if (global.__mobxGlobals && global.__mobxGlobals.version !== new MobXGlobals().version) {
+        canMergeGlobalState = false
+    }
 
     if (!canMergeGlobalState) {
         // Because this is a IIFE we need to let isolateCalled a chance to change
@@ -172,7 +175,9 @@ export let globalState: MobXGlobals = (function () {
         return new MobXGlobals()
     } else if (global.__mobxGlobals) {
         global.__mobxInstanceCount += 1
-        if (!global.__mobxGlobals.UNCHANGED) global.__mobxGlobals.UNCHANGED = {} // make merge backward compatible
+        if (!global.__mobxGlobals.UNCHANGED) {
+            global.__mobxGlobals.UNCHANGED = {}
+        } // make merge backward compatible
         return global.__mobxGlobals
     } else {
         global.__mobxInstanceCount = 1
@@ -185,12 +190,15 @@ export function isolateGlobalState() {
         globalState.pendingReactions.length ||
         globalState.inBatch ||
         globalState.isRunningReactions
-    )
+    ) {
         die(36)
+    }
     isolateCalled = true
     if (canMergeGlobalState) {
         let global = getGlobal()
-        if (--global.__mobxInstanceCount === 0) global.__mobxGlobals = undefined
+        if (--global.__mobxInstanceCount === 0) {
+            global.__mobxGlobals = undefined
+        }
         globalState = new MobXGlobals()
     }
 }
@@ -205,7 +213,10 @@ export function getGlobalState(): any {
  */
 export function resetGlobalState() {
     const defaultGlobals = new MobXGlobals()
-    for (let key in defaultGlobals)
-        if (persistentKeys.indexOf(key as any) === -1) globalState[key] = defaultGlobals[key]
+    for (let key in defaultGlobals) {
+        if (persistentKeys.indexOf(key as any) === -1) {
+            globalState[key] = defaultGlobals[key]
+        }
+    }
     globalState.allowStateChanges = !globalState.enforceActions
 }

package/src/core/observable.ts

@@ -69,8 +69,9 @@ export function addObserver(observable: IObservable, node: IDerivation) {
     // invariantObservers(observable);
 
     observable.observers_.add(node)
-    if (observable.lowestObserverState_ > node.dependenciesState_)
+    if (observable.lowestObserverState_ > node.dependenciesState_) {
         observable.lowestObserverState_ = node.dependenciesState_
+    }
 
     // invariantObservers(observable);
     // invariant(observable._observers.indexOf(node) !== -1, "INTERNAL ERROR didn't add node");
@@ -183,7 +184,9 @@ export function reportObserved(observable: IObservable): boolean {
 // Called by Atom when its value changes
 export function propagateChanged(observable: IObservable) {
     // invariantLOS(observable, "changed start");
-    if (observable.lowestObserverState_ === IDerivationState_.STALE_) return
+    if (observable.lowestObserverState_ === IDerivationState_.STALE_) {
+        return
+    }
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
     // Ideally we use for..of here, but the downcompiled version is really slow...
@@ -202,7 +205,9 @@ export function propagateChanged(observable: IObservable) {
 // Called by ComputedValue when it recalculate and its value changed
 export function propagateChangeConfirmed(observable: IObservable) {
     // invariantLOS(observable, "confirmed start");
-    if (observable.lowestObserverState_ === IDerivationState_.STALE_) return
+    if (observable.lowestObserverState_ === IDerivationState_.STALE_) {
+        return
+    }
     observable.lowestObserverState_ = IDerivationState_.STALE_
 
     observable.observers_.forEach(d => {
@@ -223,7 +228,9 @@ export function propagateChangeConfirmed(observable: IObservable) {
 // Used by computed when its dependency changed, but we don't wan't to immediately recompute.
 export function propagateMaybeChanged(observable: IObservable) {
     // invariantLOS(observable, "maybe start");
-    if (observable.lowestObserverState_ !== IDerivationState_.UP_TO_DATE_) return
+    if (observable.lowestObserverState_ !== IDerivationState_.UP_TO_DATE_) {
+        return
+    }
     observable.lowestObserverState_ = IDerivationState_.POSSIBLY_STALE_
 
     observable.observers_.forEach(d => {
@@ -269,5 +276,7 @@ function printDepTree(tree: IDependencyTree, lines: string[], depth: number) {
         return
     }
     lines.push(`${"\t".repeat(depth - 1)}${tree.name}`)
-    if (tree.dependencies) tree.dependencies.forEach(child => printDepTree(child, lines, depth + 1))
+    if (tree.dependencies) {
+        tree.dependencies.forEach(child => printDepTree(child, lines, depth + 1))
+    }
 }

package/src/core/reaction.ts

@@ -142,7 +142,9 @@ export class Reaction implements IDerivation, IReactionPublic {
             // disposed during last run. Clean up everything that was bound after the dispose call.
             clearObserving(this)
         }
-        if (isCaughtException(result)) this.reportExceptionInDerivation_(result.cause)
+        if (isCaughtException(result)) {
+            this.reportExceptionInDerivation_(result.cause)
+        }
         if (__DEV__ && notify) {
             spyReportEnd({
                 time: Date.now() - startTime
@@ -157,7 +159,9 @@ export class Reaction implements IDerivation, IReactionPublic {
             return
         }
 
-        if (globalState.disableErrorBoundaries) throw error
+        if (globalState.disableErrorBoundaries) {
+            throw error
+        }
 
         const message = __DEV__
             ? `[mobx] Encountered an uncaught exception that was thrown by a reaction or observer component, in: '${this}'`
@@ -165,7 +169,7 @@ export class Reaction implements IDerivation, IReactionPublic {
         if (!globalState.suppressReactionErrors) {
             console.error(message, error)
             /** If debugging brought you here, please, read the above message :-). Tnx! */
-        } else if (__DEV__) console.warn(`[mobx] (error in reaction '${this.name_}' suppressed, fix error of causing action below)`) // prettier-ignore
+        } else if (__DEV__) {console.warn(`[mobx] (error in reaction '${this.name_}' suppressed, fix error of causing action below)`)} // prettier-ignore
 
         if (__DEV__ && isSpyEnabled()) {
             spyReport({
@@ -210,7 +214,9 @@ export function onReactionError(handler: (error: any, derivation: IDerivation) =
     globalState.globalReactionErrorHandlers.push(handler)
     return () => {
         const idx = globalState.globalReactionErrorHandlers.indexOf(handler)
-        if (idx >= 0) globalState.globalReactionErrorHandlers.splice(idx, 1)
+        if (idx >= 0) {
+            globalState.globalReactionErrorHandlers.splice(idx, 1)
+        }
     }
 }
 
@@ -225,7 +231,9 @@ let reactionScheduler: (fn: () => void) => void = f => f()
 
 export function runReactions() {
     // Trampolining, if runReactions are already running, new reactions will be picked up
-    if (globalState.inBatch > 0 || globalState.isRunningReactions) return
+    if (globalState.inBatch > 0 || globalState.isRunningReactions) {
+        return
+    }
     reactionScheduler(runReactionsHelper)
 }
 
@@ -248,8 +256,9 @@ function runReactionsHelper() {
             allReactions.splice(0) // clear reactions
         }
         let remainingReactions = allReactions.splice(0)
-        for (let i = 0, l = remainingReactions.length; i < l; i++)
+        for (let i = 0, l = remainingReactions.length; i < l; i++) {
             remainingReactions[i].runReaction_()
+        }
     }
     globalState.isRunningReactions = false
 }

package/src/core/spy.ts

@@ -25,14 +25,22 @@ export type PureSpyEvent =
 type SpyEvent = PureSpyEvent & { spyReportStart?: true }
 
 export function spyReport(event: SpyEvent) {
-    if (!__DEV__) return // dead code elimination can do the rest
-    if (!globalState.spyListeners.length) return
+    if (!__DEV__) {
+        return
+    } // dead code elimination can do the rest
+    if (!globalState.spyListeners.length) {
+        return
+    }
     const listeners = globalState.spyListeners
-    for (let i = 0, l = listeners.length; i < l; i++) listeners[i](event)
+    for (let i = 0, l = listeners.length; i < l; i++) {
+        listeners[i](event)
+    }
 }
 
 export function spyReportStart(event: PureSpyEvent) {
-    if (!__DEV__) return
+    if (!__DEV__) {
+        return
+    }
     const change = { ...event, spyReportStart: true as const }
     spyReport(change)
 }
@@ -40,9 +48,14 @@ export function spyReportStart(event: PureSpyEvent) {
 const END_EVENT: SpyEvent = { type: "report-end", spyReportEnd: true }
 
 export function spyReportEnd(change?: { time?: number }) {
-    if (!__DEV__) return
-    if (change) spyReport({ ...change, type: "report-end", spyReportEnd: true })
-    else spyReport(END_EVENT)
+    if (!__DEV__) {
+        return
+    }
+    if (change) {
+        spyReport({ ...change, type: "report-end", spyReportEnd: true })
+    } else {
+        spyReport(END_EVENT)
+    }
 }
 
 export function spy(listener: (change: SpyEvent) => void): Lambda {

package/src/errors.ts

@@ -22,9 +22,9 @@ const niceErrors = {
     10: "'has()' can only be used on observable objects, arrays and maps",
     11: "'get()' can only be used on observable objects, arrays and maps",
     12: `Invalid annotation`,
-    13: `Dynamic observable objects cannot be frozen`,
+    13: `Dynamic observable objects cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)`,
     14: "Intercept handlers should return nothing or a change object",
-    15: `Observable arrays cannot be frozen`,
+    15: `Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)`,
     16: `Modification exception: the internal structure of an observable array was changed.`,
     17(index, length) {
         return `[mobx.array] Index out of bounds, ${index} is larger than ${length}`

package/src/types/actionannotation.ts

@@ -67,7 +67,7 @@ function assertActionDescriptor(
     if (__DEV__ && !isFunction(value)) {
         die(
             `Cannot apply '${annotationType_}' to '${adm.name_}.${key.toString()}':` +
-            `\n'${annotationType_}' can only be used on properties with a function value.`
+                `\n'${annotationType_}' can only be used on properties with a function value.`
         )
     }
 }
@@ -91,7 +91,7 @@ export function createActionDescriptor(
             value,
             annotation.options_?.autoAction ?? false,
             // https://github.com/mobxjs/mobx/discussions/3140
-            annotation.options_?.bound ? (adm.proxy_ ?? adm.target_) : undefined,
+            annotation.options_?.bound ? adm.proxy_ ?? adm.target_ : undefined
         ),
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass

package/src/types/dynamicobject.ts

@@ -19,17 +19,20 @@ function getAdm(target): ObservableObjectAdministration {
 // and skip either the internal values map, or the base object with its property descriptors!
 const objectProxyTraps: ProxyHandler<any> = {
     has(target: IIsObservableObject, name: PropertyKey): boolean {
-        if (__DEV__ && globalState.trackingDerivation)
+        if (__DEV__ && globalState.trackingDerivation) {
             warnAboutProxyRequirement(
                 "detect new properties using the 'in' operator. Use 'has' from 'mobx' instead."
             )
+        }
         return getAdm(target).has_(name)
     },
     get(target: IIsObservableObject, name: PropertyKey): any {
         return getAdm(target).get_(name)
     },
     set(target: IIsObservableObject, name: PropertyKey, value: any): boolean {
-        if (!isStringish(name)) return false
+        if (!isStringish(name)) {
+            return false
+        }
         if (__DEV__ && !getAdm(target).values_.has(name)) {
             warnAboutProxyRequirement(
                 "add a new observable property through direct assignment. Use 'set' from 'mobx' instead."
@@ -44,7 +47,9 @@ const objectProxyTraps: ProxyHandler<any> = {
                 "delete properties from an observable object. Use 'remove' from 'mobx' instead."
             )
         }
-        if (!isStringish(name)) return false
+        if (!isStringish(name)) {
+            return false
+        }
         // null (intercepted) -> true (success)
         return getAdm(target).delete_(name, true) ?? true
     },
@@ -62,10 +67,11 @@ const objectProxyTraps: ProxyHandler<any> = {
         return getAdm(target).defineProperty_(name, descriptor) ?? true
     },
     ownKeys(target: IIsObservableObject): ArrayLike<string | symbol> {
-        if (__DEV__ && globalState.trackingDerivation)
+        if (__DEV__ && globalState.trackingDerivation) {
             warnAboutProxyRequirement(
                 "iterate keys to detect added / removed properties. Use 'keys' from 'mobx' instead."
             )
+        }
         return getAdm(target).ownKeys_()
     },
     preventExtensions(target) {

package/src/types/flowannotation.ts

@@ -7,7 +7,8 @@ import {
     isFlow,
     isFunction,
     globalState,
-    MakeResult
+    MakeResult,
+    hasProp
 } from "../internal"
 
 export function createFlowAnnotation(name: string, options?: object): Annotation {
@@ -33,8 +34,10 @@ function make_(
     }
     // prototype
     // bound - must annotate protos to support super.flow()
-    if (this.options_?.bound && !isFlow(adm.target_[key])) {
-        if (this.extend_(adm, key, descriptor, false) === null) return MakeResult.Cancel
+    if (this.options_?.bound && (!hasProp(adm.target_, key) || !isFlow(adm.target_[key]))) {
+        if (this.extend_(adm, key, descriptor, false) === null) {
+            return MakeResult.Cancel
+        }
     }
     if (isFlow(descriptor.value)) {
         // A prototype could have been annotated already by other constructor,
@@ -81,11 +84,18 @@ function createFlowDescriptor(
 ): PropertyDescriptor {
     assertFlowDescriptor(adm, annotation, key, descriptor)
     let { value } = descriptor
+    // In case of flow.bound, the descriptor can be from already annotated prototype
+    if (!isFlow(value)) {
+        value = flow(value)
+    }
     if (bound) {
+        // We do not keep original function around, so we bind the existing flow
         value = value.bind(adm.proxy_ ?? adm.target_)
+        // This is normally set by `flow`, but `bind` returns new function...
+        value.isMobXFlow = true
     }
     return {
-        value: flow(value),
+        value,
         // Non-configurable for classes
         // prevents accidental field redefinition in subclass
         configurable: safeDescriptors ? adm.isPlainObject_ : true,

package/src/types/intercept-utils.ts

@@ -18,7 +18,9 @@ export function registerInterceptor<T>(
     interceptors.push(handler)
     return once(() => {
         const idx = interceptors.indexOf(handler)
-        if (idx !== -1) interceptors.splice(idx, 1)
+        if (idx !== -1) {
+            interceptors.splice(idx, 1)
+        }
     })
 }
 
@@ -32,8 +34,12 @@ export function interceptChange<T>(
         const interceptors = [...(interceptable.interceptors_ || [])]
         for (let i = 0, l = interceptors.length; i < l; i++) {
             change = interceptors[i](change)
-            if (change && !(change as any).type) die(14)
-            if (!change) break
+            if (change && !(change as any).type) {
+                die(14)
+            }
+            if (!change) {
+                break
+            }
         }
         return change
     } finally {

package/src/types/legacyobservablearray.ts

@@ -85,7 +85,6 @@ class LegacyObservableArray<T> extends StubArray {
         let nextIndex = 0
         return makeIterable({
             next() {
-                // @ts-ignore
                 return nextIndex < self.length
                     ? { value: self[nextIndex++], done: false }
                     : { done: true, value: undefined }
@@ -95,7 +94,9 @@ class LegacyObservableArray<T> extends StubArray {
 }
 
 Object.entries(arrayExtensions).forEach(([prop, fn]) => {
-    if (prop !== "concat") addHiddenProp(LegacyObservableArray.prototype, prop, fn)
+    if (prop !== "concat") {
+        addHiddenProp(LegacyObservableArray.prototype, prop, fn)
+    }
 })
 
 function createArrayEntryDescriptor(index: number) {
@@ -117,8 +118,9 @@ function createArrayBufferItem(index: number) {
 
 export function reserveArrayBuffer(max: number) {
     if (max > OBSERVABLE_ARRAY_BUFFER_SIZE) {
-        for (let index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max + 100; index++)
+        for (let index = OBSERVABLE_ARRAY_BUFFER_SIZE; index < max + 100; index++) {
             createArrayBufferItem(index)
+        }
         OBSERVABLE_ARRAY_BUFFER_SIZE = max
     }
 }

package/src/types/listen-utils.ts

@@ -13,14 +13,18 @@ export function registerListener(listenable: IListenable, handler: Function): La
     listeners.push(handler)
     return once(() => {
         const idx = listeners.indexOf(handler)
-        if (idx !== -1) listeners.splice(idx, 1)
+        if (idx !== -1) {
+            listeners.splice(idx, 1)
+        }
     })
 }
 
 export function notifyListeners<T>(listenable: IListenable, change: T) {
     const prevU = untrackedStart()
     let listeners = listenable.changeListeners_
-    if (!listeners) return
+    if (!listeners) {
+        return
+    }
     listeners = listeners.slice()
     for (let i = 0, l = listeners.length; i < l; i++) {
         listeners[i](change)