mobx 6.10.2 → 6.11.0

package/dist/types/observableobject.d.ts

@@ -1,98 +1,98 @@
-import { CreateObservableOptions, Annotation, ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
-export declare type IObjectDidChange<T = any> = {
-    observableKind: "object";
-    name: PropertyKey;
-    object: T;
-    debugObjectName: string;
-} & ({
-    type: "add";
-    newValue: any;
-} | {
-    type: "update";
-    oldValue: any;
-    newValue: any;
-} | {
-    type: "remove";
-    oldValue: any;
-});
-export declare type IObjectWillChange<T = any> = {
-    object: T;
-    type: "update" | "add";
-    name: PropertyKey;
-    newValue: any;
-} | {
-    object: T;
-    type: "remove";
-    name: PropertyKey;
-};
-export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
-    target_: any;
-    values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>;
-    name_: string;
-    defaultAnnotation_: Annotation;
-    keysAtom_: IAtom;
-    changeListeners_: any;
-    interceptors_: any;
-    proxy_: any;
-    isPlainObject_: boolean;
-    appliedAnnotations_?: object;
-    private pendingKeys_;
-    constructor(target_: any, values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation);
-    getObservablePropValue_(key: PropertyKey): any;
-    setObservablePropValue_(key: PropertyKey, newValue: any): boolean | null;
-    get_(key: PropertyKey): any;
-    /**
-     * @param {PropertyKey} key
-     * @param {any} value
-     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
-     * @param {boolean} proxyTrap whether it's called from proxy trap
-     * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
-     */
-    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
-     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
-     * @param {boolean} proxyTrap whether it's called from proxy trap
-     * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
-     */
-    extend_(key: PropertyKey, descriptor: PropertyDescriptor, annotation: Annotation | boolean, proxyTrap?: boolean): boolean | null;
-    /**
-     * @param {PropertyKey} key
-     * @param {PropertyDescriptor} descriptor
-     * @param {boolean} proxyTrap whether it's called from proxy trap
-     * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
-     */
-    defineProperty_(key: PropertyKey, descriptor: PropertyDescriptor, proxyTrap?: boolean): boolean | null;
-    defineObservableProperty_(key: PropertyKey, value: any, enhancer: IEnhancer<any>, proxyTrap?: boolean): boolean | null;
-    defineComputedProperty_(key: PropertyKey, options: IComputedValueOptions<any>, proxyTrap?: boolean): boolean | null;
-    /**
-     * @param {PropertyKey} key
-     * @param {PropertyDescriptor} descriptor
-     * @param {boolean} proxyTrap whether it's called from proxy trap
-     * @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_(): ArrayLike<string | symbol>;
-    keys_(): PropertyKey[];
-}
-export interface IIsObservableObject {
-    $mobx: ObservableObjectAdministration;
-}
-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;
+import { CreateObservableOptions, Annotation, ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
+export type IObjectDidChange<T = any> = {
+    observableKind: "object";
+    name: PropertyKey;
+    object: T;
+    debugObjectName: string;
+} & ({
+    type: "add";
+    newValue: any;
+} | {
+    type: "update";
+    oldValue: any;
+    newValue: any;
+} | {
+    type: "remove";
+    oldValue: any;
+});
+export type IObjectWillChange<T = any> = {
+    object: T;
+    type: "update" | "add";
+    name: PropertyKey;
+    newValue: any;
+} | {
+    object: T;
+    type: "remove";
+    name: PropertyKey;
+};
+export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
+    target_: any;
+    values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>;
+    name_: string;
+    defaultAnnotation_: Annotation;
+    keysAtom_: IAtom;
+    changeListeners_: any;
+    interceptors_: any;
+    proxy_: any;
+    isPlainObject_: boolean;
+    appliedAnnotations_?: object;
+    private pendingKeys_;
+    constructor(target_: any, values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation);
+    getObservablePropValue_(key: PropertyKey): any;
+    setObservablePropValue_(key: PropertyKey, newValue: any): boolean | null;
+    get_(key: PropertyKey): any;
+    /**
+     * @param {PropertyKey} key
+     * @param {any} value
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
+     * @param {boolean} proxyTrap whether it's called from proxy trap
+     * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
+     */
+    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
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
+     * @param {boolean} proxyTrap whether it's called from proxy trap
+     * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
+     */
+    extend_(key: PropertyKey, descriptor: PropertyDescriptor, annotation: Annotation | boolean, proxyTrap?: boolean): boolean | null;
+    /**
+     * @param {PropertyKey} key
+     * @param {PropertyDescriptor} descriptor
+     * @param {boolean} proxyTrap whether it's called from proxy trap
+     * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
+     */
+    defineProperty_(key: PropertyKey, descriptor: PropertyDescriptor, proxyTrap?: boolean): boolean | null;
+    defineObservableProperty_(key: PropertyKey, value: any, enhancer: IEnhancer<any>, proxyTrap?: boolean): boolean | null;
+    defineComputedProperty_(key: PropertyKey, options: IComputedValueOptions<any>, proxyTrap?: boolean): boolean | null;
+    /**
+     * @param {PropertyKey} key
+     * @param {PropertyDescriptor} descriptor
+     * @param {boolean} proxyTrap whether it's called from proxy trap
+     * @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_(): ArrayLike<string | symbol>;
+    keys_(): PropertyKey[];
+}
+export interface IIsObservableObject {
+    $mobx: ObservableObjectAdministration;
+}
+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;

package/dist/types/observableset.d.ts

@@ -1,53 +1,53 @@
-import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor, IAtom } from "../internal";
-export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
-export declare type ISetDidChange<T = any> = {
-    object: ObservableSet<T>;
-    observableKind: "set";
-    debugObjectName: string;
-    type: "add";
-    newValue: T;
-} | {
-    object: ObservableSet<T>;
-    observableKind: "set";
-    debugObjectName: string;
-    type: "delete";
-    oldValue: T;
-};
-export declare type ISetWillChange<T = any> = {
-    type: "delete";
-    object: ObservableSet<T>;
-    oldValue: T;
-} | {
-    type: "add";
-    object: ObservableSet<T>;
-    newValue: T;
-};
-export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
-    name_: string;
-    [$mobx]: {};
-    private data_;
-    atom_: IAtom;
-    changeListeners_: any;
-    interceptors_: any;
-    dehancer: any;
-    enhancer_: (newV: any, oldV: any | undefined) => any;
-    constructor(initialData?: IObservableSetInitialValues<T>, enhancer?: IEnhancer<T>, name_?: string);
-    private dehanceValue_;
-    clear(): void;
-    forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
-    get size(): number;
-    add(value: T): this;
-    delete(value: T): boolean;
-    has(value: T): boolean;
-    entries(): IterableIterator<[T, T]>;
-    keys(): IterableIterator<T>;
-    values(): IterableIterator<T>;
-    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](): IterableIterator<T>;
-    get [Symbol.toStringTag](): string;
-}
-export declare var isObservableSet: (thing: any) => thing is ObservableSet<any>;
+import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor, IAtom } from "../internal";
+export type IObservableSetInitialValues<T> = Set<T> | readonly T[];
+export type ISetDidChange<T = any> = {
+    object: ObservableSet<T>;
+    observableKind: "set";
+    debugObjectName: string;
+    type: "add";
+    newValue: T;
+} | {
+    object: ObservableSet<T>;
+    observableKind: "set";
+    debugObjectName: string;
+    type: "delete";
+    oldValue: T;
+};
+export type ISetWillChange<T = any> = {
+    type: "delete";
+    object: ObservableSet<T>;
+    oldValue: T;
+} | {
+    type: "add";
+    object: ObservableSet<T>;
+    newValue: T;
+};
+export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<ISetWillChange>, IListenable {
+    name_: string;
+    [$mobx]: {};
+    private data_;
+    atom_: IAtom;
+    changeListeners_: any;
+    interceptors_: any;
+    dehancer: any;
+    enhancer_: (newV: any, oldV: any | undefined) => any;
+    constructor(initialData?: IObservableSetInitialValues<T>, enhancer?: IEnhancer<T>, name_?: string);
+    private dehanceValue_;
+    clear(): void;
+    forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+    add(value: T): this;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+    entries(): IterableIterator<[T, T]>;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    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](): IterableIterator<T>;
+    get [Symbol.toStringTag](): string;
+}
+export declare var isObservableSet: (thing: any) => thing is ObservableSet<any>;

package/dist/types/observablevalue.d.ts

@@ -1,49 +1,49 @@
-import { Atom, IEnhancer, IInterceptable, IEqualsComparer, IInterceptor, IListenable, Lambda } from "../internal";
-export interface IValueWillChange<T> {
-    object: IObservableValue<T>;
-    type: "update";
-    newValue: T;
-}
-export declare type IValueDidChange<T = any> = {
-    type: "update";
-    observableKind: "value";
-    object: IObservableValue<T>;
-    debugObjectName: string;
-    newValue: T;
-    oldValue: T | undefined;
-};
-export declare type IBoxDidChange<T = any> = {
-    type: "create";
-    observableKind: "value";
-    object: IObservableValue<T>;
-    debugObjectName: string;
-    newValue: T;
-} | IValueDidChange<T>;
-export interface IObservableValue<T> {
-    get(): T;
-    set(value: T): void;
-}
-export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
-    enhancer: IEnhancer<T>;
-    name_: string;
-    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>);
-    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;
-    valueOf(): T;
-    [Symbol.toPrimitive](): T;
-}
-export declare const isObservableValue: (x: any) => x is IObservableValue<any>;
+import { Atom, IEnhancer, IInterceptable, IEqualsComparer, IInterceptor, IListenable, Lambda } from "../internal";
+export interface IValueWillChange<T> {
+    object: IObservableValue<T>;
+    type: "update";
+    newValue: T;
+}
+export type IValueDidChange<T = any> = {
+    type: "update";
+    observableKind: "value";
+    object: IObservableValue<T>;
+    debugObjectName: string;
+    newValue: T;
+    oldValue: T | undefined;
+};
+export type IBoxDidChange<T = any> = {
+    type: "create";
+    observableKind: "value";
+    object: IObservableValue<T>;
+    debugObjectName: string;
+    newValue: T;
+} | IValueDidChange<T>;
+export interface IObservableValue<T> {
+    get(): T;
+    set(value: T): void;
+}
+export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
+    enhancer: IEnhancer<T>;
+    name_: string;
+    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>);
+    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;
+    valueOf(): T;
+    [Symbol.toPrimitive](): T;
+}
+export declare const isObservableValue: (x: any) => x is IObservableValue<any>;

package/dist/types/overrideannotation.d.ts

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

package/dist/types/type-utils.d.ts

@@ -1,11 +1,11 @@
-import { IDepTreeNode } from "../internal";
-export declare function getAtom(thing: any, property?: PropertyKey): IDepTreeNode;
-export declare function getAdministration(thing: any, property?: string): any;
-export declare function getDebugName(thing: any, property?: string): string;
-/**
- * Helper function for initializing observable structures, it applies:
- * 1. allowStateChanges so we don't violate enforceActions.
- * 2. untracked so we don't accidentaly subscribe to anything observable accessed during init in case the observable is created inside derivation.
- * 3. batch to avoid state version updates
- */
-export declare function initObservable<T>(cb: () => T): T;
+import { IDepTreeNode } from "../internal";
+export declare function getAtom(thing: any, property?: PropertyKey): IDepTreeNode;
+export declare function getAdministration(thing: any, property?: string): any;
+export declare function getDebugName(thing: any, property?: string): string;
+/**
+ * Helper function for initializing observable structures, it applies:
+ * 1. allowStateChanges so we don't violate enforceActions.
+ * 2. untracked so we don't accidentaly subscribe to anything observable accessed during init in case the observable is created inside derivation.
+ * 3. batch to avoid state version updates
+ */
+export declare function initObservable<T>(cb: () => T): T;

package/dist/utils/comparer.d.ts

@@ -1,14 +1,14 @@
-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 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 {};

package/dist/utils/eq.d.ts

@@ -1 +1 @@
-export declare function deepEqual(a: any, b: any, depth?: number): boolean;
+export declare function deepEqual(a: any, b: any, depth?: number): boolean;

package/dist/utils/global.d.ts

@@ -1 +1 @@
-export declare function getGlobal(): any;
+export declare function getGlobal(): any;

package/dist/utils/iterable.d.ts

@@ -1 +1 @@
-export declare function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T>;
+export declare function makeIterable<T>(iterator: Iterator<T>): IterableIterator<T>;

package/dist/utils/utils.d.ts

@@ -1,45 +1,45 @@
-export declare const assign: {
-    <T, U>(target: T, source: U): T & U;
-    <T_1, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
-    <T_2, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
-    (target: object, ...sources: any[]): any;
-};
-export declare const getDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
-export declare const defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
-export declare const objectPrototype: Object;
-export declare const EMPTY_ARRAY: never[];
-export declare const EMPTY_OBJECT: {};
-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.
- */
-export declare function once(func: Lambda): Lambda;
-export declare const noop: () => void;
-export declare function isFunction(fn: any): fn is Function;
-export declare function isString(value: any): value is string;
-export declare function isStringish(value: any): value is string | number | symbol;
-export declare function isObject(value: any): value is Object;
-export declare function isPlainObject(value: any): boolean;
-export declare function isGenerator(obj: any): boolean;
-export declare function addHiddenProp(object: any, propName: PropertyKey, value: any): void;
-export declare function addHiddenFinalProp(object: any, propName: PropertyKey, value: any): void;
-export declare function createInstanceofPredicate<T>(name: string, theClass: new (...args: any[]) => T): (x: any) => x is T;
-export declare function isES6Map(thing: any): thing is Map<any, any>;
-export declare function isES6Set(thing: any): thing is Set<any>;
-/**
- * Returns the following: own enumerable keys and symbols.
- */
-export declare function getPlainObjectKeys(object: any): (string | symbol)[];
-export declare const ownKeys: (target: any) => Array<string | symbol>;
-export declare function stringifyKey(key: any): string;
-export declare function toPrimitive(value: any): any;
-export declare function hasProp(target: Object, prop: PropertyKey): boolean;
-export declare const getOwnPropertyDescriptors: <T>(o: T) => { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & {
-    [x: string]: PropertyDescriptor;
-};
+export declare const assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const getDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare const defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+export declare const objectPrototype: Object;
+export declare const EMPTY_ARRAY: never[];
+export declare const EMPTY_OBJECT: {};
+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.
+ */
+export declare function once(func: Lambda): Lambda;
+export declare const noop: () => void;
+export declare function isFunction(fn: any): fn is Function;
+export declare function isString(value: any): value is string;
+export declare function isStringish(value: any): value is string | number | symbol;
+export declare function isObject(value: any): value is Object;
+export declare function isPlainObject(value: any): boolean;
+export declare function isGenerator(obj: any): boolean;
+export declare function addHiddenProp(object: any, propName: PropertyKey, value: any): void;
+export declare function addHiddenFinalProp(object: any, propName: PropertyKey, value: any): void;
+export declare function createInstanceofPredicate<T>(name: string, theClass: new (...args: any[]) => T): (x: any) => x is T;
+export declare function isES6Map(thing: any): thing is Map<any, any>;
+export declare function isES6Set(thing: any): thing is Set<any>;
+/**
+ * Returns the following: own enumerable keys and symbols.
+ */
+export declare function getPlainObjectKeys(object: any): (string | symbol)[];
+export declare const ownKeys: (target: any) => Array<string | symbol>;
+export declare function stringifyKey(key: any): string;
+export declare function toPrimitive(value: any): any;
+export declare function hasProp(target: Object, prop: PropertyKey): boolean;
+export declare const getOwnPropertyDescriptors: <T>(o: T) => { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & {
+    [x: string]: PropertyDescriptor;
+};

package/package.json

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

package/src/api/action.ts

@@ -7,9 +7,12 @@ import {
     isFunction,
     isStringish,
     createDecoratorAnnotation,
-    createActionAnnotation
+    createActionAnnotation,
+    is20223Decorator
 } from "../internal"
 
+import type { ClassFieldDecorator, ClassMethodDecorator } from "../types/decorator_fills"
+
 export const ACTION = "action"
 export const ACTION_BOUND = "action.bound"
 export const AUTOACTION = "autoAction"
@@ -29,17 +32,24 @@ const autoActionBoundAnnotation = createActionAnnotation(AUTOACTION_BOUND, {
     bound: true
 })
 
-export interface IActionFactory extends Annotation, PropertyDecorator {
+export interface IActionFactory
+    extends Annotation,
+        PropertyDecorator,
+        ClassMethodDecorator,
+        ClassFieldDecorator {
     // 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
+    (customName: string): PropertyDecorator &
+        Annotation &
+        ClassMethodDecorator &
+        ClassFieldDecorator
 
     // decorator (name no longer supported)
-    bound: Annotation & PropertyDecorator
+    bound: Annotation & PropertyDecorator & ClassMethodDecorator & ClassFieldDecorator
 }
 
 function createActionFactory(autoAction: boolean): IActionFactory {
@@ -52,6 +62,13 @@ 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)

package/src/api/annotation.ts

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