r-state-tree 0.5.0 → 0.6.0

package/dist/observables/internal/NodeMap.d.ts

@@ -13,6 +13,7 @@ declare class NodeMap<K = unknown, GraphNode extends AtomNode | SignalNode<unkno
     getOrCreate(key: K, value?: unknown): GraphNode;
     reportObserved(key: K, value?: unknown): void;
     reportChanged(key: K, value?: unknown): void;
+    keys(): Iterable<unknown>;
 }
 export declare class AtomMap<K = unknown> extends NodeMap<K, AtomNode> {
     protected createNode(): AtomNode;

package/dist/observables/internal/lookup.d.ts

@@ -7,10 +7,11 @@ export declare function getAdministration<T extends object>(obj: T): T extends S
 export declare function getSource<T>(obj: T): T;
 export declare function getAction<T extends Function>(fn: T): T;
 export declare function getObservableClassInstance<T extends object>(value: T): T;
+export declare class Observable {
+    constructor();
+}
 export declare function getObservableIfExists<T>(value: T): T | undefined;
 export declare function createObservableWithCustomAdministration<T>(value: T, Adm: new (obj: any) => Administration): T;
 export declare function getObservable<T>(value: T): T;
-export declare function isShallowObservable(obj: unknown): boolean;
-export declare function getShallowObservable<T>(value: T): T;
 export declare function isObservable(obj: unknown): boolean;
 export declare function getInternalNode(obj: object, key?: PropertyKey): any;

package/dist/observables/internal/utils.d.ts

@@ -2,7 +2,7 @@ import type { AtomNode, ComputedNode, SignalNode } from "../preact";
 export declare function defaultEquals<T>(a: T, b: T): boolean;
 export declare function isNonPrimitive(val: unknown): val is object;
 export declare function isPropertyKey(val: unknown): val is string | number | symbol;
-export type PropertyType = "action" | "computed" | "observable" | "observableShallow" | "observableSignal";
+export type PropertyType = "action" | "computed" | "observable";
 export declare function getPropertyType(key: PropertyKey, obj: object): PropertyType | null;
 export declare function getPropertyDescriptor(obj: object, key: PropertyKey): PropertyDescriptor | undefined;
 export declare function isPlainObject(value: unknown): value is object;

package/dist/observables/object.d.ts

@@ -8,6 +8,7 @@ export declare class ObjectAdministration<T extends object> extends Administrati
     valuesMap: SignalMap<PropertyKey>;
     computedMap: Map<PropertyKey, ComputedNode<T[keyof T]>>;
     types: Map<PropertyKey, PropertyType | null>;
+    isWriting: boolean;
     static proxyTraps: ProxyHandler<object>;
     constructor(source?: T);
     private get;
@@ -15,11 +16,11 @@ export declare class ObjectAdministration<T extends object> extends Administrati
     private getComputed;
     private callComputed;
     private getType;
-    protected reportObserveDeep(): void;
     reportChanged(): void;
     getNode(key?: keyof T): unknown;
-    read(key: keyof T): unknown;
-    write(key: keyof T, newValue: T[keyof T]): void;
+    read(key: keyof T, receiver?: any): unknown;
+    private explicitObservables;
+    write(key: keyof T, newValue: T[keyof T]): boolean;
     has(key: keyof T): boolean;
-    remove(key: keyof T): void;
+    remove(key: keyof T): boolean;
 }

package/dist/observables/preact.d.ts

@@ -1,9 +1,8 @@
-import { signal, Signal, batch, effect, untracked } from "@preact/signals-core";
+import { Signal, batch, effect, untracked } from "@preact/signals-core";
 import type { ReadonlySignal } from "@preact/signals-core";
 import { ObjectAdministration } from "./object";
 export { isObservable } from "./index";
 export declare class PreactObjectAdministration<T extends object> extends ObjectAdministration<T> {
-    static proxyTraps: ProxyHandler<object>;
 }
 export interface AtomNode {
     reportObserved(): void;
@@ -40,7 +39,7 @@ export declare function createObservedAtom(): {
 };
 export declare function createSignal<T>(initialValue: T): SignalNode<T>;
 export declare function createAtom(): AtomNode;
-export { effect, signal, batch, untracked, Signal };
+export { effect, batch, untracked, Signal };
 export type { ReadonlySignal };
 export declare function reaction<T>(fn: () => T, callback: (value: T) => void): () => void;
 export type Listener = {
@@ -51,27 +50,12 @@ export type Listener = {
 };
 export declare function createListener(callback: (listener: Listener) => void): Listener;
 export declare function createComputed<T>(fn: () => T, context?: unknown): ComputedNode<T>;
-export type PreactObservable<T> = T extends Function ? T : T extends Map<infer K, infer V> ? Map<K, PreactObservable<V>> : T extends Array<infer V> ? Array<PreactObservable<V>> : T extends Set<infer V> ? Set<PreactObservable<V>> : T extends WeakSet<infer V> ? WeakSet<PreactObservable<V>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, PreactObservable<V>> : {
-    [key in keyof T]: T[key] extends object ? PreactObservable<T[key]> : T[key];
-} & {
-    readonly [key in keyof T as T[key] extends object ? never : `$${string & key}`]?: Signal<T[key]>;
-};
-declare function observableImpl<T>(obj: T): PreactObservable<T>;
-declare function observableImpl(value: undefined, context: ClassFieldDecoratorContext): void;
-declare function shallowDecorator(value: any, context: ClassFieldDecoratorContext): any;
-declare function signalDecorator(value: any, context: ClassFieldDecoratorContext): any;
-export declare const observable: typeof observableImpl & {
-    shallow: typeof shallowDecorator;
-    signal: typeof signalDecorator;
-};
+export type PreactObservable<T> = T;
+export declare function observable<T>(obj: T): PreactObservable<T>;
+export declare function signal<T>(value: T): Signal<T>;
 export declare function computed<T>(value: () => T, context: ClassGetterDecoratorContext): void;
 export declare function computed<T>(fn: () => T): ReadonlySignal<T>;
 export declare function source<T>(obj: PreactObservable<T> | T): T;
-export declare class Observable {
-    constructor();
-}
 export declare function reportChanged<T extends object>(obj: T): T;
-export declare function reportObserved<T extends object>(obj: T, opts?: {
-    deep?: boolean;
-}): T;
+export declare function reportObserved<T extends object>(obj: T): T;
 export declare function getSignal<T extends object>(obj: T, key: keyof T): Signal<T[keyof T]>;