mobx 6.10.1 → 6.11.0-pre

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # mobx
 
+## 6.10.2
+
+### Patch Changes
+
+-   [`c8d9374d`](https://github.com/mobxjs/mobx/commit/c8d9374d4f3b05cfec0d690e0eb3ada4f619ff0b) [#3748](https://github.com/mobxjs/mobx/pull/3748) Thanks [@mweststrate](https://github.com/mweststrate)! - Fixed: #3747, computed values becoming stale if the underlying observable was created and updated outside a reactive context
+
 ## 6.10.1
 
 ### Patch Changes

package/dist/api/action.d.ts

@@ -1,15 +1,16 @@
-import { Annotation } from "../internal";
-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 {
-    <T extends Function | undefined | null>(fn: T): T;
-    <T extends Function | undefined | null>(name: string, fn: T): T;
-    (customName: string): PropertyDecorator & Annotation;
-    bound: Annotation & PropertyDecorator;
-}
-export declare const action: IActionFactory;
-export declare const autoAction: IActionFactory;
-export declare function runInAction<T>(fn: () => T): T;
-export declare function isAction(thing: any): boolean;
+import { Annotation } from "../internal";
+import type { ClassFieldDecorator, ClassMethodDecorator } 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 {
+    <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;
+}
+export declare const action: IActionFactory;
+export declare const autoAction: IActionFactory;
+export declare function runInAction<T>(fn: () => T): T;
+export declare function isAction(thing: any): boolean;

package/dist/api/annotation.d.ts

@@ -1,18 +1,19 @@
-import { ObservableObjectAdministration } from "../internal";
-export declare const enum MakeResult {
-    Cancel = 0,
-    Break = 1,
-    Continue = 2
-}
-export declare 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;
-    options_?: any;
-};
-export declare type AnnotationMapEntry = Annotation | true | false;
-export declare type AnnotationsMap<T, AdditionalFields extends PropertyKey> = {
-    [P in Exclude<keyof T, "toString">]?: AnnotationMapEntry;
-} & Record<AdditionalFields, AnnotationMapEntry>;
-export declare function isAnnotation(thing: any): boolean;
-export declare function isAnnotationMapEntry(thing: any): boolean;
+import { ObservableObjectAdministration } from "../internal";
+export declare const enum MakeResult {
+    Cancel = 0,
+    Break = 1,
+    Continue = 2
+}
+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;
+export type AnnotationsMap<T, AdditionalFields extends PropertyKey> = {
+    [P in Exclude<keyof T, "toString">]?: AnnotationMapEntry;
+} & Record<AdditionalFields, AnnotationMapEntry>;
+export declare function isAnnotation(thing: any): boolean;
+export declare function isAnnotationMapEntry(thing: any): boolean;

package/dist/api/autorun.d.ts

@@ -1,25 +1,25 @@
-import { IEqualsComparer, IReactionDisposer, IReactionPublic, GenericAbortSignal } from "../internal";
-export interface IAutorunOptions {
-    delay?: number;
-    name?: string;
-    /**
-     * Experimental.
-     * Warns if the view doesn't track observables
-     */
-    requiresObservable?: boolean;
-    scheduler?: (callback: () => void) => any;
-    onError?: (error: any) => void;
-    signal?: GenericAbortSignal;
-}
-/**
- * Creates a named reactive view and keeps it alive, so that the view is always
- * updated if one of the dependencies changes, even when the view is not further used by something else.
- * @param view The reactive view
- * @returns disposer function, which can be used to stop the view from being updated in the future.
- */
-export declare function autorun(view: (r: IReactionPublic) => any, opts?: IAutorunOptions): IReactionDisposer;
-export declare type IReactionOptions<T, FireImmediately extends boolean> = IAutorunOptions & {
-    fireImmediately?: FireImmediately;
-    equals?: IEqualsComparer<T>;
-};
-export declare function reaction<T, FireImmediately extends boolean = false>(expression: (r: IReactionPublic) => T, effect: (arg: T, prev: FireImmediately extends true ? T | undefined : T, r: IReactionPublic) => void, opts?: IReactionOptions<T, FireImmediately>): IReactionDisposer;
+import { IEqualsComparer, IReactionDisposer, IReactionPublic, GenericAbortSignal } from "../internal";
+export interface IAutorunOptions {
+    delay?: number;
+    name?: string;
+    /**
+     * Experimental.
+     * Warns if the view doesn't track observables
+     */
+    requiresObservable?: boolean;
+    scheduler?: (callback: () => void) => any;
+    onError?: (error: any) => void;
+    signal?: GenericAbortSignal;
+}
+/**
+ * Creates a named reactive view and keeps it alive, so that the view is always
+ * updated if one of the dependencies changes, even when the view is not further used by something else.
+ * @param view The reactive view
+ * @returns disposer function, which can be used to stop the view from being updated in the future.
+ */
+export declare function autorun(view: (r: IReactionPublic) => any, opts?: IAutorunOptions): IReactionDisposer;
+export type IReactionOptions<T, FireImmediately extends boolean> = IAutorunOptions & {
+    fireImmediately?: FireImmediately;
+    equals?: IEqualsComparer<T>;
+};
+export declare function reaction<T, FireImmediately extends boolean = false>(expression: (r: IReactionPublic) => T, effect: (arg: T, prev: FireImmediately extends true ? T | undefined : T, r: IReactionPublic) => void, opts?: IReactionOptions<T, FireImmediately>): IReactionDisposer;

package/dist/api/become-observed.d.ts

@@ -1,5 +1,5 @@
-import { IComputedValue, IObservable, IObservableArray, Lambda, ObservableMap, ObservableSet, IObservableValue } from "../internal";
-export declare function onBecomeObserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any> | ObservableSet<any> | IObservableValue<any>, listener: Lambda): Lambda;
-export declare function onBecomeObserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, listener: Lambda): Lambda;
-export declare function onBecomeUnobserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any> | ObservableSet<any> | IObservableValue<any>, listener: Lambda): Lambda;
-export declare function onBecomeUnobserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, listener: Lambda): Lambda;
+import { IComputedValue, IObservable, IObservableArray, Lambda, ObservableMap, ObservableSet, IObservableValue } from "../internal";
+export declare function onBecomeObserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any> | ObservableSet<any> | IObservableValue<any>, listener: Lambda): Lambda;
+export declare function onBecomeObserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, listener: Lambda): Lambda;
+export declare function onBecomeUnobserved(value: IObservable | IComputedValue<any> | IObservableArray<any> | ObservableMap<any, any> | ObservableSet<any> | IObservableValue<any>, listener: Lambda): Lambda;
+export declare function onBecomeUnobserved<K, V = any>(value: ObservableMap<K, V> | Object, property: K, listener: Lambda): Lambda;

package/dist/api/computed.d.ts

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

package/dist/api/configure.d.ts

@@ -1,17 +1,17 @@
-export declare function configure(options: {
-    enforceActions?: "never" | "always" | "observed";
-    computedRequiresReaction?: boolean;
-    /**
-     * Warn if you try to create to derivation / reactive context without accessing any observable.
-     */
-    reactionRequiresObservable?: boolean;
-    /**
-     * Warn if observables are accessed outside a reactive context
-     */
-    observableRequiresReaction?: boolean;
-    isolateGlobalState?: boolean;
-    disableErrorBoundaries?: boolean;
-    safeDescriptors?: boolean;
-    reactionScheduler?: (f: () => void) => void;
-    useProxies?: "always" | "never" | "ifavailable";
-}): void;
+export declare function configure(options: {
+    enforceActions?: "never" | "always" | "observed";
+    computedRequiresReaction?: boolean;
+    /**
+     * Warn if you try to create to derivation / reactive context without accessing any observable.
+     */
+    reactionRequiresObservable?: boolean;
+    /**
+     * Warn if observables are accessed outside a reactive context
+     */
+    observableRequiresReaction?: boolean;
+    isolateGlobalState?: boolean;
+    disableErrorBoundaries?: boolean;
+    safeDescriptors?: boolean;
+    reactionScheduler?: (f: () => void) => void;
+    useProxies?: "always" | "never" | "ifavailable";
+}): void;

package/dist/api/decorators.d.ts

@@ -1,17 +1,20 @@
-import { Annotation, AnnotationsMap } from "../internal";
-export declare const storedAnnotationsSymbol: unique symbol;
-/**
- * Creates a function that acts as
- * - decorator
- * - annotation object
- */
-export declare function createDecoratorAnnotation(annotation: Annotation): PropertyDecorator & Annotation;
-/**
- * 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>;
+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/extendobservable.d.ts

@@ -1,2 +1,2 @@
-import { CreateObservableOptions, AnnotationsMap } from "../internal";
-export declare function extendObservable<A extends Object, B extends Object>(target: A, properties: B, annotations?: AnnotationsMap<B, never>, options?: CreateObservableOptions): A & B;
+import { CreateObservableOptions, AnnotationsMap } from "../internal";
+export declare function extendObservable<A extends Object, B extends Object>(target: A, properties: B, annotations?: AnnotationsMap<B, never>, options?: CreateObservableOptions): A & B;

package/dist/api/extras.d.ts

@@ -1,10 +1,10 @@
-export interface IDependencyTree {
-    name: string;
-    dependencies?: IDependencyTree[];
-}
-export interface IObserverTree {
-    name: string;
-    observers?: IObserverTree[];
-}
-export declare function getDependencyTree(thing: any, property?: string): IDependencyTree;
-export declare function getObserverTree(thing: any, property?: string): IObserverTree;
+export interface IDependencyTree {
+    name: string;
+    dependencies?: IDependencyTree[];
+}
+export interface IObserverTree {
+    name: string;
+    observers?: IObserverTree[];
+}
+export declare function getDependencyTree(thing: any, property?: string): IDependencyTree;
+export declare function getObserverTree(thing: any, property?: string): IObserverTree;

package/dist/api/flow.d.ts

@@ -1,18 +1,19 @@
-import { Annotation } from "../internal";
-export declare const FLOW = "flow";
-export declare function FlowCancellationError(): void;
-export declare namespace FlowCancellationError {
-    var prototype: any;
-}
-export declare function isFlowCancellationError(error: Error): boolean;
-export declare type CancellablePromise<T> = Promise<T> & {
-    cancel(): void;
-};
-interface Flow extends Annotation, PropertyDecorator {
-    <R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;
-    bound: Annotation & PropertyDecorator;
-}
-export declare const flow: Flow;
-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 {};
+import { Annotation } from "../internal";
+import type { ClassMethodDecorator } from "../types/decorator_fills";
+export declare const FLOW = "flow";
+export declare function FlowCancellationError(): void;
+export declare namespace FlowCancellationError {
+    var prototype: any;
+}
+export declare function isFlowCancellationError(error: Error): boolean;
+export type CancellablePromise<T> = Promise<T> & {
+    cancel(): void;
+};
+interface Flow extends Annotation, PropertyDecorator, ClassMethodDecorator {
+    <R, Args extends any[]>(generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>): (...args: Args) => CancellablePromise<R>;
+    bound: Annotation & PropertyDecorator & ClassMethodDecorator;
+}
+export declare const flow: Flow;
+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/intercept-read.d.ts

@@ -1,8 +1,8 @@
-import { IObservableArray, IObservableValue, Lambda, ObservableMap, ObservableSet } from "../internal";
-export declare type ReadInterceptor<T> = (value: any) => T;
-/** Experimental feature right now, tested indirectly via Mobx-State-Tree */
-export declare function interceptReads<T>(value: IObservableValue<T>, handler: ReadInterceptor<T>): Lambda;
-export declare function interceptReads<T>(observableArray: IObservableArray<T>, handler: ReadInterceptor<T>): Lambda;
-export declare function interceptReads<K, V>(observableMap: ObservableMap<K, V>, handler: ReadInterceptor<V>): Lambda;
-export declare function interceptReads<V>(observableSet: ObservableSet<V>, handler: ReadInterceptor<V>): Lambda;
-export declare function interceptReads(object: Object, property: string, handler: ReadInterceptor<any>): Lambda;
+import { IObservableArray, IObservableValue, Lambda, ObservableMap, ObservableSet } from "../internal";
+export type ReadInterceptor<T> = (value: any) => T;
+/** Experimental feature right now, tested indirectly via Mobx-State-Tree */
+export declare function interceptReads<T>(value: IObservableValue<T>, handler: ReadInterceptor<T>): Lambda;
+export declare function interceptReads<T>(observableArray: IObservableArray<T>, handler: ReadInterceptor<T>): Lambda;
+export declare function interceptReads<K, V>(observableMap: ObservableMap<K, V>, handler: ReadInterceptor<V>): Lambda;
+export declare function interceptReads<V>(observableSet: ObservableSet<V>, handler: ReadInterceptor<V>): Lambda;
+export declare function interceptReads(object: Object, property: string, handler: ReadInterceptor<any>): Lambda;

package/dist/api/intercept.d.ts

@@ -1,8 +1,8 @@
-import { IArrayWillChange, IArrayWillSplice, IInterceptor, IMapWillChange, IObjectWillChange, IObservableArray, IObservableValue, IValueWillChange, Lambda, ObservableMap, ObservableSet, ISetWillChange } from "../internal";
-export declare function intercept<T>(value: IObservableValue<T>, handler: IInterceptor<IValueWillChange<T>>): Lambda;
-export declare function intercept<T>(observableArray: IObservableArray<T> | Array<T>, handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
-export declare function intercept<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
-export declare function intercept<V>(observableSet: ObservableSet<V> | Set<V>, handler: IInterceptor<ISetWillChange<V>>): Lambda;
-export declare function intercept<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, property: K, handler: IInterceptor<IValueWillChange<V>>): Lambda;
-export declare function intercept(object: object, handler: IInterceptor<IObjectWillChange>): Lambda;
-export declare function intercept<T extends object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<T[K]>>): Lambda;
+import { IArrayWillChange, IArrayWillSplice, IInterceptor, IMapWillChange, IObjectWillChange, IObservableArray, IObservableValue, IValueWillChange, Lambda, ObservableMap, ObservableSet, ISetWillChange } from "../internal";
+export declare function intercept<T>(value: IObservableValue<T>, handler: IInterceptor<IValueWillChange<T>>): Lambda;
+export declare function intercept<T>(observableArray: IObservableArray<T> | Array<T>, handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>): Lambda;
+export declare function intercept<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, handler: IInterceptor<IMapWillChange<K, V>>): Lambda;
+export declare function intercept<V>(observableSet: ObservableSet<V> | Set<V>, handler: IInterceptor<ISetWillChange<V>>): Lambda;
+export declare function intercept<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, property: K, handler: IInterceptor<IValueWillChange<V>>): Lambda;
+export declare function intercept(object: object, handler: IInterceptor<IObjectWillChange>): Lambda;
+export declare function intercept<T extends object, K extends keyof T>(object: T, property: K, handler: IInterceptor<IValueWillChange<T[K]>>): Lambda;

package/dist/api/iscomputed.d.ts

@@ -1,3 +1,3 @@
-export declare function _isComputed(value: any, property?: PropertyKey): boolean;
-export declare function isComputed(value: any): boolean;
-export declare function isComputedProp(value: any, propName: PropertyKey): boolean;
+export declare function _isComputed(value: any, property?: PropertyKey): boolean;
+export declare function isComputed(value: any): boolean;
+export declare function isComputedProp(value: any, propName: PropertyKey): boolean;

package/dist/api/isobservable.d.ts

@@ -1,2 +1,2 @@
-export declare function isObservable(value: any): boolean;
-export declare function isObservableProp(value: any, propName: PropertyKey): boolean;
+export declare function isObservable(value: any): boolean;
+export declare function isObservableProp(value: any, propName: PropertyKey): boolean;

package/dist/api/makeObservable.d.ts

@@ -1,6 +1,6 @@
-import { AnnotationsMap, CreateObservableOptions } from "../internal";
-declare type NoInfer<T> = [T][T extends any ? 0 : never];
-declare 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 {};
+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 {};

package/dist/api/object-api.d.ts

@@ -1,36 +1,36 @@
-import { IObservableArray, ObservableMap, ObservableSet } from "../internal";
-export declare function keys<K>(map: ObservableMap<K, any>): ReadonlyArray<K>;
-export declare function keys<T>(ar: IObservableArray<T>): ReadonlyArray<number>;
-export declare function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>;
-export declare function keys<T extends Object>(obj: T): ReadonlyArray<PropertyKey>;
-export declare function values<K, T>(map: ObservableMap<K, T>): ReadonlyArray<T>;
-export declare function values<T>(set: ObservableSet<T>): ReadonlyArray<T>;
-export declare function values<T>(ar: IObservableArray<T>): ReadonlyArray<T>;
-export declare function values<T = any>(obj: T): ReadonlyArray<T extends object ? T[keyof T] : any>;
-export declare function entries<K, T>(map: ObservableMap<K, T>): ReadonlyArray<[K, T]>;
-export declare function entries<T>(set: ObservableSet<T>): ReadonlyArray<[T, T]>;
-export declare function entries<T>(ar: IObservableArray<T>): ReadonlyArray<[number, T]>;
-export declare function entries<T = any>(obj: T): ReadonlyArray<[string, T extends object ? T[keyof T] : any]>;
-export declare function set<V>(obj: ObservableMap<PropertyKey, V>, values: {
-    [key: string]: V;
-}): any;
-export declare function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
-export declare function set<T>(obj: ObservableSet<T>, value: T): any;
-export declare function set<T>(obj: IObservableArray<T>, index: number, value: T): any;
-export declare function set<T extends Object>(obj: T, values: {
-    [key: string]: any;
-}): any;
-export declare function set<T extends Object>(obj: T, key: PropertyKey, value: any): any;
-export declare function remove<K, V>(obj: ObservableMap<K, V>, key: K): any;
-export declare function remove<T>(obj: ObservableSet<T>, key: T): any;
-export declare function remove<T>(obj: IObservableArray<T>, index: number): any;
-export declare function remove<T extends Object>(obj: T, key: string): any;
-export declare function has<K>(obj: ObservableMap<K, any>, key: K): boolean;
-export declare function has<T>(obj: ObservableSet<T>, key: T): boolean;
-export declare function has<T>(obj: IObservableArray<T>, index: number): boolean;
-export declare function has<T extends Object>(obj: T, key: string): boolean;
-export declare function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined;
-export declare function get<T>(obj: IObservableArray<T>, index: number): T | undefined;
-export declare function get<T extends Object>(obj: T, key: string): any;
-export declare function apiDefineProperty(obj: Object, key: PropertyKey, descriptor: PropertyDescriptor): any;
-export declare function apiOwnKeys(obj: Object): any;
+import { IObservableArray, ObservableMap, ObservableSet } from "../internal";
+export declare function keys<K>(map: ObservableMap<K, any>): ReadonlyArray<K>;
+export declare function keys<T>(ar: IObservableArray<T>): ReadonlyArray<number>;
+export declare function keys<T>(set: ObservableSet<T>): ReadonlyArray<T>;
+export declare function keys<T extends Object>(obj: T): ReadonlyArray<PropertyKey>;
+export declare function values<K, T>(map: ObservableMap<K, T>): ReadonlyArray<T>;
+export declare function values<T>(set: ObservableSet<T>): ReadonlyArray<T>;
+export declare function values<T>(ar: IObservableArray<T>): ReadonlyArray<T>;
+export declare function values<T = any>(obj: T): ReadonlyArray<T extends object ? T[keyof T] : any>;
+export declare function entries<K, T>(map: ObservableMap<K, T>): ReadonlyArray<[K, T]>;
+export declare function entries<T>(set: ObservableSet<T>): ReadonlyArray<[T, T]>;
+export declare function entries<T>(ar: IObservableArray<T>): ReadonlyArray<[number, T]>;
+export declare function entries<T = any>(obj: T): ReadonlyArray<[string, T extends object ? T[keyof T] : any]>;
+export declare function set<V>(obj: ObservableMap<PropertyKey, V>, values: {
+    [key: string]: V;
+}): any;
+export declare function set<K, V>(obj: ObservableMap<K, V>, key: K, value: V): any;
+export declare function set<T>(obj: ObservableSet<T>, value: T): any;
+export declare function set<T>(obj: IObservableArray<T>, index: number, value: T): any;
+export declare function set<T extends Object>(obj: T, values: {
+    [key: string]: any;
+}): any;
+export declare function set<T extends Object>(obj: T, key: PropertyKey, value: any): any;
+export declare function remove<K, V>(obj: ObservableMap<K, V>, key: K): any;
+export declare function remove<T>(obj: ObservableSet<T>, key: T): any;
+export declare function remove<T>(obj: IObservableArray<T>, index: number): any;
+export declare function remove<T extends Object>(obj: T, key: string): any;
+export declare function has<K>(obj: ObservableMap<K, any>, key: K): boolean;
+export declare function has<T>(obj: ObservableSet<T>, key: T): boolean;
+export declare function has<T>(obj: IObservableArray<T>, index: number): boolean;
+export declare function has<T extends Object>(obj: T, key: string): boolean;
+export declare function get<K, V>(obj: ObservableMap<K, V>, key: K): V | undefined;
+export declare function get<T>(obj: IObservableArray<T>, index: number): T | undefined;
+export declare function get<T extends Object>(obj: T, key: string): any;
+export declare function apiDefineProperty(obj: Object, key: PropertyKey, descriptor: PropertyDescriptor): any;
+export declare function apiOwnKeys(obj: Object): any;

package/dist/api/observable.d.ts

@@ -1,44 +1,45 @@
-import { IEnhancer, IEqualsComparer, IObservableArray, IObservableMapInitialValues, IObservableSetInitialValues, IObservableValue, ObservableMap, ObservableSet, Annotation, AnnotationsMap } from "../internal";
-export declare const OBSERVABLE = "observable";
-export declare const OBSERVABLE_REF = "observable.ref";
-export declare const OBSERVABLE_SHALLOW = "observable.shallow";
-export declare const OBSERVABLE_STRUCT = "observable.struct";
-export declare type CreateObservableOptions = {
-    name?: string;
-    equals?: IEqualsComparer<any>;
-    deep?: boolean;
-    defaultDecorator?: Annotation;
-    proxy?: boolean;
-    autoBind?: boolean;
-};
-export declare const defaultCreateObservableOptions: CreateObservableOptions;
-export declare function asCreateObservableOptions(thing: any): CreateObservableOptions;
-export declare function getEnhancerFromOptions(options: CreateObservableOptions): IEnhancer<any>;
-export declare function getAnnotationFromOptions(options?: CreateObservableOptions): Annotation | undefined;
-export declare function getEnhancerFromAnnotation(annotation?: Annotation): IEnhancer<any>;
-export interface IObservableValueFactory {
-    <T>(value: T, options?: CreateObservableOptions): IObservableValue<T>;
-    <T>(value?: T, options?: CreateObservableOptions): IObservableValue<T | undefined>;
-}
-export interface IObservableFactory extends Annotation, PropertyDecorator {
-    <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;
-    box: IObservableValueFactory;
-    array: <T = any>(initialValues?: T[], options?: CreateObservableOptions) => IObservableArray<T>;
-    set: <T = any>(initialValues?: IObservableSetInitialValues<T>, options?: CreateObservableOptions) => ObservableSet<T>;
-    map: <K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions) => ObservableMap<K, V>;
-    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;
-    /**
-     * Decorator that creates an observable converts its value (objects, maps or arrays) into a shallow observable structure
-     */
-    shallow: Annotation & PropertyDecorator;
-    deep: Annotation & PropertyDecorator;
-    struct: Annotation & PropertyDecorator;
-}
-export declare var observable: IObservableFactory;
+import { IEnhancer, IEqualsComparer, IObservableArray, IObservableMapInitialValues, IObservableSetInitialValues, IObservableValue, ObservableMap, ObservableSet, Annotation, AnnotationsMap } from "../internal";
+import type { ClassAccessorDecorator, ClassFieldDecorator } from "../types/decorator_fills";
+export declare const OBSERVABLE = "observable";
+export declare const OBSERVABLE_REF = "observable.ref";
+export declare const OBSERVABLE_SHALLOW = "observable.shallow";
+export declare const OBSERVABLE_STRUCT = "observable.struct";
+export type CreateObservableOptions = {
+    name?: string;
+    equals?: IEqualsComparer<any>;
+    deep?: boolean;
+    defaultDecorator?: Annotation;
+    proxy?: boolean;
+    autoBind?: boolean;
+};
+export declare const defaultCreateObservableOptions: CreateObservableOptions;
+export declare function asCreateObservableOptions(thing: any): CreateObservableOptions;
+export declare function getEnhancerFromOptions(options: CreateObservableOptions): IEnhancer<any>;
+export declare function getAnnotationFromOptions(options?: CreateObservableOptions): Annotation | undefined;
+export declare function getEnhancerFromAnnotation(annotation?: Annotation): IEnhancer<any>;
+export interface IObservableValueFactory {
+    <T>(value: T, options?: CreateObservableOptions): IObservableValue<T>;
+    <T>(value?: T, options?: CreateObservableOptions): IObservableValue<T | undefined>;
+}
+export interface IObservableFactory extends Annotation, PropertyDecorator, ClassAccessorDecorator, ClassFieldDecorator {
+    <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;
+    box: IObservableValueFactory;
+    array: <T = any>(initialValues?: T[], options?: CreateObservableOptions) => IObservableArray<T>;
+    set: <T = any>(initialValues?: IObservableSetInitialValues<T>, options?: CreateObservableOptions) => ObservableSet<T>;
+    map: <K = any, V = any>(initialValues?: IObservableMapInitialValues<K, V>, options?: CreateObservableOptions) => ObservableMap<K, V>;
+    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;
+}
+export declare var observable: IObservableFactory;

package/dist/api/observe.d.ts

@@ -1,8 +1,8 @@
-import { IArrayDidChange, IComputedValue, IMapDidChange, IObjectDidChange, IObservableArray, IObservableValue, IValueDidChange, Lambda, ObservableMap, ObservableSet, ISetDidChange } from "../internal";
-export declare function observe<T>(value: IObservableValue<T> | IComputedValue<T>, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<T>(observableArray: IObservableArray<T> | Array<T>, listener: (change: IArrayDidChange<T>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<V>(observableSet: ObservableSet<V> | Set<V>, listener: (change: ISetDidChange<V>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, listener: (change: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, property: K, listener: (change: IValueDidChange<V>) => void, fireImmediately?: boolean): Lambda;
-export declare function observe(object: Object, listener: (change: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
-export declare function observe<T, K extends keyof T>(object: T, property: K, listener: (change: IValueDidChange<T[K]>) => void, fireImmediately?: boolean): Lambda;
+import { IArrayDidChange, IComputedValue, IMapDidChange, IObjectDidChange, IObservableArray, IObservableValue, IValueDidChange, Lambda, ObservableMap, ObservableSet, ISetDidChange } from "../internal";
+export declare function observe<T>(value: IObservableValue<T> | IComputedValue<T>, listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<T>(observableArray: IObservableArray<T> | Array<T>, listener: (change: IArrayDidChange<T>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<V>(observableSet: ObservableSet<V> | Set<V>, listener: (change: ISetDidChange<V>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, listener: (change: IMapDidChange<K, V>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<K, V>(observableMap: ObservableMap<K, V> | Map<K, V>, property: K, listener: (change: IValueDidChange<V>) => void, fireImmediately?: boolean): Lambda;
+export declare function observe(object: Object, listener: (change: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
+export declare function observe<T, K extends keyof T>(object: T, property: K, listener: (change: IValueDidChange<T[K]>) => void, fireImmediately?: boolean): Lambda;

package/dist/api/tojs.d.ts

@@ -1,7 +1,7 @@
-/**
- * Recursively converts an observable to it's non-observable native counterpart.
- * It does NOT recurse into non-observables, these are left as they are, even if they contain observables.
- * Computed and other non-enumerable properties are completely ignored.
- * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.
- */
-export declare function toJS<T>(source: T, options?: any): T;
+/**
+ * Recursively converts an observable to it's non-observable native counterpart.
+ * It does NOT recurse into non-observables, these are left as they are, even if they contain observables.
+ * Computed and other non-enumerable properties are completely ignored.
+ * Complex scenarios require custom solution, eg implementing `toJSON` or using `serializr` lib.
+ */
+export declare function toJS<T>(source: T, options?: any): T;

package/dist/api/trace.d.ts

@@ -1,3 +1,3 @@
-export declare function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): void;
-export declare function trace(thing?: any, enterBreakPoint?: boolean): void;
-export declare function trace(enterBreakPoint?: boolean): void;
+export declare function trace(thing?: any, prop?: string, enterBreakPoint?: boolean): void;
+export declare function trace(thing?: any, enterBreakPoint?: boolean): void;
+export declare function trace(enterBreakPoint?: boolean): void;