r-state-tree 0.4.0 → 0.4.2

package/README.md

@@ -1,6 +1,10 @@
 # r-state-tree
 
-Reactive state management featuring store trees, computed child stores, and snapshot utilities backed by `@preact/signals-core`.
+r-state-tree is a reactive state management library for building complex applications by moving state out of your render tree.
+
+- Stores hold application/view state as a tree and drive your UI.
+- Models hold domain state as a separate tree with snapshots, identifiers and references.
+- Views become dumb renderers that react to Stores/Models.
 
 ## Installation
 
@@ -14,6 +18,13 @@ This library uses [TC39 Stage 3 Decorators](https://github.com/tc39/proposal-dec
 
 The library includes a decorator metadata polyfill for runtimes that don't yet natively support `Symbol.metadata`.
 
+## Core concepts
+
+- Stores: application/view state containers. Create with `createStore()`, attach with `mount()`. Compose with `@child` (single or arrays, stable via `{ key }`). React to changes with `effect`/`reaction` and store lifecycles (`storeDidMount`/`storeWillUnmount`). Update reactive `props` via `updateStore()`.
+- Models: domain state containers. Create with `Model.create()`. Persistent via snapshots (`toSnapshot`, `applySnapshot`, `onSnapshot`, diffs via `onSnapshotDiff`). Structure with `@state`, `@child`, identifiers via `@id`, and references via `@modelRef`.
+- Context: pass data through Store/Model trees without prop drilling using `createContext<T>()`, `[Context.provide]`, and `Context.consume(this)`. Context is reactive and can be overridden by descendants.
+- Reactivity: powered by signals. Use `@observable`, `@computed`, `effect`, `reaction`, `batch`, and `untracked` for precise updates.
+
 ## Stores
 
 Stores describe reactive state containers composed into a tree.
@@ -51,15 +62,15 @@ updateStore(app.todo, { title: "Ship release" });
 
 ### Child stores
 
-Use `@child` for single child stores and `@children` for arrays.
+Use `@child` for both single child stores and arrays.
 
 ```ts
-import { child, children } from "r-state-tree";
+import { child } from "r-state-tree";
 
 class ListStore extends Store {
 	items = ["Buy milk", "Walk dog"];
 
-	@children get todos() {
+	@child get todos() {
 		return this.items.map((title, i) =>
 			createStore(TodoStore, { title, key: i })
 		);
@@ -143,6 +154,44 @@ batch(() => {
 });
 ```
 
+## Modeling guide
+
+- Root store: mount a single root Store that composes the application via `@child` properties.
+- View stores: create one Store per view/route/tab. Views render from stores; stores drive view transitions.
+- Keyed children: pass `{ key }` when creating child stores to preserve identity across reorders.
+- Models in stores: pass domain Models via `{ models }` and consume with `@model` on the Store.
+
+```ts
+import { Store, Model, child, createStore, mount } from "r-state-tree";
+
+class TabViewStore extends Store<{ title: string }> {}
+
+class RootStore extends Store {
+	@child get tabs() {
+		return ["Home", "Profile"].map((title, i) =>
+			createStore(TabViewStore, { title, key: i })
+		);
+	}
+}
+
+const root = mount(createStore(RootStore));
+```
+
+Passing models into stores:
+
+```ts
+class User extends Model {
+	// ... @id, @state, etc.
+}
+
+class ProfileStore extends Store {
+	@model user: User; // injected model
+}
+
+const user = User.create({ id: 1, name: "Alice" });
+const profile = mount(createStore(ProfileStore, { models: { user } }));
+```
+
 ## Observable classes
 
 For reactive class instances outside the Model/Store system, use `@observable` and `@computed` decorators:
@@ -190,6 +239,61 @@ effect(() => {
 state.count++; // Triggers the effect
 ```
 
+## Observables (low‑level)
+
+Create reactive structures outside Stores/Models. Supported: Objects, Arrays, Map, Set, WeakMap, WeakSet.
+
+- Track reads with `effect`/`reaction`. Nested values are tracked when you access them inside your effects.
+- Access raw values via `source(observable)`; check if something is reactive with `isObservable(value)`.
+- Arrays: reading specific indices (`arr[i]`) or `length` tracks those; common mutators (`push/pop/shift/unshift/splice/reverse/sort/fill`) are reactive; non-index and symbol keys are not reactive.
+
+```ts
+import { observable, effect, computed, reaction } from "r-state-tree";
+
+// Object
+const state = observable({ count: 0, nested: { value: 1 } });
+
+effect(() => {
+	// tracks reads
+	state.count;
+	state.nested.value;
+});
+
+state.count++;
+state.nested.value++;
+
+// Computed
+const doubled = computed(() => state.count * 2);
+effect(() => {
+	doubled.value;
+});
+
+// Array
+const arr = observable([0, 1]);
+effect(() => arr[0]);
+arr[0]++; // triggers; arr.push(2) does not, index 0 didn't change
+
+// Map
+const map = observable(new Map([["k", 1]]));
+effect(() => map.get("k"));
+map.set("k", 2); // triggers
+
+// Set
+const set = observable(new Set([1]));
+effect(() => set.has(2));
+set.add(2); // triggers
+
+// Reaction (runs only on changes, skips initial)
+let last: number | undefined;
+reaction(
+	() => state.count,
+	(v) => {
+		last = v;
+	}
+);
+state.count++;
+```
+
 ## Models and snapshots
 
 Models capture persistent state with snapshot utilities.
@@ -198,14 +302,14 @@ Models capture persistent state with snapshot utilities.
 import {
 	Model,
 	state,
-	identifier,
+	id,
 	applySnapshot,
 	onSnapshot,
 	toSnapshot,
 } from "r-state-tree";
 
 class TodoModel extends Model {
-	@identifier id = 0;
+	@id id = 0;
 	@state title = "";
 	@state completed = false;
 }
@@ -220,44 +324,72 @@ todo.title = "Learn r-state-tree";
 stop();
 ```
 
+### Model lifecycle hooks
+
+Models support lifecycle methods:
+
+```ts
+class TodoModel extends Model {
+	@child tags: TagModel[] = [];
+
+	modelDidInit(snapshot?, ...args: unknown[]) {
+		// Called when model is created via Model.create()
+		// Receives the snapshot and any additional arguments passed to create()
+		console.log("Model initialized", snapshot);
+	}
+
+	modelDidAttach() {
+		// Called when this model is attached as a child to another model
+		console.log("Model attached to parent");
+	}
+
+	modelWillDetach() {
+		// Called when this model is detached from its parent
+		console.log("Model will be detached");
+	}
+}
+```
+
 ### Model decorators
 
 Use decorators to configure model properties:
 
 ```ts
-import {
-	Model,
-	state,
-	identifier,
-	child,
-	children,
-	modelRef,
-	modelRefs,
-} from "r-state-tree";
+import { Model, state, id, child, modelRef } from "r-state-tree";
 
 class User extends Model {
-	@identifier id = 0;
+	@id id = 0;
 	@state name = "";
 }
 
 class TodoModel extends Model {
-	@identifier id = 0;
+	@id id = 0;
 	@state title = "";
 	@modelRef assignee?: User; // Reference to another model by ID
 	@child metadata = MetadataModel.create(); // Nested child model
-	@children tags: TagModel[] = []; // Array of child models
+	@child tags: TagModel[] = []; // Array of child models
+}
+```
+
+The `@child` and `@modelRef` decorators support both single values and arrays. You can also specify the child type using `@child(ChildType)`:
+
+```ts
+class TodoModel extends Model {
+	@child(TagModel) tags: TagModel[] = []; // Type-safe array of child models
+	@child(TagModel) primaryTag: TagModel | null = null; // Can switch between single and array at runtime
 }
 ```
 
 ### Model references
 
-Reference models by ID using `@modelRef` and `@modelRefs`:
+Reference models by ID using `@modelRef`:
 
 ```ts
 class ProjectModel extends Model {
-	@identifier id = 0;
-	@children users: User[] = [];
-	@modelRef owner?: User;
+	@id id = 0;
+	@child users: User[] = [];
+	@modelRef owner?: User; // Single reference
+	@modelRef assignees: User[] = []; // Array of references
 
 	assignOwner(userId: number) {
 		// Find user by ID and set as owner
@@ -278,6 +410,81 @@ const project = ProjectModel.create({
 project.owner?.name; // "Alice"
 ```
 
+Both `@child` and `@modelRef` support runtime type switching between single values and arrays:
+
+```ts
+class ItemModel extends Model {
+	@id id = 0;
+	@state value = 0;
+}
+
+class ContainerModel extends Model {
+	@child(ItemModel) items: ItemModel | ItemModel[]; // Can be single or array
+
+	setSingle() {
+		this.items = ItemModel.create({ id: 1, value: 10 });
+	}
+
+	setArray() {
+		this.items = [
+			ItemModel.create({ id: 2, value: 20 }),
+			ItemModel.create({ id: 3, value: 30 }),
+		];
+	}
+}
+```
+
+## API surface
+
+- Stores
+  - `Store`, `createStore`, `mount`, `unmount`, `updateStore`
+- Models
+  - `Model`, decorators: `@state`, `@id`, `@child`, `@modelRef`
+- Snapshots
+  - `onSnapshot`, `toSnapshot`, `applySnapshot`, `onSnapshotDiff`
+  - Types: `Snapshot`, `SnapshotDiff`, `IdType`, `Configuration`
+- Context
+  - `createContext`, type `Context`
+- Reactivity and observables
+  - `observable`, `computed`, `effect`, `reaction`, `batch`, `untracked`, `Observable`
+  - Utilities: `isObservable`, `source`, `reportObserved`, `reportChanged`
+- Signals interop
+  - `signal`, `getSignal`, types `Signal`, `ReadonlySignal`
+
+## UI integration and signals interop
+
+r-state-tree is built on `@preact/signals-core`. You can interoperate with signals directly:
+
+- Per-property signals via `$prop` on observable objects (including Stores/Models), or `getSignal(obj, key)`.
+- Re-exported utilities: `signal`, `computed`, `effect`, `batch`, `untracked`, and types `Signal`, `ReadonlySignal`.
+
+```ts
+import { observable, effect, getSignal } from "r-state-tree";
+
+const state = observable({ count: 0 });
+
+// Either form returns a Signal<number>
+const s1 = state.$count;
+const s2 = getSignal(state, "count");
+
+effect(() => {
+	// Use s1.value (or s2.value) in your UI binding
+	console.log("count:", s1.value);
+});
+
+// Update via signal or through the object
+s1.value = 1;
+state.count = 2;
+```
+
+### Identifier and reference rules
+
+- `@id` values are unique within a tree. They cannot be cleared to `undefined` after assignment.
+- Identifiers can be reassigned to a new value (including in snapshots) as long as uniqueness is preserved.
+- `@modelRef` requires the referenced model to have an id and be attached to the tree; the ref becomes `undefined` when the model detaches.
+- When a model is re-attached to the same tree, compatible refs restore automatically; attaching to a different root does not restore prior refs.
+- `@modelRef` and `@child` can switch between single and array at runtime; reactions observe the property itself rather than internal array mutations.
+
 ### Snapshot diffs
 
 Use `onSnapshotDiff` to receive undo/redo payloads:

package/dist/api.d.ts

@@ -0,0 +1,9 @@
+import { Snapshot, SnapshotDiff } from "./types";
+import Store from "./store/Store";
+import Model from "./model/Model";
+export declare function mount<T extends Store>(container: T): T;
+export declare function unmount<S extends Store>(container: S): void;
+export declare function toSnapshot<T extends Model>(model: T): Snapshot<T>;
+export declare function onSnapshot<T extends Model>(model: T, callback: (snapshot: Snapshot<T>, model: T) => void): () => void;
+export declare function onSnapshotDiff<T extends Model>(model: T, callback: (snapshotDiff: SnapshotDiff<T>, model: T) => void): () => void;
+export declare function applySnapshot<T extends Model>(model: T, snapshot: Snapshot<T>): T;

package/dist/computedProxy.d.ts

@@ -0,0 +1,2 @@
+import { ComputedNode } from "./observables";
+export default function <T extends Record<PropertyKey, any>>(computed: ComputedNode<T>): T;

package/dist/context.d.ts

@@ -0,0 +1,13 @@
+import type Model from "./model/Model";
+import type Store from "./store/Store";
+declare const CONTEXT_SYMBOL: unique symbol;
+declare const HAS_DEFAULT: unique symbol;
+export interface Context<T> {
+    readonly [CONTEXT_SYMBOL]: symbol;
+    readonly [HAS_DEFAULT]: boolean;
+    readonly defaultValue: T | undefined;
+    readonly provide: symbol;
+    consume(instance: Model | Store): T;
+}
+export declare function createContext<T>(defaultValue?: T): Context<T>;
+export {};

package/dist/decorators.d.ts

@@ -0,0 +1,6 @@
+import "@tsmetadata/polyfill";
+export declare const child: any;
+export declare const modelRef: any;
+export declare const model: any;
+export declare const id: any;
+export declare const state: any;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import "@tsmetadata/polyfill";
+import Store, { createStore, updateStore } from "./store/Store";
+import Model from "./model/Model";
+import { mount, unmount, onSnapshot, toSnapshot, applySnapshot, onSnapshotDiff } from "./api";
+import { createContext } from "./context";
+export { createStore, Store, Model, mount, unmount, updateStore, onSnapshot, onSnapshotDiff, toSnapshot, applySnapshot, createContext, };
+export { observable, computed, source, reportChanged, reportObserved, getSignal, isObservable, reaction, Signal, ReadonlySignal, batch, untracked, effect, Observable, signal, } from "./observables";
+export * from "./decorators";
+export type { Configuration, Snapshot, IdType, SnapshotDiff } from "./types";
+export type { Context } from "./context";

package/dist/model/ChildModelsAdministration.d.ts

@@ -0,0 +1,35 @@
+import { ArrayAdministration } from "../observables";
+export declare function notifyArrayUpdate<T>(arr: T[], index: number, oldValue: T, newValue: T): void;
+export declare function notifySpliceArray<T>(arr: T[], index: number, added: T[], removed: T[]): void;
+export declare function observe<T>(obj: object, method: MutationListener<T>): () => void;
+export type UpdateArrayEvent<T> = {
+    object: T[];
+    type: "updateArray";
+    index: number;
+    oldValue: T;
+    newValue: T;
+};
+export type SpliceArrayEvent<T> = {
+    object: T[];
+    type: "spliceArray";
+    index: number;
+    added: T[];
+    removed: T[];
+};
+export type MutationEvent<T> = UpdateArrayEvent<T> | SpliceArrayEvent<T>;
+export type MutationListener<T> = (ev: MutationEvent<T>) => void;
+export type HasListener<T> = {
+    listener: ObservableListener<T>;
+};
+declare class ObservableListener<T> {
+    private listeners;
+    private notifying;
+    subscribe(l: MutationListener<T>): () => void;
+    get size(): number;
+    notify(ev: MutationEvent<T>): void;
+}
+export declare class ChildModelsAdministration<T> extends ArrayAdministration<T> {
+    set(index: number, newValue: T): void;
+    spliceWithArray(index: number, deleteCount?: number | undefined, newItems?: T[] | undefined): T[];
+}
+export {};

package/dist/model/Model.d.ts

@@ -0,0 +1,17 @@
+import { ModelConfiguration, Snapshot } from "../types";
+type ExtractModelDidInitArgs<T extends Model> = T extends {
+    modelDidInit(...args: infer Args): unknown;
+} ? Args extends [infer Snapshot, ...infer Rest] ? Rest : [] : [];
+export default class Model {
+    static get types(): ModelConfiguration<unknown>;
+    static childTypes: object;
+    static create<T extends Model = Model>(this: {
+        new (...args: unknown[]): T;
+    }, snapshot?: Snapshot<T>, ...args: ExtractModelDidInitArgs<T>): T;
+    constructor();
+    get parent(): Model | null;
+    modelDidInit(snapshot?: Snapshot<this>, ...args: unknown[]): void;
+    modelDidAttach(): void;
+    modelWillDetach(): void;
+}
+export {};

package/dist/model/ModelAdministration.d.ts

@@ -0,0 +1,42 @@
+import { PreactObjectAdministration, ComputedNode, AtomNode } from "../observables";
+import Model from "../model/Model";
+import { ModelConfiguration, Snapshot, SnapshotChange } from "../types";
+export declare function getConfigurationFromSnapshot(snapshot: object): ModelConfiguration<unknown> | undefined;
+export declare function getModelAdm<T extends Model>(model: T): ModelAdministration;
+export declare class ModelAdministration extends PreactObjectAdministration<any> {
+    static proxyTraps: ProxyHandler<object>;
+    private configurationGetter?;
+    private _parent;
+    private parentAtom;
+    referencedAtoms: Map<PropertyKey, AtomNode>;
+    referencedModels: Map<PropertyKey, ComputedNode<Model[]>>;
+    activeModels: Set<PropertyKey>;
+    root: ModelAdministration;
+    private modelsTraceUnsub;
+    private writeInProgress;
+    private computedSnapshot;
+    private snapshotMap;
+    private contextCache;
+    parentName: PropertyKey | null;
+    get parent(): ModelAdministration | null;
+    set parent(value: ModelAdministration | null);
+    setConfiguration(configurationGetter: () => ModelConfiguration<any>): void;
+    private get configuration();
+    private getReferencedAtom;
+    private setState;
+    private setId;
+    private setModel;
+    private setModels;
+    private getModelRef;
+    private getModelRefs;
+    private setModelRef;
+    private setModelRefs;
+    private attach;
+    private detach;
+    getContextValue<T>(contextId: symbol, provideSymbol: symbol, defaultValue: T | undefined, hasDefault: boolean): T;
+    private lookupContextValue;
+    private toJSON;
+    onSnapshotChange(onChange: SnapshotChange<any>): () => void;
+    loadSnapshot(snapshot: Snapshot<any>): void;
+    getSnapshot(): Snapshot<any>;
+}

package/dist/model/idMap.d.ts

@@ -0,0 +1,8 @@
+import { IdType } from "../types";
+import Model from "./Model";
+export declare function onSnapshotLoad<T>(fn: () => T): T;
+export declare function setIdentifier(model: Model, id: string | number): void;
+export declare function getIdentifier(model: Model): IdType | undefined;
+export declare function getModelById(root: Model, id: IdType): Model | undefined;
+export declare function onModelAttached(model: Model): void;
+export declare function onModelDetached(model: Model): void;

package/dist/observables/array.d.ts

@@ -0,0 +1,21 @@
+import { AtomNode } from "./preact";
+import { Administration } from "./internal/Administration";
+import { SignalMap } from "./internal/NodeMap";
+export declare class ArrayAdministration<T> extends Administration<T[]> {
+    valuesMap: SignalMap<number>;
+    keysAtom: AtomNode;
+    static proxyTraps: ProxyHandler<Array<unknown>>;
+    static methods: Partial<{
+        [K in keyof typeof Array.prototype as (typeof Array.prototype)[K] extends Function ? K : never]: (typeof Array.prototype)[K];
+    }>;
+    constructor(source?: T[]);
+    protected reportObserveDeep(): void;
+    getNode(key?: number): unknown;
+    get(index: number): T | undefined;
+    set(index: number, newValue: T): void;
+    getArrayLength(): number;
+    setArrayLength(newLength: number): void;
+    spliceWithArray(index: number, deleteCount?: number, newItems?: T[]): T[];
+    spliceItemsIntoValues(index: number, deleteCount: number, newItems: T[]): T[];
+    onArrayChanged(lengthChanged?: boolean, index?: number, count?: number): void;
+}

package/dist/observables/collection.d.ts

@@ -0,0 +1,43 @@
+import { AtomNode } from "./preact";
+import { Administration } from "./internal/Administration";
+import { AtomMap, SignalMap } from "./internal/NodeMap";
+type Collection<K, V> = Set<K> | Map<K, V>;
+export declare class CollectionAdministration<K, V = K> extends Administration<Collection<K, V>> {
+    isMap: boolean;
+    hasMap: AtomMap<K>;
+    valuesMap: SignalMap<K>;
+    keysAtom: AtomNode;
+    static proxyTraps: ProxyHandler<Set<unknown> | Map<unknown, unknown>>;
+    static methods: {
+        clear: (this: any) => unknown;
+        forEach: (this: any) => unknown;
+        has: (this: any) => unknown;
+        add: (this: any) => unknown;
+        set: (this: any) => unknown;
+        get: (this: any) => unknown;
+        delete: (this: any) => unknown;
+        entries: (this: any) => unknown;
+        keys: (this: any) => unknown;
+        values: (this: any) => unknown;
+        [Symbol.iterator]: (this: any) => unknown;
+    };
+    constructor(source: Collection<K, V>);
+    private hasEntry;
+    private onCollectionChange;
+    protected reportObserveDeep(): void;
+    getNode(key?: K): unknown;
+    clear(): void;
+    forEach(callbackFn: (value: V, key: K, collection: Collection<K, V>) => void, thisArg?: unknown): void;
+    get size(): number;
+    add(value: K): this;
+    delete(value: K): boolean;
+    has(value: K): boolean;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V] | V>;
+    [Symbol.toStringTag]: string;
+}
+export {};

package/dist/observables/date.d.ts

@@ -0,0 +1,4 @@
+import { Administration } from "./internal/Administration";
+export declare class DateAdministration extends Administration<Date> {
+    static proxyTraps: ProxyHandler<Date>;
+}

package/dist/observables/index.d.ts

@@ -0,0 +1,6 @@
+export { getAdministration, getSource, isObservable, getObservable, getObservableClassInstance, getInternalNode, createObservableWithCustomAdministration, } from "./internal/lookup";
+export { ArrayAdministration } from "./array";
+export { CollectionAdministration } from "./collection";
+export { DateAdministration } from "./date";
+export { ObjectAdministration } from "./object";
+export { AtomNode, reaction, SignalNode, createAtom, batch, createComputed, createSignal, untracked, ListenerNode, createListener, ComputedNode, PreactObjectAdministration, getSignal, source, reportChanged, reportObserved, observable, computed, Signal, ReadonlySignal, effect, signal, Observable, } from "./preact";

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

@@ -0,0 +1,17 @@
+import { ObservedAtomNode } from "../preact";
+import { SignalMap } from "./NodeMap";
+export declare class Administration<T extends object = any> {
+    static readonly proxyTraps: ProxyHandler<object>;
+    readonly proxy: T;
+    readonly source: T;
+    readonly atom: ObservedAtomNode;
+    protected valuesMap?: SignalMap;
+    protected isObserved: boolean;
+    private forceObservedAtoms?;
+    constructor(source: T);
+    protected flushChange(): void;
+    getNode(): unknown;
+    reportChanged(): void;
+    protected reportObserveDeep(): void;
+    reportObserved(deep?: boolean): void;
+}

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

@@ -0,0 +1,23 @@
+import { AtomNode, ObservedAtomNode, SignalNode } from "../preact";
+declare class NodeMap<K = unknown, GraphNode extends AtomNode | SignalNode<unknown> = AtomNode | SignalNode<unknown>> {
+    private map;
+    private weakMap;
+    private observedAtom?;
+    private cleanUpRegistered;
+    constructor(observedAtom?: ObservedAtomNode);
+    private registerCleanup;
+    protected createNode(_initialValue?: unknown): GraphNode;
+    get(key: unknown): GraphNode | undefined;
+    delete(key: K): void;
+    add(key: K, atom: GraphNode): void;
+    getOrCreate(key: K, value?: unknown): GraphNode;
+    reportObserved(key: K, value?: unknown): void;
+    reportChanged(key: K, value?: unknown): void;
+}
+export declare class AtomMap<K = unknown> extends NodeMap<K, AtomNode> {
+    protected createNode(): AtomNode;
+}
+export declare class SignalMap<K = unknown, V = unknown> extends NodeMap<K, SignalNode<V>> {
+    protected createNode(initialValue?: unknown): SignalNode<V>;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { CollectionAdministration } from "../collection";
+import { PreactObjectAdministration } from "../preact";
+import { ArrayAdministration } from "../array";
+import { DateAdministration } from "../date";
+import { Administration } from "./Administration";
+export declare function getAdministration<T extends object>(obj: T): T extends Set<infer S> ? CollectionAdministration<S> : T extends Map<infer K, infer V> ? CollectionAdministration<K, V> : T extends Array<infer R> ? ArrayAdministration<R> : T extends Date ? DateAdministration : PreactObjectAdministration<any>;
+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 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 isObservable(obj: unknown): boolean;
+export declare function getInternalNode(obj: object, key?: PropertyKey): any;

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

@@ -0,0 +1,9 @@
+import { 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";
+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;
+export declare function resolveNode(node: SignalNode<unknown> | AtomNode | ComputedNode<unknown>): unknown;

package/dist/observables/object.d.ts

@@ -0,0 +1,25 @@
+import { AtomNode, ComputedNode } from "./preact";
+import { PropertyType } from "./internal/utils";
+import { Administration } from "./internal/Administration";
+import { AtomMap, SignalMap } from "./internal/NodeMap";
+export declare class ObjectAdministration<T extends object> extends Administration<T> {
+    keysAtom: AtomNode;
+    hasMap: AtomMap<PropertyKey>;
+    valuesMap: SignalMap<PropertyKey>;
+    computedMap: Map<PropertyKey, ComputedNode<T[keyof T]>>;
+    types: Map<PropertyKey, PropertyType | null>;
+    static proxyTraps: ProxyHandler<object>;
+    constructor(source?: T);
+    private get;
+    private set;
+    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;
+    has(key: keyof T): boolean;
+    remove(key: keyof T): void;
+}

package/dist/observables/preact.d.ts

@@ -0,0 +1,69 @@
+import { signal, Signal, ReadonlySignal, batch, effect, untracked } 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;
+    reportChanged(val?: unknown): void;
+    node?: Signal<unknown>;
+}
+export type ObservedAtomNode = AtomNode & {
+    observing: boolean;
+    onObservedStateChange(callback: (observing: boolean) => void): () => void;
+};
+export interface SignalNode<T> {
+    reportObserved(): void;
+    reportChanged(val: T): void;
+    node?: Signal<T>;
+    get: () => T;
+    set: (value: T) => T;
+}
+export interface ComputedNode<T> {
+    get(): T;
+    node?: ReadonlySignal<T>;
+    clear: () => void;
+}
+export interface ListenerNode {
+    dispose: () => void;
+    track: <T>(trackFn: () => T) => T;
+    isDisposed: boolean;
+}
+export declare function createObservedAtom(): {
+    node: Signal<number>;
+    reportObserved(): number;
+    reportChanged(): number;
+    readonly observing: boolean;
+    onObservedStateChange(callback: (observing: boolean) => void): () => void;
+};
+export declare function createSignal<T>(initialValue: T): SignalNode<T>;
+export declare function createAtom(): AtomNode;
+export { effect, signal, batch, untracked, Signal, ReadonlySignal };
+export declare function reaction<T>(fn: () => T, callback: (value: T) => void): () => void;
+export type Listener = {
+    dispose: () => void;
+    track: <T>(trackFn: () => T) => T;
+    isDisposed: boolean;
+    callback(listener: Listener): void;
+};
+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]>;
+};
+export declare function observable<T>(obj: T): PreactObservable<T>;
+export declare function observable(value: undefined, context: ClassFieldDecoratorContext): void;
+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 getSignal<T extends object>(obj: T, key: keyof T): Signal<T[keyof T]>;

package/dist/r-state-tree.cjs

@@ -1672,13 +1672,13 @@ function onSnapshotLoad(fn) {
             rootMap.set(root, set);
           }
           if (idMap.has(model2)) {
-            const id = idMap.get(model2);
-            if (set.has(id)) {
+            const id2 = idMap.get(model2);
+            if (set.has(id2)) {
               throw new Error(
                 "r-state-tree duplicate ids detected after snapshot was loaded"
               );
             }
-            set.add(id);
+            set.add(id2);
           }
         });
       } finally {
@@ -1687,40 +1687,40 @@ function onSnapshotLoad(fn) {
     }
   }
 }
-function setIdentifier(model2, id) {
+function setIdentifier(model2, id2) {
   const prevId = idMap.get(model2);
-  idMap.set(model2, id);
+  idMap.set(model2, id2);
   if (prevId == null) {
     if (model2.parent) {
       onModelAttached(model2);
     }
-  } else if (prevId !== id) {
+  } else if (prevId !== id2) {
     updateIdentifier(model2);
   }
 }
 function getIdentifier(model2) {
   return idMap.get(model2);
 }
-function getModelById(root, id) {
+function getModelById(root, id2) {
   const map = attachedIdMap.get(root);
-  return map?.get(id);
+  return map?.get(id2);
 }
 function updateIdentifier(model2) {
-  const id = idMap.get(model2);
+  const id2 = idMap.get(model2);
   let node = model2.parent;
   while (node) {
     const map = attachedIdMap.get(node);
     if (map) {
-      map.set(id, model2);
+      map.set(id2, model2);
     }
     node = node.parent;
   }
 }
 function onModelAttached(model2) {
   const attachedMap = attachedIdMap.get(model2);
-  const id = idMap.get(model2);
-  if (attachedMap || id != null) {
-    const id2 = idMap.get(model2);
+  const id2 = idMap.get(model2);
+  if (attachedMap || id2 != null) {
+    const id22 = idMap.get(model2);
     let node = model2.parent;
     while (node) {
       let map = attachedIdMap.get(node);
@@ -1741,26 +1741,26 @@ function onModelAttached(model2) {
         }
         map.set(key, value);
       });
-      if (id2 != null) {
-        if (map.has(id2)) {
+      if (id22 != null) {
+        if (map.has(id22)) {
           if (loadingSnapshot) {
             potentialDups.add(model2);
-            potentialDups.add(map.get(id2));
+            potentialDups.add(map.get(id22));
           } else {
             throw new Error(
-              `r-state-tree: id: ${id2} is already assigned to another model`
+              `r-state-tree: id: ${id22} is already assigned to another model`
             );
           }
         }
-        map.set(id2, model2);
+        map.set(id22, model2);
       }
       node = node.parent;
     }
   }
 }
 function onModelDetached(model2) {
-  const id = idMap.get(model2);
-  if (attachedIdMap.has(model2) || id != null) {
+  const id2 = idMap.get(model2);
+  if (attachedIdMap.has(model2) || id2 != null) {
     const attachedMap = attachedIdMap.get(model2);
     let node = model2.parent;
     while (node) {
@@ -1769,8 +1769,8 @@ function onModelDetached(model2) {
         attachedMap?.forEach((value, key) => {
           map.delete(key);
         });
-        if (id != null) {
-          map.delete(id);
+        if (id2 != null) {
+          map.delete(id2);
         }
       }
       node = node.parent;
@@ -2015,13 +2015,13 @@ class ModelAdministration extends PreactObjectAdministration {
     }
   }
   setId(name, v) {
-    const id = getIdentifier(this.proxy);
-    if (id === v) {
+    const id2 = getIdentifier(this.proxy);
+    if (id2 === v) {
       return;
     }
-    if (id != null && v == null) {
+    if (id2 != null && v == null) {
       throw new Error(
-        "r-state-tree can't clear an identifier once it has already been set."
+        "r-state-tree can't clear an id once it has already been set."
       );
     }
     if (v !== void 0) {
@@ -2107,7 +2107,7 @@ class ModelAdministration extends PreactObjectAdministration {
       if (!this.referencedModels) this.referencedModels = /* @__PURE__ */ new Map();
       c = createComputed(() => {
         a.reportObserved();
-        const models = (this.source[name] || []).map((id) => getModelById(this.root.proxy, id)).filter((m) => !!m);
+        const models = (this.source[name] || []).map((id2) => getModelById(this.root.proxy, id2)).filter((m) => !!m);
         return models;
       });
       this.referencedModels.set(name, c);
@@ -2115,27 +2115,27 @@ class ModelAdministration extends PreactObjectAdministration {
     return c.get();
   }
   setModelRef(name, modelValue) {
-    let id = void 0;
+    let id2 = void 0;
     if (modelValue) {
-      id = getIdentifier(modelValue);
-      if (id == null) {
+      id2 = getIdentifier(modelValue);
+      if (id2 == null) {
         throw new Error(
           "r-state-tree: Only models with identifiers can be used as a ref"
         );
       }
     }
-    this.source[name] = id;
+    this.source[name] = id2;
     this.referencedAtoms?.get(name)?.reportChanged();
   }
   setModelRefs(name, modelValue) {
     const ids = modelValue.map((model2) => {
-      const id = getIdentifier(model2);
-      if (id == null) {
+      const id2 = getIdentifier(model2);
+      if (id2 == null) {
         throw new Error(
           "r-state-tree: Only models with identifiers can be used as a ref"
         );
       }
-      return id;
+      return id2;
     });
     this.source[name] = ids;
     this.referencedAtoms?.get(name)?.reportChanged();
@@ -2304,8 +2304,8 @@ class ModelAdministration extends PreactObjectAdministration {
                     model22 = snapshot2;
                   } else {
                     ensureChildTypes(key);
-                    const id = childType2 && getSnapshotId(snapshot2, Ctor);
-                    const foundModel = id != null ? getModelById(this.root.proxy, id) : this.proxy[key][index];
+                    const id2 = childType2 && getSnapshotId(snapshot2, Ctor);
+                    const foundModel = id2 != null ? getModelById(this.root.proxy, id2) : this.proxy[key][index];
                     const adm = foundModel && getModelAdm(foundModel);
                     if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
                       adm.loadSnapshot(snapshot2);
@@ -2322,8 +2322,8 @@ class ModelAdministration extends PreactObjectAdministration {
               model2 = value;
             } else {
               ensureChildTypes(key);
-              const id = childType2 && getSnapshotId(value, childType2);
-              if (id != null && this.proxy[key] && id === getIdentifier(this.proxy[key])) {
+              const id2 = childType2 && getSnapshotId(value, childType2);
+              if (id2 != null && this.proxy[key] && id2 === getIdentifier(this.proxy[key])) {
                 const adm = getModelAdm(this.proxy[key]);
                 adm.loadSnapshot(value);
                 model2 = this.proxy[key];
@@ -2483,7 +2483,7 @@ function makeChildDecorator(typeObj) {
 const child = makeChildDecorator(childType);
 const modelRef = makeChildDecorator(modelRefType);
 const model = makeDecorator(modelType);
-const identifier = makeDecorator(idType);
+const id = makeDecorator(idType);
 const state = makeDecorator(stateType);
 Object.defineProperty(exports, "ReadonlySignal", {
   enumerable: true,
@@ -2518,7 +2518,7 @@ exports.computed = computed;
 exports.createContext = createContext;
 exports.createStore = createStore;
 exports.getSignal = getSignal;
-exports.identifier = identifier;
+exports.id = id;
 exports.isObservable = isObservable;
 exports.model = model;
 exports.modelRef = modelRef;

package/dist/r-state-tree.js

@@ -1671,13 +1671,13 @@ function onSnapshotLoad(fn) {
             rootMap.set(root, set);
           }
           if (idMap.has(model2)) {
-            const id = idMap.get(model2);
-            if (set.has(id)) {
+            const id2 = idMap.get(model2);
+            if (set.has(id2)) {
               throw new Error(
                 "r-state-tree duplicate ids detected after snapshot was loaded"
               );
             }
-            set.add(id);
+            set.add(id2);
           }
         });
       } finally {
@@ -1686,40 +1686,40 @@ function onSnapshotLoad(fn) {
     }
   }
 }
-function setIdentifier(model2, id) {
+function setIdentifier(model2, id2) {
   const prevId = idMap.get(model2);
-  idMap.set(model2, id);
+  idMap.set(model2, id2);
   if (prevId == null) {
     if (model2.parent) {
       onModelAttached(model2);
     }
-  } else if (prevId !== id) {
+  } else if (prevId !== id2) {
     updateIdentifier(model2);
   }
 }
 function getIdentifier(model2) {
   return idMap.get(model2);
 }
-function getModelById(root, id) {
+function getModelById(root, id2) {
   const map = attachedIdMap.get(root);
-  return map?.get(id);
+  return map?.get(id2);
 }
 function updateIdentifier(model2) {
-  const id = idMap.get(model2);
+  const id2 = idMap.get(model2);
   let node = model2.parent;
   while (node) {
     const map = attachedIdMap.get(node);
     if (map) {
-      map.set(id, model2);
+      map.set(id2, model2);
     }
     node = node.parent;
   }
 }
 function onModelAttached(model2) {
   const attachedMap = attachedIdMap.get(model2);
-  const id = idMap.get(model2);
-  if (attachedMap || id != null) {
-    const id2 = idMap.get(model2);
+  const id2 = idMap.get(model2);
+  if (attachedMap || id2 != null) {
+    const id22 = idMap.get(model2);
     let node = model2.parent;
     while (node) {
       let map = attachedIdMap.get(node);
@@ -1740,26 +1740,26 @@ function onModelAttached(model2) {
         }
         map.set(key, value);
       });
-      if (id2 != null) {
-        if (map.has(id2)) {
+      if (id22 != null) {
+        if (map.has(id22)) {
           if (loadingSnapshot) {
             potentialDups.add(model2);
-            potentialDups.add(map.get(id2));
+            potentialDups.add(map.get(id22));
           } else {
             throw new Error(
-              `r-state-tree: id: ${id2} is already assigned to another model`
+              `r-state-tree: id: ${id22} is already assigned to another model`
             );
           }
         }
-        map.set(id2, model2);
+        map.set(id22, model2);
       }
       node = node.parent;
     }
   }
 }
 function onModelDetached(model2) {
-  const id = idMap.get(model2);
-  if (attachedIdMap.has(model2) || id != null) {
+  const id2 = idMap.get(model2);
+  if (attachedIdMap.has(model2) || id2 != null) {
     const attachedMap = attachedIdMap.get(model2);
     let node = model2.parent;
     while (node) {
@@ -1768,8 +1768,8 @@ function onModelDetached(model2) {
         attachedMap?.forEach((value, key) => {
           map.delete(key);
         });
-        if (id != null) {
-          map.delete(id);
+        if (id2 != null) {
+          map.delete(id2);
         }
       }
       node = node.parent;
@@ -2014,13 +2014,13 @@ class ModelAdministration extends PreactObjectAdministration {
     }
   }
   setId(name, v) {
-    const id = getIdentifier(this.proxy);
-    if (id === v) {
+    const id2 = getIdentifier(this.proxy);
+    if (id2 === v) {
       return;
     }
-    if (id != null && v == null) {
+    if (id2 != null && v == null) {
       throw new Error(
-        "r-state-tree can't clear an identifier once it has already been set."
+        "r-state-tree can't clear an id once it has already been set."
       );
     }
     if (v !== void 0) {
@@ -2106,7 +2106,7 @@ class ModelAdministration extends PreactObjectAdministration {
       if (!this.referencedModels) this.referencedModels = /* @__PURE__ */ new Map();
       c = createComputed(() => {
         a.reportObserved();
-        const models = (this.source[name] || []).map((id) => getModelById(this.root.proxy, id)).filter((m) => !!m);
+        const models = (this.source[name] || []).map((id2) => getModelById(this.root.proxy, id2)).filter((m) => !!m);
         return models;
       });
       this.referencedModels.set(name, c);
@@ -2114,27 +2114,27 @@ class ModelAdministration extends PreactObjectAdministration {
     return c.get();
   }
   setModelRef(name, modelValue) {
-    let id = void 0;
+    let id2 = void 0;
     if (modelValue) {
-      id = getIdentifier(modelValue);
-      if (id == null) {
+      id2 = getIdentifier(modelValue);
+      if (id2 == null) {
         throw new Error(
           "r-state-tree: Only models with identifiers can be used as a ref"
         );
       }
     }
-    this.source[name] = id;
+    this.source[name] = id2;
     this.referencedAtoms?.get(name)?.reportChanged();
   }
   setModelRefs(name, modelValue) {
     const ids = modelValue.map((model2) => {
-      const id = getIdentifier(model2);
-      if (id == null) {
+      const id2 = getIdentifier(model2);
+      if (id2 == null) {
         throw new Error(
           "r-state-tree: Only models with identifiers can be used as a ref"
         );
       }
-      return id;
+      return id2;
     });
     this.source[name] = ids;
     this.referencedAtoms?.get(name)?.reportChanged();
@@ -2303,8 +2303,8 @@ class ModelAdministration extends PreactObjectAdministration {
                     model22 = snapshot2;
                   } else {
                     ensureChildTypes(key);
-                    const id = childType2 && getSnapshotId(snapshot2, Ctor);
-                    const foundModel = id != null ? getModelById(this.root.proxy, id) : this.proxy[key][index];
+                    const id2 = childType2 && getSnapshotId(snapshot2, Ctor);
+                    const foundModel = id2 != null ? getModelById(this.root.proxy, id2) : this.proxy[key][index];
                     const adm = foundModel && getModelAdm(foundModel);
                     if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
                       adm.loadSnapshot(snapshot2);
@@ -2321,8 +2321,8 @@ class ModelAdministration extends PreactObjectAdministration {
               model2 = value;
             } else {
               ensureChildTypes(key);
-              const id = childType2 && getSnapshotId(value, childType2);
-              if (id != null && this.proxy[key] && id === getIdentifier(this.proxy[key])) {
+              const id2 = childType2 && getSnapshotId(value, childType2);
+              if (id2 != null && this.proxy[key] && id2 === getIdentifier(this.proxy[key])) {
                 const adm = getModelAdm(this.proxy[key]);
                 adm.loadSnapshot(value);
                 model2 = this.proxy[key];
@@ -2482,7 +2482,7 @@ function makeChildDecorator(typeObj) {
 const child = makeChildDecorator(childType);
 const modelRef = makeChildDecorator(modelRefType);
 const model = makeDecorator(modelType);
-const identifier = makeDecorator(idType);
+const id = makeDecorator(idType);
 const state = makeDecorator(stateType);
 export {
   Model,
@@ -2498,7 +2498,7 @@ export {
   createStore,
   effect2 as effect,
   getSignal,
-  identifier,
+  id,
   isObservable,
   model,
   modelRef,

package/dist/store/Store.d.ts

@@ -0,0 +1,20 @@
+import { Props, StoreConfiguration } from "../types";
+export declare function allowNewStore<T>(fn: () => T): T;
+type CreateStoreProps<T extends Props> = {
+    [K in keyof T as undefined extends T[K] ? K : never]?: T[K] extends infer U ? U extends undefined ? never : undefined extends U ? U | undefined : U : never;
+} & {
+    [K in keyof T as undefined extends T[K] ? never : K]?: T[K];
+} & Pick<Props, 'key'>;
+export declare function createStore<K extends Store<T>, T extends Props>(Type: new (props: T) => K, props?: CreateStoreProps<T>): K;
+export declare function updateStore<K extends Store<T>, T extends Props>(store: K, props: CreateStoreProps<T>): K;
+export declare function types<T extends Store>(config: Partial<StoreConfiguration<T>>): Partial<StoreConfiguration<T>>;
+export default class Store<PropsType extends Props = Props> {
+    static get types(): StoreConfiguration<unknown>;
+    props: PropsType;
+    constructor(props: PropsType);
+    get key(): string | number | undefined;
+    reaction<T>(track: () => T, callback: (a: T) => void): () => void;
+    storeDidMount(): void;
+    storeWillUnmount(): void;
+}
+export {};

package/dist/store/StoreAdministration.d.ts

@@ -0,0 +1,30 @@
+import { PreactObjectAdministration as ObjectAdministration } from "../observables";
+import Store from "./Store";
+import { StoreConfiguration, Props } from "../types";
+export declare function updateProps(props: Props, newProps: Props): void;
+export declare function getStoreAdm(store: Store): StoreAdministration;
+export declare class StoreAdministration<StoreType extends Store = Store> extends ObjectAdministration<Store> {
+    static proxyTraps: ProxyHandler<object>;
+    parent: StoreAdministration | null;
+    mounted: boolean;
+    private contextCache;
+    private childStoreDataMap;
+    private reactionsUnsub;
+    private configurationGetter?;
+    setConfiguration(configurationGetter: () => StoreConfiguration<StoreType>): void;
+    private get configuration();
+    private createChildStore;
+    private setStoreList;
+    private setSingleStore;
+    private updateStore;
+    private getComputedGetter;
+    private initializeStore;
+    private getStore;
+    private getModelRef;
+    isRoot(): boolean;
+    getContextValue<T>(contextId: symbol, provideSymbol: symbol, defaultValue: T | undefined, hasDefault: boolean): T;
+    private lookupContextValue;
+    reaction<T>(track: () => T, callback: (a: T) => void): () => void;
+    mount(parent?: StoreAdministration | null): void;
+    unmount(): void;
+}

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+import Store from "./store/Store";
+import Model from "./model/Model";
+export type StoreElement = {
+    Type: new (...args: unknown[]) => Store;
+    props: Props;
+    key: string | number;
+};
+export type ChildStore = Store | Store[] | null;
+export type Key = string | number | undefined;
+export type Context = {
+    [key: string]: unknown;
+};
+export type Props = {
+    [key: string]: unknown;
+    key?: Key;
+    models?: {
+        [key: string]: Model | Model[] | null;
+    };
+};
+export type StoreCtor<S extends Store = Store> = (new (...args: ConstructorParameters<typeof Store>) => S) & {
+    [P in keyof Store]: Store[P];
+};
+export type ChildModel = Model | Model[] | null;
+export type IdType = string | number;
+export declare enum CommonCfgTypes {
+    child = "child"
+}
+export declare enum ModelCfgTypes {
+    state = "state",
+    id = "id",
+    modelRef = "modelRef"
+}
+export declare enum StoreCfgTypes {
+    model = "model"
+}
+export declare enum ObservableCfgTypes {
+    observable = "observable",
+    computed = "computed"
+}
+export type ConfigurationTypes = CommonCfgTypes | ModelCfgTypes | StoreCfgTypes | ObservableCfgTypes;
+export type ConfigurationType = {
+    type: ConfigurationTypes;
+    childType?: Function;
+    [key: string]: unknown;
+};
+export type ModelConfiguration<T> = Record<PropertyKey, ConfigurationType>;
+export type StoreConfiguration<T> = Record<PropertyKey, ConfigurationType>;
+export type Configuration<T> = ModelConfiguration<T> | StoreConfiguration<T>;
+type SnapshotValue<T> = T extends Model ? Snapshot<T> : T extends Array<infer R> ? R extends Model ? Array<Snapshot<R>> : T : T;
+export type Snapshot<T extends Model = Model> = {
+    [K in keyof T]?: T[K] extends infer U ? U extends Model | Model[] ? SnapshotValue<U> | null : U extends null | undefined ? null : SnapshotValue<Exclude<U, null | undefined>> | null : never;
+};
+export type SnapshotDiff<T extends Model = Model> = {
+    undo: Snapshot<T>;
+    redo: Snapshot<T>;
+};
+export type SnapshotChange<T extends Model = Model> = (snapshot: Snapshot<T>, model: T) => void;
+export type RefSnapshot = {
+    [key: string]: IdType;
+    [key: number]: IdType;
+};
+export declare const childType: ((childType: Function) => ConfigurationType) & {
+    type: CommonCfgTypes;
+};
+export declare const stateType: ConfigurationType;
+export declare const modelRefType: ((childType: Function) => ConfigurationType) & {
+    type: ModelCfgTypes;
+};
+export declare const idType: ConfigurationType;
+export declare const modelType: ConfigurationType;
+export declare const observableType: ConfigurationType;
+export declare const computedType: ConfigurationType;
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import { ModelConfiguration } from "./types";
+export declare function getPropertyDescriptor(obj: object, key: PropertyKey): PropertyDescriptor | undefined;
+export declare function getParentConstructor(Ctor: Function | undefined): Function | undefined;
+export declare function clone<T>(val: T): T;
+export declare function getDiff<T extends object>(o1: T, o2: T, getConfig: (snapshot: object) => ModelConfiguration<unknown> | undefined): Partial<T> | null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "r-state-tree",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"description": "reactive state management library",
 	"main": "dist/r-state-tree.cjs",
 	"module": "dist/r-state-tree.js",