mobx 6.0.3 → 6.0.4

package/package.json

@@ -1,15 +1,24 @@
 {
     "name": "mobx",
-    "version": "6.0.3",
+    "version": "6.0.4",
     "description": "Simple, scalable state management.",
+    "source": "src/mobx.ts",
     "main": "dist/index.js",
-    "module": "dist/mobx.esm.js",
     "umd:main": "dist/mobx.umd.production.min.js",
     "unpkg": "dist/mobx.umd.production.min.js",
-    "jsnext:main": "dist/mobx.esm.js",
+    "jsdelivr": "dist/mobx.umd.production.min.js",
+    "jsnext:main": "dist/mobx.esm.production.min.js",
+    "module": "dist/mobx.esm.js",
     "react-native": "dist/mobx.esm.js",
-    "source": "src/mobx.ts",
+    "types": "dist/mobx.d.ts",
     "typings": "dist/mobx.d.ts",
+    "files": [
+        "src",
+        "dist",
+        "LICENSE",
+        "CHANGELOG.md",
+        "README.md"
+    ],
     "sideEffects": false,
     "repository": {
         "type": "git",
@@ -24,13 +33,6 @@
     "bugs": {
         "url": "https://github.com/mobxjs/mobx/issues"
     },
-    "files": [
-        "src",
-        "dist",
-        "LICENSE",
-        "CHANGELOG.md",
-        "README.md"
-    ],
     "homepage": "https://mobx.js.org/",
     "dependencies": {},
     "devDependencies": {
@@ -61,15 +63,15 @@
     "scripts": {
         "test": "jest",
         "lint": "eslint src/**/*",
-        "build": "node scripts/build.js",
+        "build": "node ../../scripts/build.js mobx",
+        "build:test": "yarn build --target test",
         "perf": "scripts/perf.sh",
         "test:performance": "yarn perf proxy && yarn perf legacy",
         "test:mixed-versions": "yarn test --testRegex mixed-versions",
-        "test:check": "yarn test:types && yarn lint",
-        "test:types": "tsc --noEmit && yarn test:flow",
+        "test:types": "tsc --noEmit",
         "test:flow": "flow check",
         "test:coverage": "yarn test -i --coverage",
         "test:size": "yarn import-size --report . observable computed autorun action",
-        "prepublish": "yarn build publish"
+        "prepublish": "node ./scripts/prepublish.js && yarn build --target publish"
     }
 }

package/src/types/observableobject.ts

@@ -324,9 +324,14 @@ export function asObservableObject(
 
     if (__DEV__ && !Object.isExtensible(target))
         die("Cannot make the designated object observable; it is not extensible")
-    if (!isPlainObject(target))
-        name = (target.constructor.name || "ObservableObject") + "@" + getNextId()
-    if (!name) name = "ObservableObject@" + getNextId()
+
+    if (!name) {
+        if (isPlainObject(target)) {
+            name = "ObservableObject@" + getNextId()
+        } else {
+            name = (target.constructor.name || "ObservableObject") + "@" + getNextId()
+        }
+    }
 
     const adm = new ObservableObjectAdministration(
         target,

package/dist/index.js.flow

@@ -1,591 +0,0 @@
-// @flow
-
-export type IObservableMapInitialValues<K, V> = IMapEntries<K, V> | KeyValueMap<V> | IMap<K, V>
-
-export interface IMobxConfigurationOptions {
-    +enforceActions?: "never" | "always" | "observed";
-    computedRequiresReaction?: boolean;
-    /**
-     * (Experimental)
-     * Warn if you try to create to derivation / reactive context without accessing any observable.
-     */
-    reactionRequiresObservable?: boolean;
-    /**
-     * (Experimental)
-     * Warn if observables are accessed outside a reactive context
-     */
-    observableRequiresReaction?: boolean;
-    isolateGlobalState?: boolean;
-    disableErrorBoundaries?: boolean;
-    reactionScheduler?: (f: () => void) => void;
-    useProxies?: "always" | "never" | "ifavailable";
-}
-
-declare export function configure(options: IMobxConfigurationOptions): void
-
-export interface IAutorunOptions {
-    delay?: number;
-    name?: string;
-    /**
-     *  warn if the derivation has no dependencies after creation/update
-     */
-    requiresObservable?: boolean;
-    scheduler?: (callback: () => void) => any;
-    onError?: (error: any) => void;
-}
-
-export interface IReactionOptions extends IAutorunOptions {
-    fireImmediately?: boolean;
-    equals?: IEqualsComparer<any>;
-}
-
-export interface IInterceptable<T> {
-    interceptors: IInterceptor<T>[] | any;
-    intercept(handler: IInterceptor<T>): Lambda;
-}
-
-export type IEqualsComparer<T> = (a: T, b: T) => boolean
-
-export type IInterceptor<T> = (change: T) => T
-
-export type IMapEntry<K, V> = [K, V]
-
-export type IMapEntries<K, V> = IMapEntry<K, V>[]
-
-export interface IMap<K, V> {
-    clear(): void;
-    delete(key: K): boolean;
-    forEach(callbackfn: (value: V, index: K, map: IMap<K, V>) => void, thisArg?: any): void;
-    get(key: K): V | any;
-    has(key: K): boolean;
-    set(key: K, value?: V): any;
-    size: number;
-}
-
-declare export function isObservableMap(x: any): boolean
-
-export interface IComputedValueOptions<T> {
-    get?: () => T;
-    set?: (value: T) => void;
-    name?: string;
-    equals?: IEqualsComparer<T>;
-    context?: any;
-}
-
-type PropertyDescriptor<T> = {
-    enumerable?: boolean,
-    configurable?: boolean,
-    writable?: boolean,
-    value?: T,
-    get?: () => T,
-    set?: (value: T) => void
-}
-
-export interface IComputed {
-    <T>(func: () => T, setter?: (value: T) => void): IComputedValue<T>;
-    <T>(func: () => T, options: IComputedValueOptions<T>): IComputedValue<T>;
-    (target: Object, key: string, baseDescriptor?: PropertyDescriptor<*>): void;
-    struct(target: Object, key: string, baseDescriptor?: PropertyDescriptor<*>): void;
-}
-
-export interface IDependencyTree {
-    name: string;
-    dependencies?: IDependencyTree[];
-}
-
-export interface IObserverTree {
-    name: string;
-    observers?: IObserverTree[];
-}
-
-export interface IAtom {
-    reportObserved: () => void;
-    reportChanged: () => void;
-}
-
-export interface IComputedValue<T> {
-    get(): T;
-    set(value: T): void;
-    observe(listener: (newValue: T, oldValue: T) => void, fireImmediately?: boolean): Lambda;
-}
-
-export interface IObservable {}
-
-export interface IDepTreeNode {
-    name: string;
-    observing?: IObservable[];
-}
-
-export interface IDerivation {
-    name: string;
-}
-
-export interface IReactionPublic {
-    dispose: () => void;
-    trace: (enterBreakPoint?: boolean) => void;
-}
-
-declare export class IListenable {
-    observe(handler: (change: any, oldValue?: any) => void, fireImmediately?: boolean): Lambda;
-}
-
-export interface IObservableArray<T> extends Array<T> {
-    spliceWithArray(index: number, deleteCount?: number, newItems?: T[]): T[];
-    observe(
-        listener: (changeData: IArrayChange<T> | IArraySplice<T>) => void,
-        fireImmediately?: boolean
-    ): Lambda;
-    intercept(handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
-    intercept(handler: IInterceptor<IArrayChange<T> | IArraySplice<T>>): Lambda; // TODO: remove in 4.0
-    intercept<T>(handler: IInterceptor<IArrayChange<T> | IArraySplice<T>>): Lambda; // TODO: remove in 4.0
-    clear(): T[];
-    peek(): T[];
-    replace(newItems: T[]): T[];
-    find(
-        predicate: (item: T, index: number, array: Array<T>) => mixed,
-        thisArg?: any,
-        fromIndex?: number
-    ): T | any;
-    findIndex(
-        predicate: (item: T, index: number, array: Array<T>) => mixed,
-        thisArg?: any,
-        fromIndex?: number
-    ): number;
-    remove(value: T): boolean;
-}
-
-export interface IArrayChange<T> {
-    type: "update";
-    object: IObservableArray<T>;
-    index: number;
-    newValue: T;
-    oldValue: T;
-}
-
-export interface IArraySplice<T> {
-    type: "splice";
-    object: IObservableArray<T>;
-    index: number;
-    added: T[];
-    addedCount: number;
-    removed: T[];
-    removedCount: number;
-}
-
-export interface IArrayWillChange<T> {
-    type: "update";
-    object: IObservableArray<T>;
-    index: number;
-    newValue: T;
-}
-
-export interface IArrayWillSplice<T> {
-    type: "splice";
-    object: IObservableArray<T>;
-    index: number;
-    added: T[];
-    removedCount: number;
-}
-
-export type KeyValueMap<V> = {
-    [key: string]: V
-}
-
-export interface IMapChange<K, T> {
-    object: ObservableMap<K, T>;
-    type: "update" | "add" | "delete";
-    name: K;
-    newValue?: any;
-    oldValue?: any;
-}
-
-export interface IMapWillChange<K, T> {
-    object: ObservableMap<K, T>;
-    type: "update" | "add" | "delete";
-    name: K;
-    newValue?: any;
-}
-
-export interface IObservableObject {}
-
-export interface IObjectChange {
-    name: string;
-    object: any;
-    type: "update" | "add" | "remove";
-    oldValue?: any;
-    newValue: any;
-}
-
-export interface IObjectWillChange {
-    object: any;
-    type: "update" | "add" | "remove";
-    name: string;
-    newValue: any;
-}
-
-export interface IValueWillChange<T> {
-    object: any;
-    type: "update";
-    newValue: T;
-}
-
-export interface IValueDidChange<T> extends IValueWillChange<T> {
-    oldValue: ?T;
-}
-
-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 interface IEnhancer<T> {
-    (newValue: T, oldValue: T | void, name: string): T;
-}
-
-export interface IObservableFactory {
-    // observable overloads
-    (target: Object, key: string, baseDescriptor?: PropertyDescriptor<*>): any;
-    <T>(value: Array<T>): IObservableArray<T>;
-    <T>(value: null | void): IObservableValue<T>;
-    (value: null | void): IObservableValue<any>;
-    <T>(value: IMap<string | number | boolean, T>): ObservableMap<T>;
-    <T: Object>(value: T): T;
-}
-
-export type IObservableDecorator = {
-    (target: Object, property: string, descriptor?: PropertyDescriptor<*>): void,
-    enhancer: IEnhancer<any>
-}
-
-export type CreateObservableOptions = {
-    name?: string,
-    deep?: boolean,
-    defaultDecorator?: IObservableDecorator
-}
-
-declare export class IObservableFactories {
-    box<T>(value?: T, options?: CreateObservableOptions): IObservableValue<T>;
-    array<T>(initialValues?: T[], options?: CreateObservableOptions): IObservableArray<T>;
-    set<V>(initialValues?: V[], options?: CreateObservableOptions): Set<V>;
-    map<K, V>(
-        initialValues?: IObservableMapInitialValues<K, V>,
-        options?: CreateObservableOptions
-    ): ObservableMap<K, V>;
-    object<T>(props: T, options?: CreateObservableOptions): T & IObservableObject;
-    ref(
-        target: Object,
-        property?: string,
-        descriptor?: PropertyDescriptor<*>
-    ): IObservableDecorator;
-    shallow(
-        target: Object,
-        property?: string,
-        descriptor?: PropertyDescriptor<*>
-    ): IObservableDecorator;
-    deep(
-        target: Object,
-        property?: string,
-        descriptor?: PropertyDescriptor<*>
-    ): IObservableDecorator;
-    struct(
-        target: Object,
-        property?: string,
-        descriptor?: PropertyDescriptor<*>
-    ): IObservableDecorator;
-}
-
-export interface Lambda {
-    (): void;
-    name?: string;
-}
-
-export interface IActionFactory {
-    (a1: any, a2?: any, a3?: any, a4?: any, a6?: any): any;
-    bound(target: Object, propertyKey: string, descriptor?: PropertyDescriptor<*>): void;
-}
-
-declare export class ObservableMap<K, V> {
-    constructor(initialData?: IMapEntries<K, V> | KeyValueMap<V>, valueModeFunc?: Function): this;
-    has(key: K): boolean;
-    set(key: K, value: V): void;
-    delete(key: K): boolean;
-    get(key: K): V;
-    keys(): Iterator<K>;
-    values(): Iterator<V>;
-    entries(): IMapEntries<K, V> & Iterator<IMapEntry<K, V>>;
-    forEach(callback: (value: V, key: K, object: KeyValueMap<K, V>) => void, thisArg?: any): void;
-    merge(other: ObservableMap<K, V> | KeyValueMap<K, V>): ObservableMap<K, V>;
-    clear(): void;
-    replace(other: ObservableMap<K, V> | KeyValueMap<K, V>): ObservableMap<K, V>;
-    size: number;
-    toJS(): Map<K, V>;
-    toPOJO(): KeyValueMap<V>;
-    toJSON(): KeyValueMap<V>;
-    toString(): string;
-    observe(listener: (changes: IMapChange<K, V>) => void, fireImmediately?: boolean): Lambda;
-    intercept(handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
-}
-
-declare export function action(
-    targetOrName: any,
-    propertyKeyOrFuc?: any,
-    descriptor?: PropertyDescriptor<*>
-): any
-declare export function action<T>(name: string, func: T): T
-declare export function action<T>(func: T): T
-
-declare export function runInAction<T>(name: string, block: () => T): T
-declare export function runInAction<T>(block: () => T): T
-declare export function isAction(thing: any): boolean
-declare export function autorun(
-    nameOrFunction: string | ((r: IReactionPublic) => any),
-    options?: IAutorunOptions
-): any
-declare export function reaction<T>(
-    expression: (r: IReactionPublic) => T,
-    effect: (arg: T, r: IReactionPublic) => void,
-    opts?: IReactionOptions
-): () => mixed
-
-export interface IWhenOptions {
-    name?: string;
-    timeout?: number;
-    onError?: (error: any) => void;
-    /**
-     *  warn if the derivation has no dependencies after creation/update
-     */
-    requiresObservable?: boolean;
-}
-
-declare export function when(
-    cond: () => boolean,
-    effect: Lambda,
-    options?: IWhenOptions
-): () => mixed
-declare export function when(cond: () => boolean, options?: IWhenOptions): Promise<any>
-
-declare export function computed<T>(
-    target: any,
-    key?: string,
-    baseDescriptor?: PropertyDescriptor<*>
-): any
-
-declare export function extendObservable<A, B>(
-    target: A,
-    properties: B,
-    decorators?: any,
-    options?: any
-): A & B
-
-declare export function makeObservable<A>(target: A, annotations?: any, options: any): A
-
-declare export function makeAutoObservable<A>(target: A, exceptions?: any, options: any): A
-
-declare export function intercept(
-    object: Object,
-    property: string,
-    handler: IInterceptor<any>
-): Lambda
-
-declare export function isComputed(value: any): boolean
-declare export function isComputedProp(value: any, property: string): boolean
-
-declare export function isObservable(value: any): boolean
-declare export function isObservableProp(value: any, property: string): boolean
-
-declare export var comparer: {
-    identity: IEqualsComparer<any>,
-    structural: IEqualsComparer<any>,
-    default: IEqualsComparer<any>
-}
-
-declare export var observable: IObservableFactory &
-    IObservableFactories & {
-        deep: {
-            struct<T>(initialValue?: T): T
-        },
-        ref: {
-            struct<T>(initialValue?: T): T
-        }
-    }
-
-declare export function observe<T>(
-    value: IObservableValue<T> | IComputedValue<T>,
-    listener: (change: IValueDidChange<T>) => void,
-    fireImmediately?: boolean
-): Lambda
-declare export function observe<T>(
-    observableArray: IObservableArray<T>,
-    listener: (change: IArrayChange<T> | IArraySplice<T>) => void,
-    fireImmediately?: boolean
-): Lambda
-declare export function observe<K, T>(
-    observableMap: ObservableMap<K, T>,
-    listener: (change: IMapChange<K, T>) => void,
-    fireImmediately?: boolean
-): Lambda
-declare export function observe<K, T>(
-    observableMap: ObservableMap<K, T>,
-    property: string,
-    listener: (change: IValueDidChange<K, T>) => void,
-    fireImmediately?: boolean
-): Lambda
-declare export function observe(
-    object: any,
-    listener: (change: IObjectChange) => void,
-    fireImmediately?: boolean
-): Lambda
-declare export function observe(
-    object: any,
-    property: string,
-    listener: (change: IValueDidChange<any>) => void,
-    fireImmediately?: boolean
-): Lambda
-
-declare export function toJS<T>(source: T): T
-
-declare export function untracked<T>(action: () => T): T
-
-declare export function spy(listener: (change: any) => void): Lambda
-
-declare export function transaction<T>(action: () => T, thisArg?: any, report?: boolean): T
-
-declare export function isObservableArray(thing: any): boolean
-
-declare export function isObservableObject<T>(thing: T): boolean
-
-declare export class Reaction {
-    name: string;
-    isDisposed: boolean;
-    constructor(name: string, onInvalidate: () => void): this;
-    schedule(): void;
-    isScheduled(): boolean;
-    track(fn: () => void): void;
-    dispose(): void;
-    getDisposer(): Lambda & {
-        $mosbservable: Reaction
-    };
-    toString(): string;
-    trace(enterBreakPoint?: boolean): void;
-}
-
-declare export function createAtom(
-    name: string,
-    onBecomeObservedHandler?: () => void,
-    onBecomeUnobservedHandler?: () => void
-): IAtom
-
-declare export function decorate<T>(target: T, decorators: any): T
-
-export type CancellablePromise<T> = Promise<T> & { cancel: () => void }
-
-declare export function flow<T>(
-    fn: () => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): () => CancellablePromise<T>
-declare export function flow<T, A>(
-    fn: (A) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): A => CancellablePromise<T>
-declare export function flow<T, A, B>(
-    fn: (A, B) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): (A, B) => CancellablePromise<T>
-declare export function flow<T, A, B, C>(
-    fn: (A, B, C) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): (A, B, C) => CancellablePromise<T>
-declare export function flow<T, A, B, C, D>(
-    fn: (
-        A,
-        B,
-        C,
-        D
-    ) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): (A, B, C, D) => CancellablePromise<T>
-declare export function flow<T, A, B, C, D, E>(
-    fn: (
-        A,
-        B,
-        C,
-        D,
-        E
-    ) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): (A, B, C, D, E) => CancellablePromise<T>
-declare export function flow<T, A, B, C, D, E, F>(
-    fn: (
-        A,
-        B,
-        C,
-        D,
-        E,
-        F
-    ) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): (A, B, C, D, E, F) => CancellablePromise<T>
-declare export function flow<T, A, B, C, D, E, F, G, H>(
-    fn: (
-        A,
-        B,
-        C,
-        D,
-        E,
-        F,
-        G,
-        H
-    ) => Generator<any, T | Promise<T>, any> | AsyncGenerator<any, T | Promise<T>, any>
-): (A, B, C, D, E, F, G, H) => CancellablePromise<T>
-
-declare export function isFlowCancellationError(error: Error): boolean
-declare export class FlowCancellationError extends Error {}
-
-declare export function keys<K>(map: ObservableMap<K, any>): K[]
-declare export function keys(obj: any): string[]
-
-declare export function values<K, T>(map: ObservableMap<K, T>): T[]
-declare export function values<T>(ar: IObservableArray<T>): T[]
-declare export function values(obj: any): any[]
-
-declare export function set<V>(obj: ObservableMap<string, V>, values: { [key: string]: V }): void
-declare export function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): void
-declare export function set<T>(obj: IObservableArray<T>, index: number, value: T): void
-declare export function set(obj: any, values: { [key: string]: any }): void
-declare export function set(obj: any, key: string, value: any): void
-
-declare export function remove<K, V>(obj: ObservableMap<K, V>, key: K): void
-declare export function remove<T>(obj: IObservableArray<T>, index: number): void
-declare export function remove(obj: any, key: string): void
-
-declare export function has<K>(obj: ObservableMap<K, any>, key: K): boolean
-declare export function has<T>(obj: IObservableArray<T>, index: number): boolean
-declare export function has(obj: any, key: string): boolean
-
-declare export function get<K, V>(obj: ObservableMap<K, V>, key: K): V | void
-declare export function get<T>(obj: IObservableArray<T>, index: number): T | void
-declare export function get(obj: any, key: string): any
-
-declare export function onReactionError(
-    handler: (error: any, derivation: IDerivation) => void
-): () => void
-
-declare export function onBecomeObserved(
-    value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any>,
-    listener: Lambda
-): Lambda
-declare export function onBecomeObserved<K>(
-    value: ObservableMap<K, any> | Object,
-    property: K,
-    listener: Lambda
-): Lambda
-
-declare export function onBecomeUnobserved(
-    value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any>,
-    listener: Lambda
-): Lambda
-declare export function onBecomeUnobserved<K>(
-    value: ObservableMap<K, any> | Object,
-    property: K,
-    listener: Lambda
-): Lambda
-
-declare export function getAtom(thing: any, property?: string): IDepTreeNode
-declare export function getDebugName(thing: any, property?: string): string
-declare export function getDependencyTree(thing: any, property?: string): IDependencyTree
-declare export function getObserverTree(thing: any, property?: string): IObserverTree