mobx 6.13.2 → 6.13.4

package/dist/types/legacyobservablearray.d.ts

@@ -7,7 +7,7 @@ export declare class LegacyObservableArray<T> extends StubArray {
     get length(): number;
     set length(newLength: number);
     get [Symbol.toStringTag](): string;
-    [Symbol.iterator](): IterableIterator<any>;
+    [Symbol.iterator](): IteratorObject<any, unknown, unknown>;
 }
 export declare function reserveArrayBuffer(max: number): void;
 export declare function createLegacyArray<T>(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string): IObservableArray<T>;

package/dist/types/observablemap.d.ts

@@ -54,10 +54,10 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     private addValue_;
     get(key: K): V | undefined;
     private dehanceValue_;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    entries(): IterableIterator<IMapEntry<K, V>>;
-    [Symbol.iterator](): IterableIterator<IMapEntry<K, V>>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
+    entries(): MapIterator<IMapEntry<K, V>>;
+    [Symbol.iterator](): MapIterator<IMapEntry<K, V>>;
     forEach(callback: (value: V, key: K, object: Map<K, V>) => void, thisArg?: any): void;
     /** Merge another object into this object, returns this. */
     merge(other?: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;

package/dist/types/observableobject.d.ts

@@ -37,7 +37,7 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     isPlainObject_: boolean;
     appliedAnnotations_?: object;
     private pendingKeys_;
-    constructor(target_: any, values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation);
+    constructor(target_: any, values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>> | undefined, name_: string, defaultAnnotation_?: Annotation);
     getObservablePropValue_(key: PropertyKey): any;
     setObservablePropValue_(key: PropertyKey, newValue: any): boolean | null;
     get_(key: PropertyKey): any;

package/dist/types/observableset.d.ts

@@ -39,9 +39,9 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     add(value: T): this;
     delete(value: T): boolean;
     has(value: T): boolean;
-    entries(): IterableIterator<[T, T]>;
-    keys(): IterableIterator<T>;
-    values(): IterableIterator<T>;
+    entries(): SetIterator<[T, T]>;
+    keys(): SetIterator<T>;
+    values(): SetIterator<T>;
     intersection<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T & U>;
     union<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T | U>;
     difference<U>(otherSet: ReadonlySetLike<U>): Set<T>;
@@ -54,7 +54,7 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     intercept_(handler: IInterceptor<ISetWillChange<T>>): Lambda;
     toJSON(): T[];
     toString(): string;
-    [Symbol.iterator](): IterableIterator<T>;
+    [Symbol.iterator](): SetIterator<T>;
     get [Symbol.toStringTag](): string;
 }
 export declare var isObservableSet: (thing: any) => thing is ObservableSet<any>;

package/dist/utils/iterable.d.ts

@@ -1 +1 @@
-export declare function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
+export declare function makeIterable<T, TReturn = unknown>(iterator: Iterator<T>): IteratorObject<T, TReturn>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.13.2",
+    "version": "6.13.4",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/types/actionannotation.ts

@@ -8,8 +8,7 @@ import {
     Annotation,
     globalState,
     MakeResult,
-    assert20223DecoratorType,
-    storeAnnotation
+    assert20223DecoratorType
 } from "../internal"
 
 export function createActionAnnotation(name: string, options?: object): Annotation {
@@ -73,12 +72,18 @@ function decorate_20223_(this: Annotation, mthd, context: DecoratorContext) {
     const _createAction = m =>
         createAction(ann.options_?.name ?? name!.toString(), m, ann.options_?.autoAction ?? false)
 
-    // Backwards/Legacy behavior, expects makeObservable(this)
     if (kind == "field") {
-        addInitializer(function () {
-            storeAnnotation(this, name, ann)
-        })
-        return
+        return function (initMthd) {
+            let mthd = initMthd
+            if (!isAction(mthd)) {
+                mthd = _createAction(mthd)
+            }
+            if (ann.options_?.bound) {
+                mthd = mthd.bind(this)
+                mthd.isMobxAction = true
+            }
+            return mthd
+        }
     }
 
     if (kind == "method") {

package/src/types/observablemap.ts

@@ -9,6 +9,7 @@ import {
     checkIfStateModificationsAreAllowed,
     createAtom,
     createInstanceofPredicate,
+    makeIterable,
     deepEnhancer,
     getNextId,
     getPlainObjectKeys,
@@ -19,7 +20,6 @@ import {
     isPlainES6Map,
     isPlainObject,
     isSpyEnabled,
-    makeIterable,
     notifyListeners,
     referenceEnhancer,
     registerInterceptor,
@@ -296,15 +296,15 @@ export class ObservableMap<K = any, V = any>
         return value
     }
 
-    keys(): IterableIterator<K> {
+    keys(): MapIterator<K> {
         this.keysAtom_.reportObserved()
         return this.data_.keys()
     }
 
-    values(): IterableIterator<V> {
+    values(): MapIterator<V> {
         const self = this
         const keys = this.keys()
-        return makeIterable({
+        return makeIterableForMap({
             next() {
                 const { done, value } = keys.next()
                 return {
@@ -315,10 +315,10 @@ export class ObservableMap<K = any, V = any>
         })
     }
 
-    entries(): IterableIterator<IMapEntry<K, V>> {
+    entries(): MapIterator<IMapEntry<K, V>> {
         const self = this
         const keys = this.keys()
-        return makeIterable({
+        return makeIterableForMap({
             next() {
                 const { done, value } = keys.next()
                 return {
@@ -490,6 +490,11 @@ export var isObservableMap = createInstanceofPredicate("ObservableMap", Observab
     thing: any
 ) => thing is ObservableMap<any, any>
 
+function makeIterableForMap<T>(iterator: Iterator<T>): MapIterator<T> {
+    iterator[Symbol.toStringTag] = "MapIterator"
+    return makeIterable<T, BuiltinIteratorReturn>(iterator)
+}
+
 function convertToMap(dataStructure: any): Map<any, any> {
     if (isES6Map(dataStructure) || isObservableMap(dataStructure)) {
         return dataStructure

package/src/types/observableset.ts

@@ -13,6 +13,7 @@ import {
     notifyListeners,
     spyReportEnd,
     createInstanceofPredicate,
+    makeIterable,
     hasInterceptors,
     interceptChange,
     IInterceptable,
@@ -20,7 +21,6 @@ import {
     registerInterceptor,
     checkIfStateModificationsAreAllowed,
     untracked,
-    makeIterable,
     transaction,
     isES6Set,
     IAtom,
@@ -214,33 +214,33 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
         let nextIndex = 0
         const keys = Array.from(this.keys())
         const values = Array.from(this.values())
-        return makeIterable<[T, T]>({
+        return makeIterableForSet<[T, T]>({
             next() {
                 const index = nextIndex
                 nextIndex += 1
                 return index < values.length
                     ? { value: [keys[index], values[index]], done: false }
-                    : { done: true }
+                    : { value: undefined, done: true }
             }
-        } as any)
+        })
     }
 
-    keys(): IterableIterator<T> {
+    keys(): SetIterator<T> {
         return this.values()
     }
 
-    values(): IterableIterator<T> {
+    values(): SetIterator<T> {
         this.atom_.reportObserved()
         const self = this
         let nextIndex = 0
         const observableValues = Array.from(this.data_.values())
-        return makeIterable<T>({
+        return makeIterableForSet({
             next() {
                 return nextIndex < observableValues.length
                     ? { value: self.dehanceValue_(observableValues[nextIndex++]), done: false }
-                    : { done: true }
+                    : { value: undefined, done: true }
             }
-        } as any)
+        })
     }
 
     intersection<U>(otherSet: ReadonlySetLike<U> | Set<U>): Set<T & U> {
@@ -343,3 +343,8 @@ export class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillCh
 export var isObservableSet = createInstanceofPredicate("ObservableSet", ObservableSet) as (
     thing: any
 ) => thing is ObservableSet<any>
+
+function makeIterableForSet<T>(iterator: Iterator<T>): SetIterator<T> {
+    iterator[Symbol.toStringTag] = "SetIterator"
+    return makeIterable<T, BuiltinIteratorReturn>(iterator)
+}

package/src/utils/iterable.ts

@@ -1,8 +1,5 @@
-export function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T> {
-    iterator[Symbol.iterator] = getSelf
-    return iterator as any
-}
-
-function getSelf() {
-    return this
+export function makeIterable<T, TReturn = unknown>(
+    iterator: Iterator<T>
+): IteratorObject<T, TReturn> {
+    return Object.assign(Object.create(Iterator.prototype), iterator)
 }