mobx 6.16.1 → 7.0.1

package/dist/types/actionannotation.d.ts

@@ -1,5 +1,6 @@
 import { ObservableObjectAdministration, Annotation } from "../internal";
 export declare function createActionAnnotation(name: string, options?: object): Annotation;
+export declare function decorateAction20223_(annotation: Annotation, mthd: any, context: DecoratorContext): any;
 export declare function createActionDescriptor(adm: ObservableObjectAdministration, annotation: Annotation, key: PropertyKey, descriptor: PropertyDescriptor, safeDescriptors?: boolean): {
     value: Function;
     configurable: boolean;

package/dist/types/computedannotation.d.ts

@@ -1,2 +1,3 @@
 import { Annotation } from "../internal";
 export declare function createComputedAnnotation(name: string, options?: object): Annotation;
+export declare function decorateComputed20223_(annotation: Annotation, get: any, context: ClassGetterDecoratorContext): () => any;

package/dist/types/decorator_fills.d.ts

@@ -3,4 +3,6 @@ export type ClassGetterDecorator<This = any, Value = any> = (value: (this: This)
 export type ClassSetterDecorator<This = any, Value = any> = (value: (this: This, value: Value) => void, context: ClassSetterDecoratorContext) => ((this: This, value: Value) => void) | void;
 export type ClassMethodDecorator<This = any, Value extends (...p: any[]) => any = any> = (value: Value, context: ClassMethodDecoratorContext<This, Value>) => Value | void;
 export type ClassFieldDecorator<This = any, Value extends (...p: any[]) => any = any> = (value: Value, context: ClassFieldDecoratorContext<This, Value>) => Value | void;
+export type ClassMethodAndFieldDecorator = ClassMethodDecorator & ClassFieldDecorator;
+export type ClassAccessorAndFieldDecorator = ClassAccessorDecorator & ClassFieldDecorator;
 export type Decorator = ClassAccessorDecorator | ClassGetterDecorator | ClassSetterDecorator | ClassMethodDecorator | ClassFieldDecorator;

package/dist/types/flowannotation.d.ts

@@ -1,2 +1,3 @@
 import { Annotation } from "../internal";
 export declare function createFlowAnnotation(name: string, options?: object): Annotation;
+export declare function decorateFlow20223_(annotation: Annotation, mthd: any, context: ClassMethodDecoratorContext): any;

package/dist/types/observableannotation.d.ts

@@ -1,2 +1,7 @@
 import { Annotation } from "../internal";
 export declare function createObservableAnnotation(name: string, options?: object): Annotation;
+export declare function decorateObservable20223_(annotation: Annotation, desc: any, context: ClassAccessorDecoratorContext | ClassFieldDecoratorContext): {
+    get(): any;
+    set(value: any): boolean | null;
+    init(value: any): any;
+} | undefined;

package/dist/types/observablearray.d.ts

@@ -1,4 +1,4 @@
-import { IAtom, IEnhancer, IInterceptable, IInterceptor, IListenable, Lambda } from "../internal";
+import { IAtom, IEnhancer, IInterceptable, IListenable } from "../internal";
 export declare const UPDATE = "update";
 export declare const MAX_SPLICE_SIZE = 10000;
 export interface IObservableArray<T = any> extends Array<T> {
@@ -42,7 +42,6 @@ export interface IArrayWillSplice<T = any> {
 }
 export declare class ObservableArrayAdministration implements IInterceptable<IArrayWillChange<any> | IArrayWillSplice<any>>, IListenable {
     owned_: boolean;
-    legacyMode_: boolean;
     atom_: IAtom;
     readonly values_: any[];
     interceptors_: any;
@@ -51,11 +50,9 @@ export declare class ObservableArrayAdministration implements IInterceptable<IAr
     dehancer: any;
     proxy_: IObservableArray<any>;
     lastKnownLength_: number;
-    constructor(name: string | undefined, enhancer: IEnhancer<any>, owned_: boolean, legacyMode_: boolean);
+    constructor(name: string | undefined, enhancer: IEnhancer<any>, owned_: boolean);
     dehanceValue_(value: any): any;
     dehanceValues_(values: any[]): any[];
-    intercept_(handler: IInterceptor<IArrayWillChange<any> | IArrayWillSplice<any>>): Lambda;
-    observe_(listener: (changeData: IArrayDidChange<any>) => void, fireImmediately?: boolean): Lambda;
     getArrayLength_(): number;
     setArrayLength_(newLength: number): void;
     updateArrayLength_(oldLength: number, delta: number): void;

package/dist/types/observablemap.d.ts

@@ -1,4 +1,4 @@
-import { $mobx, IEnhancer, IInterceptable, IInterceptor, IListenable, Lambda, ObservableValue, IAtom } from "../internal";
+import { $mobx, IEnhancer, IInterceptable, IListenable, ObservableValue, IAtom } from "../internal";
 export interface IKeyValueMap<V = any> {
     [key: string]: V;
 }
@@ -69,12 +69,5 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     toString(): string;
     toJSON(): [K, V][];
     get [Symbol.toStringTag](): string;
-    /**
-     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
-     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
-     * for callback details
-     */
-    observe_(listener: (changes: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
-    intercept_(handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
 }
 export declare var isObservableMap: (thing: any) => thing is ObservableMap<any, any>;

package/dist/types/observableobject.d.ts

@@ -1,4 +1,4 @@
-import { CreateObservableOptions, $mobx, Annotation, ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
+import { CreateObservableOptions, $mobx, Annotation, ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, ObservableValue } from "../internal";
 export type IObjectDidChange<T = any> = {
     observableKind: "object";
     name: PropertyKey;
@@ -54,11 +54,6 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
      */
     set_(key: PropertyKey, value: any, proxyTrap?: boolean): boolean | null;
     has_(key: PropertyKey): boolean;
-    /**
-     * @param {PropertyKey} key
-     * @param {Annotation|boolean} annotation true - use default annotation, false - ignore prop
-     */
-    make_(key: PropertyKey, annotation: Annotation | boolean): void;
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
@@ -83,13 +78,6 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
     delete_(key: PropertyKey, proxyTrap?: boolean): boolean | null;
-    /**
-     * Observes this object. Triggers for the events 'add', 'update' and 'delete'.
-     * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe
-     * for callback details
-     */
-    observe_(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
-    intercept_(handler: any): Lambda;
     notifyPropertyAddition_(key: PropertyKey, value: any): void;
     ownKeys_(): Array<string | symbol>;
     keys_(): PropertyKey[];
@@ -100,3 +88,4 @@ export interface IIsObservableObject {
 export declare function asObservableObject(target: any, options?: CreateObservableOptions): IIsObservableObject;
 export declare function isObservableObject(thing: any): boolean;
 export declare function recordAnnotationApplied(adm: ObservableObjectAdministration, annotation: Annotation, key: PropertyKey): void;
+export declare function assertAnnotable(adm: ObservableObjectAdministration, annotation: Annotation, key: PropertyKey): void;

package/dist/types/observableset.d.ts

@@ -1,4 +1,4 @@
-import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor, IAtom } from "../internal";
+import { $mobx, IEnhancer, IListenable, IInterceptable, IAtom } from "../internal";
 export type IObservableSetInitialValues<T> = Set<T> | readonly T[];
 export type ISetDidChange<T = any> = {
     object: ObservableSet<T>;
@@ -52,8 +52,6 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     isSupersetOf(otherSet: ReadonlySetLike<unknown>): boolean;
     isDisjointFrom(otherSet: ReadonlySetLike<unknown> | Set<unknown>): boolean;
     replace(other: ObservableSet<T> | IObservableSetInitialValues<T>): ObservableSet<T>;
-    observe_(listener: (changes: ISetDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-    intercept_(handler: IInterceptor<ISetWillChange<T>>): Lambda;
     toJSON(): T[];
     toString(): string;
     [Symbol.iterator](): SetIterator<T>;

package/dist/types/observablevalue.d.ts

@@ -1,4 +1,4 @@
-import { Atom, IEnhancer, IInterceptable, IEqualsComparer, IInterceptor, IListenable, Lambda } from "../internal";
+import { Atom, IEnhancer, IInterceptable, IEqualsComparer, IListenable } from "../internal";
 export interface IValueWillChange<T> {
     object: IObservableValue<T>;
     type: "update";
@@ -24,22 +24,20 @@ export interface IObservableValue<T> {
     set(value: T): void;
 }
 export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
-    enhancer: IEnhancer<T>;
+    enhancer_: IEnhancer<T>;
     name_: string;
-    private equals;
+    private equals_;
     hasUnreportedChange_: boolean;
     interceptors_: any;
     changeListeners_: any;
     value_: any;
     dehancer: any;
-    constructor(value: T, enhancer: IEnhancer<T>, name_?: string, notifySpy?: boolean, equals?: IEqualsComparer<any>);
+    constructor(value: T, enhancer_: IEnhancer<T>, name_?: string, notifySpy?: boolean, equals_?: IEqualsComparer<any>);
     private dehanceValue;
     set(newValue: T): void;
     private prepareNewValue_;
     setNewValue_(newValue: T): void;
     get(): T;
-    intercept_(handler: IInterceptor<IValueWillChange<T>>): Lambda;
-    observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
     raw(): any;
     toJSON(): T;
     toString(): string;

package/dist/types/overrideannotation.d.ts

@@ -1,4 +1,3 @@
 import { Annotation } from "../internal";
-import type { ClassMethodDecorator } from "./decorator_fills";
-export declare const override: Annotation & PropertyDecorator & ClassMethodDecorator;
+export declare const override: Annotation;
 export declare function isOverride(annotation: Annotation): boolean;

package/dist/utils/comparer.d.ts

@@ -1,14 +1,7 @@
 export interface IEqualsComparer<T> {
     (a: T, b: T): boolean;
 }
-declare function identityComparer(a: any, b: any): boolean;
-declare function structuralComparer(a: any, b: any): boolean;
-declare function shallowComparer(a: any, b: any): boolean;
-declare function defaultComparer(a: any, b: any): boolean;
-export declare const comparer: {
-    identity: typeof identityComparer;
-    structural: typeof structuralComparer;
-    default: typeof defaultComparer;
-    shallow: typeof shallowComparer;
-};
-export {};
+export declare function compareIdentity(a: any, b: any): boolean;
+export declare function compareStructural(a: any, b: any): boolean;
+export declare function compareShallow(a: any, b: any): boolean;
+export declare const compareDefault: (value1: any, value2: any) => boolean;

package/dist/utils/utils.d.ts

@@ -13,8 +13,6 @@ export interface Lambda {
     (): void;
     name?: string;
 }
-export declare function assertProxies(): void;
-export declare function warnAboutProxyRequirement(msg: string): void;
 export declare function getNextId(): number;
 /**
  * Makes sure that the provided function is invoked at most once.

package/package.json

@@ -1,8 +1,9 @@
 {
     "name": "mobx",
-    "version": "6.16.1",
+    "version": "7.0.1",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
+    "type": "commonjs",
     "main": "dist/index.js",
     "umd:main": "dist/mobx.umd.production.min.js",
     "unpkg": "dist/mobx.umd.production.min.js",
@@ -12,6 +13,25 @@
     "react-native": "dist/mobx.esm.js",
     "types": "dist/mobx.d.ts",
     "typings": "dist/mobx.d.ts",
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "react-native": {
+                "types": "./dist/mobx.d.ts",
+                "default": "./dist/mobx.esm.js"
+            },
+            "import": {
+                "types": "./dist/mobx.d.ts",
+                "default": "./dist/mobx.mjs"
+            },
+            "default": {
+                "types": "./dist/mobx.d.ts",
+                "default": "./dist/index.js"
+            }
+        },
+        "./dist/*": "./dist/*",
+        "./src/*": "./src/*"
+    },
     "files": [
         "src",
         "dist",
@@ -36,13 +56,6 @@
     "homepage": "https://mobx.js.org/",
     "dependencies": {},
     "devDependencies": {
-        "@babel/core": "^7.9.0",
-        "@babel/plugin-proposal-class-properties": "^7.8.3",
-        "@babel/plugin-proposal-decorators": "^7.8.3",
-        "@babel/plugin-transform-runtime": "^7.9.0",
-        "@babel/preset-env": "^7.9.5",
-        "@babel/preset-typescript": "^7.9.0",
-        "@babel/runtime": "^7.9.2",
         "conditional-type-checks": "^1.0.5"
     },
     "keywords": [
@@ -62,18 +75,15 @@
     "scripts": {
         "test": "jest --config jest.projects.js",
         "lint": "eslint src/**/*",
-        "build": "node ../../scripts/build.js mobx",
-        "build:test": "npm run build -- --target test",
+        "build": "rollup --config rollup.config.mjs",
+        "build:test": "npm run build -- --environment TARGET:test",
         "perf": "scripts/perf.sh",
-        "perf-legacy": "node --expose-gc ./__tests__/perf/index.js legacy",
-        "perf-proxy": "node --expose-gc ./__tests__/perf/index.js proxy",
         "perf-decorator": "tsc -p ./__tests__/perf/tsconfig.decorator.json && node --expose-gc ./__tests__/perf/compiled/lazy-computed-decorator.js && node --expose-gc ./__tests__/perf/compiled/lazy-observable-decorator.js",
-        "test:performance": "npm run perf -- proxy && npm run perf -- legacy && npm run perf-decorator",
+        "test:performance": "npm run perf && npm run perf-decorator",
         "test:mixed-versions": "npm test -- --testRegex mixed-versions",
         "test:types": "tsc --noEmit",
         "test:coverage": "npm test -- -i --coverage",
-        "test:size": "import-size --report . observable computed autorun action",
         "test:check": "npm run test:types",
-        "prepublishOnly": "node ./scripts/prepublish.js && npm run build -- --target publish"
+        "prepublishOnly": "node ./scripts/prepublish.js && npm run build -- --environment TARGET:publish"
     }
 }

package/src/api/action.ts

@@ -2,16 +2,15 @@ import {
     createAction,
     executeAction,
     Annotation,
-    storeAnnotation,
     die,
     isFunction,
     isStringish,
-    createDecoratorAnnotation,
     createActionAnnotation,
-    is20223Decorator
+    decorateAction20223_,
+    assign
 } from "../internal"
-
-import type { ClassFieldDecorator, ClassMethodDecorator } from "../types/decorator_fills"
+import { createDecoratorAnnotation, type DecoratorAnnotation } from "./decoratorannotation"
+import type { ClassMethodAndFieldDecorator } from "../types/decorator_fills"
 
 export const ACTION = "action"
 export const ACTION_BOUND = "action.bound"
@@ -32,28 +31,32 @@ const autoActionBoundAnnotation = createActionAnnotation(AUTOACTION_BOUND, {
     bound: true
 })
 
-export interface IActionFactory
-    extends Annotation,
-        PropertyDecorator,
-        ClassMethodDecorator,
-        ClassFieldDecorator {
+function createActionDecoratorAnnotation(
+    annotation: Annotation
+): DecoratorAnnotation<ClassMethodAndFieldDecorator> {
+    return createDecoratorAnnotation(annotation, decorateAction20223_)
+}
+
+export interface IActionFactory extends Annotation, ClassMethodAndFieldDecorator {
     // nameless actions
     <T extends Function | undefined | null>(fn: T): T
     // named actions
     <T extends Function | undefined | null>(name: string, fn: T): T
 
-    // named decorator
-    (customName: string): PropertyDecorator &
-        Annotation &
-        ClassMethodDecorator &
-        ClassFieldDecorator
-
-    // decorator (name no longer supported)
-    bound: Annotation & PropertyDecorator & ClassMethodDecorator & ClassFieldDecorator
+    // named annotation
+    (customName: string): DecoratorAnnotation<ClassMethodAndFieldDecorator>
 }
 
 function createActionFactory(autoAction: boolean): IActionFactory {
     const res: IActionFactory = function action(arg1, arg2?): any {
+        if (arg2 && typeof arg2.kind === "string") {
+            return decorateAction20223_(
+                autoAction ? autoActionAnnotation : actionAnnotation,
+                arg1,
+                arg2
+            )
+        }
+
         // action(fn() {})
         if (isFunction(arg1)) {
             return createAction(arg1.name || DEFAULT_ACTION_NAME, arg1, autoAction)
@@ -62,20 +65,9 @@ function createActionFactory(autoAction: boolean): IActionFactory {
         if (isFunction(arg2)) {
             return createAction(arg1, arg2, autoAction)
         }
-        // @action (2022.3 Decorators)
-        if (is20223Decorator(arg2)) {
-            return (autoAction ? autoActionAnnotation : actionAnnotation).decorate_20223_(
-                arg1,
-                arg2
-            )
-        }
-        // @action
-        if (isStringish(arg2)) {
-            return storeAnnotation(arg1, arg2, autoAction ? autoActionAnnotation : actionAnnotation)
-        }
-        // action("name") & @action("name")
+        // action("name") annotation
         if (isStringish(arg1)) {
-            return createDecoratorAnnotation(
+            return createActionDecoratorAnnotation(
                 createActionAnnotation(autoAction ? AUTOACTION : ACTION, {
                     name: arg1,
                     autoAction
@@ -91,12 +83,12 @@ function createActionFactory(autoAction: boolean): IActionFactory {
 }
 
 export const action: IActionFactory = createActionFactory(false)
-Object.assign(action, actionAnnotation)
+assign(action, actionAnnotation)
 export const autoAction: IActionFactory = createActionFactory(true)
-Object.assign(autoAction, autoActionAnnotation)
+assign(autoAction, autoActionAnnotation)
 
-action.bound = createDecoratorAnnotation(actionBoundAnnotation)
-autoAction.bound = createDecoratorAnnotation(autoActionBoundAnnotation)
+export const actionBound = createActionDecoratorAnnotation(actionBoundAnnotation)
+export const autoActionBound = createActionDecoratorAnnotation(autoActionBoundAnnotation)
 
 export function runInAction<T>(fn: () => T): T {
     return executeAction(fn.name || DEFAULT_ACTION_NAME, false, fn, this, undefined)

package/src/api/annotation.ts

@@ -20,7 +20,6 @@ export type Annotation = {
         descriptor: PropertyDescriptor,
         proxyTrap: boolean
     ): boolean | null
-    decorate_20223_(value: any, context: DecoratorContext)
     options_?: any
 }
 

package/src/api/autorun.ts

@@ -6,7 +6,7 @@ import {
     Lambda,
     Reaction,
     action,
-    comparer,
+    compareDefault,
     getNextId,
     isAction,
     isFunction,
@@ -140,9 +140,7 @@ export function reaction<T, FireImmediately extends boolean = false>(
     let isScheduled = false
     let value: T
 
-    const equals: IEqualsComparer<T> = (opts as any).compareStructural
-        ? comparer.structural
-        : opts.equals || comparer.default
+    const equals: IEqualsComparer<T> = opts.equals || compareDefault
 
     const r = new Reaction(
         name,

package/src/api/computed.ts

@@ -2,53 +2,48 @@ import {
     ComputedValue,
     IComputedValueOptions,
     Annotation,
-    storeAnnotation,
-    createDecoratorAnnotation,
-    isStringish,
     isPlainObject,
     isFunction,
     die,
     IComputedValue,
     createComputedAnnotation,
-    comparer,
-    is20223Decorator
+    compareStructural,
+    decorateComputed20223_,
+    assign
 } from "../internal"
-
+import { createDecoratorAnnotation, type DecoratorAnnotation } from "./decoratorannotation"
 import type { ClassGetterDecorator } from "../types/decorator_fills"
 
 export const COMPUTED = "computed"
 export const COMPUTED_STRUCT = "computed.struct"
 
-export interface IComputedFactory extends Annotation, PropertyDecorator, ClassGetterDecorator {
-    // @computed(opts)
-    <T>(options: IComputedValueOptions<T>): Annotation & PropertyDecorator & ClassGetterDecorator
+function createComputedDecoratorAnnotation(
+    annotation: Annotation
+): DecoratorAnnotation<ClassGetterDecorator> {
+    return createDecoratorAnnotation(annotation, decorateComputed20223_)
+}
+
+export interface IComputedFactory extends Annotation, ClassGetterDecorator {
+    // computed annotation with options
+    <T>(options: IComputedValueOptions<T>): DecoratorAnnotation<ClassGetterDecorator>
     // computed(fn, opts)
     <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>
-
-    struct: Annotation & PropertyDecorator & ClassGetterDecorator
 }
 
 const computedAnnotation = createComputedAnnotation(COMPUTED)
 const computedStructAnnotation = createComputedAnnotation(COMPUTED_STRUCT, {
-    equals: comparer.structural
+    equals: compareStructural
 })
+export const computedStruct = createComputedDecoratorAnnotation(computedStructAnnotation)
 
-/**
- * Decorator for class properties: @computed get value() { return expr; }.
- * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
- */
 export const computed: IComputedFactory = function computed(arg1, arg2) {
-    if (is20223Decorator(arg2)) {
-        // @computed (2022.3 Decorators)
-        return computedAnnotation.decorate_20223_(arg1, arg2)
-    }
-    if (isStringish(arg2)) {
-        // @computed
-        return storeAnnotation(arg1, arg2, computedAnnotation)
+    if (arg2 && typeof arg2.kind === "string") {
+        return decorateComputed20223_(computedAnnotation, arg1, arg2)
     }
+
     if (isPlainObject(arg1)) {
-        // @computed({ options })
-        return createDecoratorAnnotation(createComputedAnnotation(COMPUTED, arg1))
+        // computed annotation with options
+        return createComputedDecoratorAnnotation(createComputedAnnotation(COMPUTED, arg1))
     }
 
     // computed(expr, options?)
@@ -69,6 +64,4 @@ export const computed: IComputedFactory = function computed(arg1, arg2) {
     return new ComputedValue(opts)
 } as any
 
-Object.assign(computed, computedAnnotation)
-
-computed.struct = createDecoratorAnnotation(computedStructAnnotation)
+assign(computed, computedAnnotation)

package/src/api/configure.ts

@@ -1,9 +1,7 @@
 import { globalState, isolateGlobalState, setReactionScheduler } from "../internal"
 
-const NEVER = "never"
 const ALWAYS = "always"
 const OBSERVED = "observed"
-// const IF_AVAILABLE = "ifavailable"
 
 export function configure(options: {
     enforceActions?: "never" | "always" | "observed"
@@ -20,23 +18,11 @@ export function configure(options: {
     disableErrorBoundaries?: boolean
     safeDescriptors?: boolean
     reactionScheduler?: (f: () => void) => void
-    useProxies?: "always" | "never" | "ifavailable"
 }): void {
     if (options.isolateGlobalState === true) {
         isolateGlobalState()
     }
-    const { useProxies, enforceActions } = options
-    if (useProxies !== undefined) {
-        globalState.useProxies =
-            useProxies === ALWAYS
-                ? true
-                : useProxies === NEVER
-                ? false
-                : typeof Proxy !== "undefined"
-    }
-    if (useProxies === "ifavailable") {
-        globalState.verifyProxies = true
-    }
+    const { enforceActions } = options
     if (enforceActions !== undefined) {
         const ea = enforceActions === ALWAYS ? ALWAYS : enforceActions === OBSERVED
         globalState.enforceActions = ea

package/src/api/decoratorannotation.ts

@@ -0,0 +1,20 @@
+import { die } from "../errors"
+import { assign } from "../utils/utils"
+import type { Annotation } from "./annotation"
+
+export type DecoratorAnnotation<Decorator extends (...args: any[]) => any> = Annotation & Decorator
+
+export function createDecoratorAnnotation<Decorator extends (...args: any[]) => any>(
+    annotation: Annotation,
+    decorate: (annotation: Annotation, value: any, context: any) => any
+): DecoratorAnnotation<Decorator> {
+    return assign(function decoratorAnnotation(value, context) {
+        if (context && typeof context.kind === "string") {
+            return decorate(annotation, value, context)
+        }
+        if (__DEV__) {
+            die(`Invalid arguments for \`${annotation.annotationType_}\``)
+        }
+        return undefined
+    }, annotation) as any
+}

package/src/api/decorators.ts

@@ -1,88 +1,4 @@
-import { Annotation, addHiddenProp, AnnotationsMap, hasProp, die, isOverride } from "../internal"
-
-import type { Decorator } from "../types/decorator_fills"
-
-export const storedAnnotationsSymbol = Symbol("mobx-stored-annotations")
-
-/**
- * Creates a function that acts as
- * - decorator
- * - annotation object
- */
-export function createDecoratorAnnotation<D extends Decorator = Decorator>(
-    annotation: Annotation
-): PropertyDecorator & Annotation & D {
-    function decorator(target, property) {
-        if (is20223Decorator(property)) {
-            return annotation.decorate_20223_(target, property)
-        } else {
-            storeAnnotation(target, property, annotation)
-        }
-    }
-    return Object.assign(decorator, annotation) as any
-}
-
-/**
- * Stores annotation to prototype,
- * so it can be inspected later by `makeObservable` called from constructor
- */
-export function storeAnnotation(prototype: any, key: PropertyKey, annotation: Annotation) {
-    if (!hasProp(prototype, storedAnnotationsSymbol)) {
-        addHiddenProp(prototype, storedAnnotationsSymbol, {
-            // Inherit annotations
-            ...prototype[storedAnnotationsSymbol]
-        })
-    }
-    // @override must override something
-    if (__DEV__ && isOverride(annotation) && !hasProp(prototype[storedAnnotationsSymbol], key)) {
-        const fieldName = `${prototype.constructor.name}.prototype.${key.toString()}`
-        die(
-            `'${fieldName}' is decorated with 'override', ` +
-                `but no such decorated member was found on prototype.`
-        )
-    }
-    // Cannot re-decorate
-    assertNotDecorated(prototype, annotation, key)
-
-    // Ignore override
-    if (!isOverride(annotation)) {
-        prototype[storedAnnotationsSymbol][key] = annotation
-    }
-}
-
-function assertNotDecorated(prototype: object, annotation: Annotation, key: PropertyKey) {
-    if (__DEV__ && !isOverride(annotation) && hasProp(prototype[storedAnnotationsSymbol], key)) {
-        const fieldName = `${prototype.constructor.name}.prototype.${key.toString()}`
-        const currentAnnotationType = prototype[storedAnnotationsSymbol][key].annotationType_
-        const requestedAnnotationType = annotation.annotationType_
-        die(
-            `Cannot apply '@${requestedAnnotationType}' to '${fieldName}':` +
-                `\nThe field is already decorated with '@${currentAnnotationType}'.` +
-                `\nRe-decorating fields is not allowed.` +
-                `\nUse '@override' decorator for methods overridden by subclass.`
-        )
-    }
-}
-
-/**
- * Collects annotations from prototypes and stores them on target (instance)
- */
-export function collectStoredAnnotations(target): AnnotationsMap<any, any> {
-    if (!hasProp(target, storedAnnotationsSymbol)) {
-        // if (__DEV__ && !target[storedAnnotationsSymbol]) {
-        //     die(
-        //         `No annotations were passed to makeObservable, but no decorated members have been found either`
-        //     )
-        // }
-        // We need a copy as we will remove annotation from the list once it's applied.
-        addHiddenProp(target, storedAnnotationsSymbol, { ...target[storedAnnotationsSymbol] })
-    }
-    return target[storedAnnotationsSymbol]
-}
-
-export function is20223Decorator(context): context is DecoratorContext {
-    return typeof context == "object" && typeof context["kind"] == "string"
-}
+import { die } from "../internal"
 
 export function assert20223DecoratorType(
     context: DecoratorContext,

package/src/api/extras.ts

@@ -33,7 +33,7 @@ function nodeToObserverTree(node: IDepTreeNode): IObserverTree {
         name: node.name_
     }
     if (hasObservers(node as any)) {
-        result.observers = Array.from(<any>getObservers(node as any)).map(<any>nodeToObserverTree)
+        result.observers = Array.from(<any>getObservers(node as any), <any>nodeToObserverTree)
     }
     return result
 }