mobx 6.10.2 → 6.11.0-pre

package/dist/types/actionannotation.d.ts

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

package/dist/types/autoannotation.d.ts

@@ -1,3 +1,3 @@
-import { Annotation } from "../internal";
-export declare const autoAnnotation: Annotation;
-export declare function createAutoAnnotation(options?: object): Annotation;
+import { Annotation } from "../internal";
+export declare const autoAnnotation: Annotation;
+export declare function createAutoAnnotation(options?: object): Annotation;

package/dist/types/computedannotation.d.ts

@@ -1,2 +1,2 @@
-import { Annotation } from "../internal";
-export declare function createComputedAnnotation(name: string, options?: object): Annotation;
+import { Annotation } from "../internal";
+export declare function createComputedAnnotation(name: string, options?: object): Annotation;

package/dist/types/decorator_fills.d.ts

@@ -0,0 +1,6 @@
+export type ClassAccessorDecorator<This = any, Value = any> = (value: ClassAccessorDecoratorTarget<This, Value>, context: ClassAccessorDecoratorContext) => ClassAccessorDecoratorResult<This, Value> | void;
+export type ClassGetterDecorator<This = any, Value = any> = (value: (this: This) => Value, context: ClassGetterDecoratorContext) => ((this: This) => Value) | void;
+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 Decorator = ClassAccessorDecorator | ClassGetterDecorator | ClassSetterDecorator | ClassMethodDecorator | ClassFieldDecorator;

package/dist/types/dynamicobject.d.ts

@@ -1,2 +1,2 @@
-import { IIsObservableObject, CreateObservableOptions } from "../internal";
-export declare function asDynamicObservableObject(target: any, options?: CreateObservableOptions): IIsObservableObject;
+import { IIsObservableObject, CreateObservableOptions } from "../internal";
+export declare function asDynamicObservableObject(target: any, options?: CreateObservableOptions): IIsObservableObject;

package/dist/types/flowannotation.d.ts

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

package/dist/types/generic-abort-signal.d.ts

@@ -1,6 +1,6 @@
-export interface GenericAbortSignal {
-    readonly aborted: boolean;
-    onabort?: ((...args: any) => any) | null;
-    addEventListener?: (...args: any) => any;
-    removeEventListener?: (...args: any) => any;
-}
+export interface GenericAbortSignal {
+    readonly aborted: boolean;
+    onabort?: ((...args: any) => any) | null;
+    addEventListener?: (...args: any) => any;
+    removeEventListener?: (...args: any) => any;
+}

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

@@ -1,8 +1,8 @@
-import { Lambda } from "../internal";
-export declare type IInterceptor<T> = (change: T) => T | null;
-export interface IInterceptable<T> {
-    interceptors_: IInterceptor<T>[] | undefined;
-}
-export declare function hasInterceptors(interceptable: IInterceptable<any>): boolean;
-export declare function registerInterceptor<T>(interceptable: IInterceptable<T>, handler: IInterceptor<T>): Lambda;
-export declare function interceptChange<T>(interceptable: IInterceptable<T | null>, change: T | null): T | null;
+import { Lambda } from "../internal";
+export type IInterceptor<T> = (change: T) => T | null;
+export interface IInterceptable<T> {
+    interceptors_: IInterceptor<T>[] | undefined;
+}
+export declare function hasInterceptors(interceptable: IInterceptable<any>): boolean;
+export declare function registerInterceptor<T>(interceptable: IInterceptable<T>, handler: IInterceptor<T>): Lambda;
+export declare function interceptChange<T>(interceptable: IInterceptable<T | null>, change: T | null): T | null;

package/dist/types/legacyobservablearray.d.ts

@@ -1,3 +1,14 @@
-import { IEnhancer, IObservableArray } from "../internal";
-export declare function reserveArrayBuffer(max: number): void;
-export declare function createLegacyArray<T>(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string): IObservableArray<T>;
+import { IEnhancer, IObservableArray } from "../internal";
+declare class StubArray {
+}
+export declare class LegacyObservableArray<T> extends StubArray {
+    constructor(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string, owned?: boolean);
+    concat(...arrays: T[][]): T[];
+    get length(): number;
+    set length(newLength: number);
+    get [Symbol.toStringTag](): string;
+    [Symbol.iterator](): IterableIterator<any>;
+}
+export declare function reserveArrayBuffer(max: number): void;
+export declare function createLegacyArray<T>(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string): IObservableArray<T>;
+export {};

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

@@ -1,7 +1,7 @@
-import { Lambda } from "../internal";
-export interface IListenable {
-    changeListeners_: Function[] | undefined;
-}
-export declare function hasListeners(listenable: IListenable): boolean;
-export declare function registerListener(listenable: IListenable, handler: Function): Lambda;
-export declare function notifyListeners<T>(listenable: IListenable, change: T): void;
+import { Lambda } from "../internal";
+export interface IListenable {
+    changeListeners_: Function[] | undefined;
+}
+export declare function hasListeners(listenable: IListenable): boolean;
+export declare function registerListener(listenable: IListenable, handler: Function): Lambda;
+export declare function notifyListeners<T>(listenable: IListenable, change: T): void;

package/dist/types/modifiers.d.ts

@@ -1,7 +1,7 @@
-export interface IEnhancer<T> {
-    (newValue: T, oldValue: T | undefined, name: string): T;
-}
-export declare function deepEnhancer(v: any, _: any, name: any): any;
-export declare function shallowEnhancer(v: any, _: any, name: any): any;
-export declare function referenceEnhancer(newValue?: any): any;
-export declare function refStructEnhancer(v: any, oldValue: any): any;
+export interface IEnhancer<T> {
+    (newValue: T, oldValue: T | undefined, name: string): T;
+}
+export declare function deepEnhancer(v: any, _: any, name: any): any;
+export declare function shallowEnhancer(v: any, _: any, name: any): any;
+export declare function referenceEnhancer(newValue?: any): any;
+export declare function refStructEnhancer(v: any, oldValue: any): any;

package/dist/types/observableannotation.d.ts

@@ -1,2 +1,2 @@
-import { Annotation } from "../internal";
-export declare function createObservableAnnotation(name: string, options?: object): Annotation;
+import { Annotation } from "../internal";
+export declare function createObservableAnnotation(name: string, options?: object): Annotation;

package/dist/types/observablearray.d.ts

@@ -1,85 +1,85 @@
-import { IAtom, IEnhancer, IInterceptable, IInterceptor, IListenable, Lambda } from "../internal";
-export declare const UPDATE = "update";
-export declare const MAX_SPLICE_SIZE = 10000;
-export interface IObservableArray<T = any> extends Array<T> {
-    spliceWithArray(index: number, deleteCount?: number, newItems?: T[]): T[];
-    clear(): T[];
-    replace(newItems: T[]): T[];
-    remove(value: T): boolean;
-    toJSON(): T[];
-}
-interface IArrayBaseChange<T> {
-    object: IObservableArray<T>;
-    observableKind: "array";
-    debugObjectName: string;
-    index: number;
-}
-export declare type IArrayDidChange<T = any> = IArrayUpdate<T> | IArraySplice<T>;
-export interface IArrayUpdate<T = any> extends IArrayBaseChange<T> {
-    type: "update";
-    newValue: T;
-    oldValue: T;
-}
-export interface IArraySplice<T = any> extends IArrayBaseChange<T> {
-    type: "splice";
-    added: T[];
-    addedCount: number;
-    removed: T[];
-    removedCount: number;
-}
-export interface IArrayWillChange<T = any> {
-    object: IObservableArray<T>;
-    index: number;
-    type: "update";
-    newValue: T;
-}
-export interface IArrayWillSplice<T = any> {
-    object: IObservableArray<T>;
-    index: number;
-    type: "splice";
-    added: T[];
-    removedCount: number;
-}
-export declare class ObservableArrayAdministration implements IInterceptable<IArrayWillChange<any> | IArrayWillSplice<any>>, IListenable {
-    owned_: boolean;
-    legacyMode_: boolean;
-    atom_: IAtom;
-    readonly values_: any[];
-    interceptors_: any;
-    changeListeners_: any;
-    enhancer_: (newV: any, oldV: any | undefined) => any;
-    dehancer: any;
-    proxy_: IObservableArray<any>;
-    lastKnownLength_: number;
-    constructor(name: string | undefined, enhancer: IEnhancer<any>, owned_: boolean, legacyMode_: 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;
-    spliceWithArray_(index: number, deleteCount?: number, newItems?: any[]): any[];
-    spliceItemsIntoValues_(index: number, deleteCount: number, newItems: any[]): any[];
-    notifyArrayChildUpdate_(index: number, newValue: any, oldValue: any): void;
-    notifyArraySplice_(index: number, added: any[], removed: any[]): void;
-    get_(index: number): any | undefined;
-    set_(index: number, newValue: any): void;
-}
-export declare function createObservableArray<T>(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string, owned?: boolean): IObservableArray<T>;
-export declare var arrayExtensions: {
-    clear(): any[];
-    replace(newItems: any[]): any[];
-    toJSON(): any[];
-    splice(index: number, deleteCount?: number | undefined, ...newItems: any[]): any[];
-    spliceWithArray(index: number, deleteCount?: number | undefined, newItems?: any[] | undefined): any[];
-    push(...items: any[]): number;
-    pop(): any;
-    shift(): any;
-    unshift(...items: any[]): number;
-    reverse(): any[];
-    sort(): any[];
-    remove(value: any): boolean;
-};
-export declare function isObservableArray(thing: any): thing is IObservableArray<any>;
-export {};
+import { IAtom, IEnhancer, IInterceptable, IInterceptor, IListenable, Lambda } from "../internal";
+export declare const UPDATE = "update";
+export declare const MAX_SPLICE_SIZE = 10000;
+export interface IObservableArray<T = any> extends Array<T> {
+    spliceWithArray(index: number, deleteCount?: number, newItems?: T[]): T[];
+    clear(): T[];
+    replace(newItems: T[]): T[];
+    remove(value: T): boolean;
+    toJSON(): T[];
+}
+interface IArrayBaseChange<T> {
+    object: IObservableArray<T>;
+    observableKind: "array";
+    debugObjectName: string;
+    index: number;
+}
+export type IArrayDidChange<T = any> = IArrayUpdate<T> | IArraySplice<T>;
+export interface IArrayUpdate<T = any> extends IArrayBaseChange<T> {
+    type: "update";
+    newValue: T;
+    oldValue: T;
+}
+export interface IArraySplice<T = any> extends IArrayBaseChange<T> {
+    type: "splice";
+    added: T[];
+    addedCount: number;
+    removed: T[];
+    removedCount: number;
+}
+export interface IArrayWillChange<T = any> {
+    object: IObservableArray<T>;
+    index: number;
+    type: "update";
+    newValue: T;
+}
+export interface IArrayWillSplice<T = any> {
+    object: IObservableArray<T>;
+    index: number;
+    type: "splice";
+    added: T[];
+    removedCount: number;
+}
+export declare class ObservableArrayAdministration implements IInterceptable<IArrayWillChange<any> | IArrayWillSplice<any>>, IListenable {
+    owned_: boolean;
+    legacyMode_: boolean;
+    atom_: IAtom;
+    readonly values_: any[];
+    interceptors_: any;
+    changeListeners_: any;
+    enhancer_: (newV: any, oldV: any | undefined) => any;
+    dehancer: any;
+    proxy_: IObservableArray<any>;
+    lastKnownLength_: number;
+    constructor(name: string | undefined, enhancer: IEnhancer<any>, owned_: boolean, legacyMode_: 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;
+    spliceWithArray_(index: number, deleteCount?: number, newItems?: any[]): any[];
+    spliceItemsIntoValues_(index: number, deleteCount: number, newItems: any[]): any[];
+    notifyArrayChildUpdate_(index: number, newValue: any, oldValue: any): void;
+    notifyArraySplice_(index: number, added: any[], removed: any[]): void;
+    get_(index: number): any | undefined;
+    set_(index: number, newValue: any): void;
+}
+export declare function createObservableArray<T>(initialValues: T[] | undefined, enhancer: IEnhancer<T>, name?: string, owned?: boolean): IObservableArray<T>;
+export declare var arrayExtensions: {
+    clear(): any[];
+    replace(newItems: any[]): any[];
+    toJSON(): any[];
+    splice(index: number, deleteCount?: number, ...newItems: any[]): any[];
+    spliceWithArray(index: number, deleteCount?: number, newItems?: any[]): any[];
+    push(...items: any[]): number;
+    pop(): any;
+    shift(): any;
+    unshift(...items: any[]): number;
+    reverse(): any[];
+    sort(): any[];
+    remove(value: any): boolean;
+};
+export declare function isObservableArray(thing: any): thing is IObservableArray<any>;
+export {};

package/dist/types/observablemap.d.ts

@@ -1,78 +1,78 @@
-import { $mobx, IEnhancer, IInterceptable, IInterceptor, IListenable, Lambda, ObservableValue, IAtom } from "../internal";
-export interface IKeyValueMap<V = any> {
-    [key: string]: V;
-}
-export declare type IMapEntry<K = any, V = any> = [K, V];
-export declare type IReadonlyMapEntry<K = any, V = any> = readonly [K, V];
-export declare type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];
-export declare type IReadonlyMapEntries<K = any, V = any> = IReadonlyMapEntry<K, V>[];
-export declare type IMapDidChange<K = any, V = any> = {
-    observableKind: "map";
-    debugObjectName: string;
-} & ({
-    object: ObservableMap<K, V>;
-    name: K;
-    type: "update";
-    newValue: V;
-    oldValue: V;
-} | {
-    object: ObservableMap<K, V>;
-    name: K;
-    type: "add";
-    newValue: V;
-} | {
-    object: ObservableMap<K, V>;
-    name: K;
-    type: "delete";
-    oldValue: V;
-});
-export interface IMapWillChange<K = any, V = any> {
-    object: ObservableMap<K, V>;
-    type: "update" | "add" | "delete";
-    name: K;
-    newValue?: V;
-}
-export declare const ADD = "add";
-export declare const DELETE = "delete";
-export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IReadonlyMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
-export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
-    enhancer_: IEnhancer<V>;
-    name_: string;
-    [$mobx]: {};
-    data_: Map<K, ObservableValue<V>>;
-    hasMap_: Map<K, ObservableValue<boolean>>;
-    keysAtom_: IAtom;
-    interceptors_: any;
-    changeListeners_: any;
-    dehancer: any;
-    constructor(initialData?: IObservableMapInitialValues<K, V>, enhancer_?: IEnhancer<V>, name_?: string);
-    private has_;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    delete(key: K): boolean;
-    private updateValue_;
-    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>>;
-    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>;
-    clear(): void;
-    replace(values: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;
-    get size(): number;
-    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>;
+import { $mobx, IEnhancer, IInterceptable, IInterceptor, IListenable, Lambda, ObservableValue, IAtom } from "../internal";
+export interface IKeyValueMap<V = any> {
+    [key: string]: V;
+}
+export type IMapEntry<K = any, V = any> = [K, V];
+export type IReadonlyMapEntry<K = any, V = any> = readonly [K, V];
+export type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];
+export type IReadonlyMapEntries<K = any, V = any> = IReadonlyMapEntry<K, V>[];
+export type IMapDidChange<K = any, V = any> = {
+    observableKind: "map";
+    debugObjectName: string;
+} & ({
+    object: ObservableMap<K, V>;
+    name: K;
+    type: "update";
+    newValue: V;
+    oldValue: V;
+} | {
+    object: ObservableMap<K, V>;
+    name: K;
+    type: "add";
+    newValue: V;
+} | {
+    object: ObservableMap<K, V>;
+    name: K;
+    type: "delete";
+    oldValue: V;
+});
+export interface IMapWillChange<K = any, V = any> {
+    object: ObservableMap<K, V>;
+    type: "update" | "add" | "delete";
+    name: K;
+    newValue?: V;
+}
+export declare const ADD = "add";
+export declare const DELETE = "delete";
+export type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IReadonlyMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
+export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
+    enhancer_: IEnhancer<V>;
+    name_: string;
+    [$mobx]: {};
+    data_: Map<K, ObservableValue<V>>;
+    hasMap_: Map<K, ObservableValue<boolean>>;
+    keysAtom_: IAtom;
+    interceptors_: any;
+    changeListeners_: any;
+    dehancer: any;
+    constructor(initialData?: IObservableMapInitialValues<K, V>, enhancer_?: IEnhancer<V>, name_?: string);
+    private has_;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    private updateValue_;
+    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>>;
+    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>;
+    clear(): void;
+    replace(values: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;
+    get size(): number;
+    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>;