mobx 6.16.1 → 7.0.0

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # mobx
 
+## 7.0.0
+
+### Major Changes
+
+-   [`1926c69f53168619d688f348aa587e8f3ae579ae`](https://github.com/mobxjs/mobx/commit/1926c69f53168619d688f348aa587e8f3ae579ae) [#4671](https://github.com/mobxjs/mobx/pull/4671) Thanks [@kubk](https://github.com/kubk)! - Release MobX 7, mobx-react-lite 5, and mobx-react 10.
+
+    Bundle sizes are down: ESM prod 17.02 KiB gzip -> 13.96 KiB gzip; a minimal tree-shaken example is 10.32 KiB gzip now.
+
+    It removes long-deprecated compatibility paths and keeps the React bindings split between `mobx-react-lite` for function components and `mobx-react` for class-component support.
+
+    ## MobX 7
+
+    MobX 7 is a cleanup release focused on the modern runtime and decorator model.
+
+    -   MobX now always uses Proxy-backed observable objects and arrays. The ES5/non-proxy fallback has been removed.
+    -   `configure({ useProxies: ... })` is no longer supported.
+    -   `{ proxy: false }` options for `observable`, `observable.object`, and `observable.array` are no longer supported.
+    -   Legacy decorators are no longer supported.
+    -   Namespaced annotation and comparer properties now use named exports to reduce bundle size:
+
+    | Removed API           | Replacement         |
+    | --------------------- | ------------------- |
+    | `observable.ref`      | `observableRef`     |
+    | `observable.shallow`  | `observableShallow` |
+    | `observable.deep`     | `observableDeep`    |
+    | `observable.struct`   | `observableStruct`  |
+    | `computed.struct`     | `computedStruct`    |
+    | `action.bound`        | `actionBound`       |
+    | `flow.bound`          | `flowBound`         |
+    | `comparer.identity`   | `compareIdentity`   |
+    | `comparer.default`    | `compareDefault`    |
+    | `comparer.structural` | `compareStructural` |
+    | `comparer.shallow`    | `compareShallow`    |
+
+    -   The public `trace` API and its related runtime support have been removed. Use `toJS`, `getDependencyTree`, `getObserverTree`, `spy` or `mobx-log` package for debugging.
+
+    ## mobx-react-lite 5 and mobx-react 10
+
+    mobx-react-lite 5 and mobx-react 10 require MobX 7 and React 18 or later.
+
+    `mobx-react-lite` remains the function-component package. `mobx-react` remains a thin wrapper around `mobx-react-lite` that adds class component and Stage 3 `@observer` class decorator support.
+
+    -   Keep function-component imports on `mobx-react-lite` if you do not need class component support.
+    -   Use `mobx-react` when you need class components or `@observer` class decorators.
+    -   `mobx-react-lite` supports function components and `forwardRef`; `mobx-react` delegates function components to `mobx-react-lite` and handles classes itself.
+    -   Remove React batching imports, including the stale React Native batching deep import. React 18+ renderers handle batching.
+
+    The recommended public React binding surface for both packages is:
+
+    -   `observer`
+    -   `Observer`
+    -   `useLocalObservable`
+    -   `enableStaticRendering`
+    -   `isUsingStaticRendering`
+
+    The following APIs have been removed from the React binding packages:
+
+    -   `Provider`, `inject`, and `MobXProviderContext`; use `React.createContext` directly.
+    -   `disposeOnUnmount`; dispose reactions in `componentWillUnmount` or return cleanup functions from `useEffect`.
+    -   `PropTypes`; use TypeScript or the regular `prop-types` package.
+    -   `useObserver`; wrap components with `observer` or use `<Observer>`.
+    -   `useLocalStore`; use `useLocalObservable`.
+    -   `useAsObservableSource`; synchronize values from props into local observable state explicitly.
+    -   `useStaticRendering`; use `enableStaticRendering`.
+    -   `observerBatching`, `isObserverBatched`, `batchingForReactDom`, `batchingOptOut`, and `batchingForReactNative`; remove these imports because React 18+ renderers handle batching.
+    -   Deprecated `observer(fn, { forwardRef: true })`; pass an already-created `React.forwardRef(...)` component to `observer` instead.
+    -   Legacy function-component `contextTypes` handling.
+
+### Patch Changes
+
+-   [`979d267d569734dc3cb969ed1880ed68bb79f1b5`](https://github.com/mobxjs/mobx/commit/979d267d569734dc3cb969ed1880ed68bb79f1b5) [#4677](https://github.com/mobxjs/mobx/pull/4677) Thanks [@kubk](https://github.com/kubk)! - Shorten minified error URL to reduce production bundle size.
+
 ## 6.16.1
 
 ### Patch Changes

package/README.md

@@ -114,19 +114,15 @@ import { makeAutoObservable } from "mobx"
 import { observer } from "mobx-react-lite"
 
 // Model the application state.
-function createTimer() {
-    return makeAutoObservable({
-        secondsPassed: 0,
-        increase() {
-            this.secondsPassed += 1
-        },
-        reset() {
-            this.secondsPassed = 0
-        }
-    })
-}
-
-const myTimer = createTimer()
+const myTimer = makeAutoObservable({
+    secondsPassed: 0,
+    increase() {
+        this.secondsPassed += 1
+    },
+    reset() {
+        this.secondsPassed = 0
+    }
+})
 
 // Build a "user interface" that uses the observable state.
 const TimerView = observer(({ timer }) => (

package/dist/api/action.d.ts

@@ -1,16 +1,18 @@
 import { Annotation } from "../internal";
-import type { ClassFieldDecorator, ClassMethodDecorator } from "../types/decorator_fills";
+import { type DecoratorAnnotation } from "./decoratorannotation";
+import type { ClassMethodAndFieldDecorator } from "../types/decorator_fills";
 export declare const ACTION = "action";
 export declare const ACTION_BOUND = "action.bound";
 export declare const AUTOACTION = "autoAction";
 export declare const AUTOACTION_BOUND = "autoAction.bound";
-export interface IActionFactory extends Annotation, PropertyDecorator, ClassMethodDecorator, ClassFieldDecorator {
+export interface IActionFactory extends Annotation, ClassMethodAndFieldDecorator {
     <T extends Function | undefined | null>(fn: T): T;
     <T extends Function | undefined | null>(name: string, fn: T): T;
-    (customName: string): PropertyDecorator & Annotation & ClassMethodDecorator & ClassFieldDecorator;
-    bound: Annotation & PropertyDecorator & ClassMethodDecorator & ClassFieldDecorator;
+    (customName: string): DecoratorAnnotation<ClassMethodAndFieldDecorator>;
 }
 export declare const action: IActionFactory;
 export declare const autoAction: IActionFactory;
+export declare const actionBound: DecoratorAnnotation<ClassMethodAndFieldDecorator>;
+export declare const autoActionBound: DecoratorAnnotation<ClassMethodAndFieldDecorator>;
 export declare function runInAction<T>(fn: () => T): T;
 export declare function isAction(thing: any): boolean;

package/dist/api/annotation.d.ts

@@ -8,7 +8,6 @@ export type Annotation = {
     annotationType_: string;
     make_(adm: ObservableObjectAdministration, key: PropertyKey, descriptor: PropertyDescriptor, source: object): MakeResult;
     extend_(adm: ObservableObjectAdministration, key: PropertyKey, descriptor: PropertyDescriptor, proxyTrap: boolean): boolean | null;
-    decorate_20223_(value: any, context: DecoratorContext): any;
     options_?: any;
 };
 export type AnnotationMapEntry = Annotation | true | false;

package/dist/api/computed.d.ts

@@ -1,14 +1,11 @@
 import { IComputedValueOptions, Annotation, IComputedValue } from "../internal";
+import { type DecoratorAnnotation } from "./decoratorannotation";
 import type { ClassGetterDecorator } from "../types/decorator_fills";
 export declare const COMPUTED = "computed";
 export declare const COMPUTED_STRUCT = "computed.struct";
-export interface IComputedFactory extends Annotation, PropertyDecorator, ClassGetterDecorator {
-    <T>(options: IComputedValueOptions<T>): Annotation & PropertyDecorator & ClassGetterDecorator;
+export interface IComputedFactory extends Annotation, ClassGetterDecorator {
+    <T>(options: IComputedValueOptions<T>): DecoratorAnnotation<ClassGetterDecorator>;
     <T>(func: () => T, options?: IComputedValueOptions<T>): IComputedValue<T>;
-    struct: Annotation & PropertyDecorator & ClassGetterDecorator;
 }
-/**
- * Decorator for class properties: @computed get value() { return expr; }.
- * For legacy purposes also invokable as ES5 observable created: `computed(() => expr)`;
- */
+export declare const computedStruct: DecoratorAnnotation<ClassGetterDecorator>;
 export declare const computed: IComputedFactory;

package/dist/api/configure.d.ts

@@ -13,5 +13,4 @@ export declare function configure(options: {
     disableErrorBoundaries?: boolean;
     safeDescriptors?: boolean;
     reactionScheduler?: (f: () => void) => void;
-    useProxies?: "always" | "never" | "ifavailable";
 }): void;

package/dist/api/decoratorannotation.d.ts

@@ -0,0 +1,3 @@
+import type { Annotation } from "./annotation";
+export type DecoratorAnnotation<Decorator extends (...args: any[]) => any> = Annotation & Decorator;
+export declare function createDecoratorAnnotation<Decorator extends (...args: any[]) => any>(annotation: Annotation, decorate: (annotation: Annotation, value: any, context: any) => any): DecoratorAnnotation<Decorator>;

package/dist/api/decorators.d.ts

@@ -1,20 +1 @@
-import { Annotation, AnnotationsMap } from "../internal";
-import type { Decorator } from "../types/decorator_fills";
-export declare const storedAnnotationsSymbol: unique symbol;
-/**
- * Creates a function that acts as
- * - decorator
- * - annotation object
- */
-export declare function createDecoratorAnnotation<D extends Decorator = Decorator>(annotation: Annotation): PropertyDecorator & Annotation & D;
-/**
- * Stores annotation to prototype,
- * so it can be inspected later by `makeObservable` called from constructor
- */
-export declare function storeAnnotation(prototype: any, key: PropertyKey, annotation: Annotation): void;
-/**
- * Collects annotations from prototypes and stores them on target (instance)
- */
-export declare function collectStoredAnnotations(target: any): AnnotationsMap<any, any>;
-export declare function is20223Decorator(context: any): context is DecoratorContext;
 export declare function assert20223DecoratorType(context: DecoratorContext, types: DecoratorContext["kind"][]): void;

package/dist/api/flow.d.ts

@@ -1,4 +1,5 @@
 import { Annotation } from "../internal";
+import { type DecoratorAnnotation } from "./decoratorannotation";
 import type { ClassMethodDecorator } from "../types/decorator_fills";
 export declare const FLOW = "flow";
 export declare class FlowCancellationError extends Error {
@@ -9,13 +10,11 @@ export declare function isFlowCancellationError(error: Error): error is FlowCanc
 export type CancellablePromise<T> = Promise<T> & {
     cancel(): void;
 };
-type FlowGenerator = (...args: any[]) => Generator<any, any, any> | AsyncGenerator<any, any, any>;
-interface Flow extends Annotation, PropertyDecorator {
-    <This, Value extends FlowGenerator>(value: Value, context: ClassMethodDecoratorContext<This, Value>): Value | void;
-    <R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;
-    bound: Annotation & PropertyDecorator & ClassMethodDecorator;
+interface Flow extends Annotation, ClassMethodDecorator {
+    <R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>, context?: never): (...args: Args) => CancellablePromise<R>;
 }
 export declare const flow: Flow;
+export declare const flowBound: DecoratorAnnotation<ClassMethodDecorator>;
 export declare function flowResult<T>(result: T): T extends Generator<any, infer R, any> ? CancellablePromise<R> : T extends CancellablePromise<any> ? T : never;
 export declare function isFlow(fn: any): boolean;
 export {};

package/dist/api/makeObservable.d.ts

@@ -1,6 +1,5 @@
 import { AnnotationsMap, CreateObservableOptions } from "../internal";
 type NoInfer<T> = [T][T extends any ? 0 : never];
-type MakeObservableOptions = Omit<CreateObservableOptions, "proxy">;
-export declare function makeObservable<T extends object, AdditionalKeys extends PropertyKey = never>(target: T, annotations?: AnnotationsMap<T, NoInfer<AdditionalKeys>>, options?: MakeObservableOptions): T;
-export declare function makeAutoObservable<T extends object, AdditionalKeys extends PropertyKey = never>(target: T, overrides?: AnnotationsMap<T, NoInfer<AdditionalKeys>>, options?: MakeObservableOptions): T;
+export declare function makeObservable<T extends object, AdditionalKeys extends PropertyKey = never>(target: T, annotations: AnnotationsMap<T, NoInfer<AdditionalKeys>>, options?: CreateObservableOptions): T;
+export declare function makeAutoObservable<T extends object, AdditionalKeys extends PropertyKey = never>(target: T, overrides?: AnnotationsMap<T, NoInfer<AdditionalKeys>>, options?: CreateObservableOptions): T;
 export {};

package/dist/api/observable.d.ts

@@ -1,5 +1,6 @@
 import { IEnhancer, IEqualsComparer, IObservableArray, IMapEntries, IReadonlyMapEntries, IKeyValueMap, IObservableSetInitialValues, IObservableValue, ObservableMap, ObservableSet, Annotation, AnnotationsMap } from "../internal";
-import type { ClassAccessorDecorator, ClassFieldDecorator } from "../types/decorator_fills";
+import { type DecoratorAnnotation } from "./decoratorannotation";
+import type { ClassAccessorAndFieldDecorator } from "../types/decorator_fills";
 export declare const OBSERVABLE = "observable";
 export declare const OBSERVABLE_REF = "observable.ref";
 export declare const OBSERVABLE_SHALLOW = "observable.shallow";
@@ -9,7 +10,6 @@ export type CreateObservableOptions = {
     equals?: IEqualsComparer<any>;
     deep?: boolean;
     defaultDecorator?: Annotation;
-    proxy?: boolean;
     autoBind?: boolean;
 };
 export declare const defaultCreateObservableOptions: CreateObservableOptions;
@@ -29,25 +29,19 @@ export interface IObservableMapFactory {
     <K, V>(initialValues?: Map<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
     <K = any, V = any>(initialValues: undefined, options?: CreateObservableOptions): ObservableMap<K, V>;
 }
-export interface IObservableFactory extends Annotation, PropertyDecorator, ClassAccessorDecorator, ClassFieldDecorator {
+export interface IObservableFactory extends Annotation, ClassAccessorAndFieldDecorator {
     <T = any>(value: T[], options?: CreateObservableOptions): IObservableArray<T>;
     <T = any>(value: Set<T>, options?: CreateObservableOptions): ObservableSet<T>;
     <K = any, V = any>(value: Map<K, V>, options?: CreateObservableOptions): ObservableMap<K, V>;
-    <T extends object>(value: T, decorators?: AnnotationsMap<T, never>, options?: CreateObservableOptions): T;
+    <T extends object>(value: T, annotations?: AnnotationsMap<T, never>, options?: CreateObservableOptions): T;
     box: IObservableValueFactory;
     array: <T = any>(initialValues?: T[], options?: CreateObservableOptions) => IObservableArray<T>;
     set: <T = any>(initialValues?: IObservableSetInitialValues<T>, options?: CreateObservableOptions) => ObservableSet<T>;
     map: IObservableMapFactory;
-    object: <T = any>(props: T, decorators?: AnnotationsMap<T, never>, options?: CreateObservableOptions) => T;
-    /**
-     * Decorator that creates an observable that only observes the references, but doesn't try to turn the assigned value into an observable.ts.
-     */
-    ref: Annotation & PropertyDecorator & ClassAccessorDecorator & ClassFieldDecorator;
-    /**
-     * Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure
-     */
-    shallow: Annotation & PropertyDecorator & ClassAccessorDecorator & ClassFieldDecorator;
-    deep: Annotation & PropertyDecorator & ClassAccessorDecorator & ClassFieldDecorator;
-    struct: Annotation & PropertyDecorator & ClassAccessorDecorator & ClassFieldDecorator;
+    object: <T = any>(props: T, annotations?: AnnotationsMap<T, never>, options?: CreateObservableOptions) => T;
 }
+export declare const observableRef: DecoratorAnnotation<ClassAccessorAndFieldDecorator>;
+export declare const observableShallow: DecoratorAnnotation<ClassAccessorAndFieldDecorator>;
+export declare const observableDeep: DecoratorAnnotation<ClassAccessorAndFieldDecorator>;
+export declare const observableStruct: DecoratorAnnotation<ClassAccessorAndFieldDecorator>;
 export declare var observable: IObservableFactory;

package/dist/core/atom.d.ts

@@ -6,9 +6,6 @@ export interface IAtom extends IObservable {
 }
 export declare class Atom implements IAtom {
     name_: string;
-    private static readonly isBeingObservedMask_;
-    private static readonly isPendingUnobservationMask_;
-    private static readonly diffValueMask_;
     private flags_;
     observers_: Set<IDerivation>;
     lastAccessedBy_: number;

package/dist/core/computedvalue.d.ts

@@ -1,4 +1,4 @@
-import { CaughtException, IDerivation, IDerivationState_, IEqualsComparer, IObservable, Lambda, TraceMode } from "../internal";
+import { CaughtException, IDerivation, IDerivationState_, IEqualsComparer, IObservable, Lambda } from "../internal";
 export interface IComputedValue<T> {
     get(): T;
     set(value: T): void;
@@ -20,25 +20,6 @@ export type IComputedDidChange<T = any> = {
     newValue: T;
     oldValue: T | undefined;
 };
-/**
- * A node in the state dependency root that observes other nodes, and can be observed itself.
- *
- * ComputedValue will remember the result of the computation for the duration of the batch, or
- * while being observed.
- *
- * During this time it will recompute only when one of its direct dependencies changed,
- * but only when it is being accessed with `ComputedValue.get()`.
- *
- * Implementation description:
- * 1. First time it's being accessed it will compute and remember result
- *    give back remembered result until 2. happens
- * 2. First time any deep dependency change, propagate POSSIBLY_STALE to all observers, wait for 3.
- * 3. When it's being accessed, recompute if any shallow dependency changed.
- *    if result changed: propagate STALE to all observers, that were POSSIBLY_STALE from the last step.
- *    go to step 2. either way
- *
- * If at any point it's outside batch and it isn't observed: reset everything and go to 1.
- */
 export declare class ComputedValue<T> implements IObservable, IComputedValue<T>, IDerivation {
     dependenciesState_: IDerivationState_;
     observing_: IObservable[];
@@ -51,15 +32,9 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     protected value_: T | undefined | CaughtException;
     name_: string;
     triggeredBy_?: string;
-    private static readonly isComputingMask_;
-    private static readonly isRunningSetterMask_;
-    private static readonly isBeingObservedMask_;
-    private static readonly isPendingUnobservationMask_;
-    private static readonly diffValueMask_;
     private flags_;
     derivation: () => T;
     setter_?: (value: T) => void;
-    isTracing_: TraceMode;
     scope_: Object | undefined;
     private equals_;
     private requiresReaction_;
@@ -69,11 +44,9 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
      *
      * The `name` property is for debug purposes only.
      *
-     * The `equals` property specifies the comparer function to use to determine if a newly produced
-     * value differs from the previous value. Two comparers are provided in the library; `defaultComparer`
-     * compares based on identity comparison (===), and `structuralComparer` deeply compares the structure.
-     * Structural comparison can be convenient if you always produce a new aggregated object and
-     * don't want to notify observers if it is structurally the same.
+     * The `equals` property specifies the comparer function used to determine if a newly produced
+     * value differs from the previous value. Structural comparison can be convenient if you always
+     * produce a new aggregated object and don't want to notify observers if it is structurally the same.
      * This is useful for working with vectors, mouse coordinates etc.
      */
     constructor(options: IComputedValueOptions<T>);
@@ -101,7 +74,6 @@ export declare class ComputedValue<T> implements IObservable, IComputedValue<T>,
     trackAndCompute(): boolean;
     computeValue_(track: boolean): T | CaughtException;
     suspend_(): void;
-    observe_(listener: (change: IComputedDidChange<T>) => void, fireImmediately?: boolean): Lambda;
     warnAboutUntrackedRead_(): void;
     toString(): string;
     valueOf(): T;

package/dist/core/derivation.d.ts

@@ -1,15 +1,10 @@
 import { IAtom, IDepTreeNode, IObservable } from "../internal";
-export declare enum IDerivationState_ {
+export declare const enum IDerivationState_ {
     NOT_TRACKING_ = -1,
     UP_TO_DATE_ = 0,
     POSSIBLY_STALE_ = 1,
     STALE_ = 2
 }
-export declare enum TraceMode {
-    NONE = 0,
-    LOG = 1,
-    BREAK = 2
-}
 /**
  * A derivation is everything that can be derived from the state (all the atoms) in a pure manner.
  * See https://medium.com/@mweststrate/becoming-fully-reactive-an-in-depth-explanation-of-mobservable-55995262a254#.xvbh6qd74
@@ -28,7 +23,6 @@ export interface IDerivation extends IDepTreeNode {
      */
     unboundDepsCount_: number;
     onBecomeStale_(): void;
-    isTracing_: TraceMode;
     /**
      *  warn if the derivation has no dependencies after creation/update
      */

package/dist/core/globalstate.d.ts

@@ -93,8 +93,6 @@ export declare class MobXGlobals {
     observableRequiresReaction: boolean;
     disableErrorBoundaries: boolean;
     suppressReactionErrors: boolean;
-    useProxies: boolean;
-    verifyProxies: boolean;
     /**
      * False forces all object's descriptors to
      * writable: true

package/dist/core/reaction.d.ts

@@ -1,4 +1,4 @@
-import { $mobx, IDerivation, IDerivationState_, IObservable, Lambda, TraceMode, GenericAbortSignal } from "../internal";
+import { $mobx, IDerivation, IDerivationState_, IObservable, Lambda, GenericAbortSignal } from "../internal";
 /**
  * Reactions are a special kind of derivations. Several things distinguishes them from normal reactive computations
  *
@@ -19,7 +19,6 @@ import { $mobx, IDerivation, IDerivationState_, IObservable, Lambda, TraceMode,
  */
 export interface IReactionPublic {
     dispose(): void;
-    trace(enterBreakPoint?: boolean): void;
 }
 export interface IReactionDisposer {
     (): void;
@@ -35,13 +34,7 @@ export declare class Reaction implements IDerivation, IReactionPublic {
     dependenciesState_: IDerivationState_;
     runId_: number;
     unboundDepsCount_: number;
-    private static readonly isDisposedMask_;
-    private static readonly isScheduledMask_;
-    private static readonly isTrackPendingMask_;
-    private static readonly isRunningMask_;
-    private static readonly diffValueMask_;
     private flags_;
-    isTracing_: TraceMode;
     constructor(name_: string | undefined, onInvalidate_: () => void, errorHandler_?: ((error: any, derivation: IDerivation) => void) | undefined, requiresObservable_?: any);
     get isDisposed(): boolean;
     set isDisposed(newValue: boolean);
@@ -64,7 +57,6 @@ export declare class Reaction implements IDerivation, IReactionPublic {
     dispose(): void;
     getDisposer_(abortSignal?: GenericAbortSignal): IReactionDisposer;
     toString(): string;
-    trace(enterBreakPoint?: boolean): void;
 }
 export declare function onReactionError(handler: (error: any, derivation: IDerivation) => void): Lambda;
 export declare function runReactions(): void;

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-declare const niceErrors: {
+export declare const niceErrors: {
     readonly 0: "Invalid value for configuration 'enforceActions', expected 'never', 'always' or 'observed'";
     readonly 1: (annotationType: any, key: PropertyKey) => string;
     readonly 5: "'keys()' can only be used on observable objects, arrays, sets and maps";
@@ -13,12 +13,9 @@ declare const niceErrors: {
     readonly 14: "Intercept handlers should return nothing or a change object";
     readonly 15: "Observable arrays cannot be frozen. If you're passing observables to 3rd party component/function that calls Object.freeze, pass copy instead: toJS(observable)";
     readonly 16: "Modification exception: the internal structure of an observable array was changed.";
-    readonly 17: (index: any, length: any) => string;
-    readonly 18: "mobx.map requires Map polyfill for the current browser. Check babel-polyfill or core-js/es6/map.js";
     readonly 19: (other: any) => string;
     readonly 20: (other: any) => string;
     readonly 21: (dataStructure: any) => string;
-    readonly 22: "mobx.set requires Set polyfill for the current browser. Check babel-polyfill or core-js/es6/set.js";
     readonly 23: "It is not possible to get index atoms from arrays";
     readonly 24: (thing: any) => string;
     readonly 25: (property: any, name: any) => string;
@@ -36,6 +33,11 @@ declare const niceErrors: {
     readonly 37: (method: any) => string;
     readonly 38: "'ownKeys()' can only be used on observable objects";
     readonly 39: "'defineProperty()' can only be used on observable objects";
+    readonly 40: (length: any) => string;
+    readonly 41: (other: any) => string;
+    readonly 42: (key: any) => string;
+    readonly 43: (annotationType: any, name: any, kind: any) => string;
+    readonly 44: (annotationType: any) => string;
 };
 declare const errors: typeof niceErrors;
 export declare function die(error: string | keyof typeof errors, ...args: any[]): never;

package/dist/internal.d.ts

@@ -1,5 +1,4 @@
-export * from "./utils/global";
-export * from "./errors";
+export { die } from "./errors";
 export * from "./utils/utils";
 export * from "./api/decorators";
 export * from "./core/atom";
@@ -36,7 +35,6 @@ export * from "./api/isobservable";
 export * from "./api/object-api";
 export * from "./api/observe";
 export * from "./api/tojs";
-export * from "./api/trace";
 export * from "./api/transaction";
 export * from "./api/when";
 export * from "./types/dynamicobject";
@@ -47,7 +45,6 @@ export * from "./types/observablearray";
 export * from "./types/observablemap";
 export * from "./types/observableset";
 export * from "./types/observableobject";
-export * from "./types/legacyobservablearray";
 export * from "./types/type-utils";
 export * from "./utils/eq";
 export * from "./utils/iterable";