mobx 5.15.3 → 5.15.7

package/lib/types/observableobject.d.ts

@@ -1,67 +1,67 @@
-import { ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
-export interface IObservableObject {
-    "observable-object": IObservableObject;
-}
-export declare type IObjectDidChange = {
-    name: PropertyKey;
-    object: any;
-    type: "add";
-    newValue: any;
-} | {
-    name: PropertyKey;
-    object: any;
-    type: "update";
-    oldValue: any;
-    newValue: any;
-} | {
-    name: PropertyKey;
-    object: any;
-    type: "remove";
-    oldValue: any;
-};
-export declare type IObjectWillChange = {
-    object: any;
-    type: "update" | "add";
-    name: PropertyKey;
-    newValue: any;
-} | {
-    object: any;
-    type: "remove";
-    name: PropertyKey;
-};
-export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
-    target: any;
-    values: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>;
-    name: string;
-    defaultEnhancer: IEnhancer<any>;
-    keysAtom: IAtom;
-    changeListeners: any;
-    interceptors: any;
-    private proxy;
-    private pendingKeys;
-    constructor(target: any, values: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>, name: string, defaultEnhancer: IEnhancer<any>);
-    read(key: PropertyKey): any;
-    write(key: PropertyKey, newValue: any): void;
-    has(key: PropertyKey): any;
-    addObservableProp(propName: PropertyKey, newValue: any, enhancer?: IEnhancer<any>): void;
-    addComputedProp(propertyOwner: any, // where is the property declared?
-    propName: PropertyKey, options: IComputedValueOptions<any>): void;
-    remove(key: PropertyKey): void;
-    illegalAccess(owner: any, propName: any): void;
-    /**
-     * 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, newValue: any): void;
-    getKeys(): PropertyKey[];
-}
-export interface IIsObservableObject {
-    $mobx: ObservableObjectAdministration;
-}
-export declare function asObservableObject(target: any, name?: PropertyKey, defaultEnhancer?: IEnhancer<any>): ObservableObjectAdministration;
-export declare function generateObservablePropConfig(propName: any): any;
-export declare function generateComputedPropConfig(propName: any): any;
-export declare function isObservableObject(thing: any): thing is IObservableObject;
+import { ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
+export interface IObservableObject {
+    "observable-object": IObservableObject;
+}
+export declare type IObjectDidChange<T = any> = {
+    name: PropertyKey;
+    object: T;
+    type: "add";
+    newValue: any;
+} | {
+    name: PropertyKey;
+    object: T;
+    type: "update";
+    oldValue: any;
+    newValue: any;
+} | {
+    name: PropertyKey;
+    object: T;
+    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<string | number | symbol, ObservableValue<any> | ComputedValue<any>>;
+    name: string;
+    defaultEnhancer: IEnhancer<any>;
+    keysAtom: IAtom;
+    changeListeners: any;
+    interceptors: any;
+    private proxy;
+    private pendingKeys;
+    constructor(target: any, values: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>, name: string, defaultEnhancer: IEnhancer<any>);
+    read(key: PropertyKey): any;
+    write(key: PropertyKey, newValue: any): void;
+    has(key: PropertyKey): any;
+    addObservableProp(propName: PropertyKey, newValue: any, enhancer?: IEnhancer<any>): void;
+    addComputedProp(propertyOwner: any, // where is the property declared?
+    propName: PropertyKey, options: IComputedValueOptions<any>): void;
+    remove(key: PropertyKey): void;
+    illegalAccess(owner: any, propName: any): void;
+    /**
+     * 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, newValue: any): void;
+    getKeys(): PropertyKey[];
+}
+export interface IIsObservableObject {
+    $mobx: ObservableObjectAdministration;
+}
+export declare function asObservableObject(target: any, name?: PropertyKey, defaultEnhancer?: IEnhancer<any>): ObservableObjectAdministration;
+export declare function generateObservablePropConfig(propName: any): any;
+export declare function generateComputedPropConfig(propName: any): any;
+export declare function isObservableObject(thing: any): thing is IObservableObject;

package/lib/types/observableset.d.ts

@@ -1,49 +1,49 @@
-import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor } from "../internal";
-export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
-export declare type ISetDidChange<T = any> = {
-    object: ObservableSet<T>;
-    type: "add";
-    newValue: T;
-} | {
-    object: ObservableSet<T>;
-    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;
-    private _atom;
-    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;
-    readonly size: number;
-    add(value: T): this;
-    delete(value: any): boolean;
-    has(value: any): 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;
-    toJS(): Set<T>;
-    toString(): string;
-    [Symbol.iterator](): IterableIterator<T>;
-    [Symbol.toStringTag]: "Set";
-}
-export declare const isObservableSet: (thing: any) => thing is ObservableSet<any>;
+import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor } from "../internal";
+export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
+export declare type ISetDidChange<T = any> = {
+    object: ObservableSet<T>;
+    type: "add";
+    newValue: T;
+} | {
+    object: ObservableSet<T>;
+    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;
+    private _atom;
+    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: any): boolean;
+    has(value: any): 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;
+    toJS(): Set<T>;
+    toString(): string;
+    [Symbol.iterator](): IterableIterator<T>;
+    [Symbol.toStringTag]: "Set";
+}
+export declare const isObservableSet: (thing: any) => thing is ObservableSet<any>;

package/lib/types/observablevalue.d.ts

@@ -1,38 +1,38 @@
-import { Atom, IEnhancer, IInterceptable, IEqualsComparer, IInterceptor, IListenable, Lambda } from "../internal";
-export interface IValueWillChange<T> {
-    object: any;
-    type: "update";
-    newValue: T;
-}
-export interface IValueDidChange<T> extends IValueWillChange<T> {
-    oldValue: T | undefined;
-}
-export interface IObservableValue<T> {
-    get(): T;
-    set(value: T): void;
-    intercept(handler: IInterceptor<IValueWillChange<T>>): Lambda;
-    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-}
-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;
-    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: any;
+    type: "update";
+    newValue: T;
+}
+export interface IValueDidChange<T> extends IValueWillChange<T> {
+    oldValue: T | undefined;
+}
+export interface IObservableValue<T> {
+    get(): T;
+    set(value: T): void;
+    intercept(handler: IInterceptor<IValueWillChange<T>>): Lambda;
+    observe(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+}
+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;
+    toJSON(): T;
+    toString(): string;
+    valueOf(): T;
+    [Symbol.toPrimitive](): T;
+}
+export declare const isObservableValue: (x: any) => x is IObservableValue<any>;

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

@@ -1,4 +1,4 @@
-import { IDepTreeNode } from "../internal";
-export declare function getAtom(thing: any, property?: string): IDepTreeNode;
-export declare function getAdministration(thing: any, property?: string): any;
-export declare function getDebugName(thing: any, property?: string): string;
+import { IDepTreeNode } from "../internal";
+export declare function getAtom(thing: any, property?: string): IDepTreeNode;
+export declare function getAdministration(thing: any, property?: string): any;
+export declare function getDebugName(thing: any, property?: string): string;

package/lib/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/lib/utils/decorators.d.ts

@@ -1,9 +1,9 @@
-export declare const mobxDidRunLazyInitializersSymbol: unique symbol;
-export declare const mobxPendingDecorators: unique symbol;
-export declare type BabelDescriptor = PropertyDescriptor & {
-    initializer?: () => any;
-};
-export declare type PropertyCreator = (instance: any, propertyName: PropertyKey, descriptor: BabelDescriptor | undefined, decoratorTarget: any, decoratorArgs: any[]) => void;
-export declare function initializeInstance(target: any): any;
-export declare function createPropDecorator(propertyInitiallyEnumerable: boolean, propertyCreator: PropertyCreator): Function;
-export declare function quacksLikeADecorator(args: IArguments): boolean;
+export declare const mobxDidRunLazyInitializersSymbol: unique symbol;
+export declare const mobxPendingDecorators: unique symbol;
+export declare type BabelDescriptor = PropertyDescriptor & {
+    initializer?: () => any;
+};
+export declare type PropertyCreator = (instance: any, propertyName: PropertyKey, descriptor: BabelDescriptor | undefined, decoratorTarget: any, decoratorArgs: any[]) => void;
+export declare function initializeInstance(target: any): any;
+export declare function createPropDecorator(propertyInitiallyEnumerable: boolean, propertyCreator: PropertyCreator): Function;
+export declare function quacksLikeADecorator(args: IArguments): boolean;

package/lib/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/lib/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/lib/utils/utils.d.ts

@@ -1,43 +1,43 @@
-import { IKeyValueMap, IObservableArray, ObservableMap } from "../internal";
-export declare const OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is a production build.";
-export declare const EMPTY_ARRAY: never[];
-export declare const EMPTY_OBJECT: {};
-export interface Lambda {
-    (): void;
-    name?: string;
-}
-export declare function getNextId(): number;
-export declare function fail(message: string | boolean): never;
-export declare function invariant(check: false, message?: string | boolean): never;
-export declare function invariant(check: true, message?: string | boolean): void;
-export declare function invariant(check: any, message?: string | boolean): void;
-export declare function deprecated(msg: string): boolean;
-export declare function deprecated(thing: string, replacement: string): boolean;
-/**
- * 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 unique<T>(list: T[]): T[];
-export declare function isObject(value: any): boolean;
-export declare function isPlainObject(value: any): boolean;
-export declare function makeNonEnumerable(object: any, propNames: PropertyKey[]): void;
-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 isPropertyConfigurable(object: any, prop: PropertyKey): boolean;
-export declare function assertPropertyConfigurable(object: any, prop: PropertyKey): void;
-export declare function createInstanceofPredicate<T>(name: string, clazz: new (...args: any[]) => T): (x: any) => x is T;
-/**
- * Returns whether the argument is an array, disregarding observability.
- */
-export declare function isArrayLike(x: any): x is Array<any> | IObservableArray<any>;
-export declare function isES6Map(thing: any): boolean;
-export declare function isES6Set(thing: any): thing is Set<any>;
-/**
- * Returns the following: own keys, prototype keys & own symbol keys, if they are enumerable.
- */
-export declare function getPlainObjectKeys(object: any): (string | number | symbol)[];
-export declare function stringifyKey(key: any): string;
-export declare function getMapLikeKeys<K, V>(map: ObservableMap<K, V>): ReadonlyArray<K>;
-export declare function getMapLikeKeys<V>(map: IKeyValueMap<V> | any): ReadonlyArray<string>;
-export declare function toPrimitive(value: any): any;
+import { IObservableArray } from "../internal";
+export declare const OBFUSCATED_ERROR = "An invariant failed, however the error is obfuscated because this is a production build.";
+export declare const EMPTY_ARRAY: never[];
+export declare const EMPTY_OBJECT: {};
+export interface Lambda {
+    (): void;
+    name?: string;
+}
+export declare function getNextId(): number;
+export declare function fail(message: string | boolean): never;
+export declare function invariant(check: false, message?: string | boolean): never;
+export declare function invariant(check: true, message?: string | boolean): void;
+export declare function invariant(check: any, message?: string | boolean): void;
+export declare function deprecated(msg: string): boolean;
+export declare function deprecated(thing: string, replacement: string): boolean;
+/**
+ * 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 unique<T>(list: T[]): T[];
+export declare function isObject(value: any): boolean;
+export declare function isPlainObject(value: any): boolean;
+export declare function convertToMap(dataStructure: any): Map<any, any>;
+export declare function makeNonEnumerable(object: any, propNames: PropertyKey[]): void;
+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 isPropertyConfigurable(object: any, prop: PropertyKey): boolean;
+export declare function assertPropertyConfigurable(object: any, prop: PropertyKey): void;
+export declare function createInstanceofPredicate<T>(name: string, clazz: new (...args: any[]) => T): (x: any) => x is T;
+/**
+ * Returns whether the argument is an array, disregarding observability.
+ */
+export declare function isArrayLike(x: any): x is Array<any> | IObservableArray<any>;
+export declare function isES6Map(thing: any): boolean;
+export declare function isES6Set(thing: any): thing is Set<any>;
+/**
+ * Returns the following: own keys, prototype keys & own symbol keys, if they are enumerable.
+ */
+export declare function getPlainObjectKeys(object: any): (string | number | symbol)[];
+export declare function stringifyKey(key: any): string;
+export declare function toPrimitive(value: any): any;
+export declare const ownKeys: (target: any) => PropertyKey[];

package/package.json

@@ -1,14 +1,10 @@
 {
   "name": "mobx",
-  "version": "5.15.3",
+  "version": "5.15.7",
   "description": "Simple, scalable state management.",
-  "main": "lib/mobx.js",
+  "main": "lib/index.js",
   "umd:main": "lib/mobx.umd.js",
   "module": "lib/mobx.module.js",
-  "browser": {
-    "./lib/mobx.js": "./lib/mobx.js",
-    "./lib/mobx.module.js": "./lib/mobx.module.js"
-  },
   "unpkg": "lib/mobx.umd.min.js",
   "jsnext:main": "lib/mobx.module.js",
   "react-native": "lib/mobx.module.js",
@@ -47,11 +43,5 @@
     "functional-reactive-programming",
     "state management",
     "data flow"
-  ],
-  "lint-staged": {
-    "*.{ts,tsx,js,jsx,md}": [
-      "prettier --write",
-      "git add"
-    ]
-  }
+  ]
 }