r-state-tree 0.4.0 → 0.4.1

package/README.md

@@ -51,15 +51,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 })
 		);
@@ -220,20 +220,38 @@ 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, identifier, child, modelRef } from "r-state-tree";
 
 class User extends Model {
 	@identifier id = 0;
@@ -245,19 +263,29 @@ class TodoModel extends Model {
 	@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;
+	@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 +306,30 @@ 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 {
+	@identifier 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 }),
+		];
+	}
+}
+```
+
 ### 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 identifier: 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/store/Store.d.ts

@@ -0,0 +1,14 @@
+import { Props, StoreConfiguration } from "../types";
+export declare function allowNewStore<T>(fn: () => T): T;
+export declare function createStore<K extends Store<T>, T extends Props>(Type: new (props: T) => K, props?: T): K;
+export declare function updateStore<K extends Store<T>, T extends Props>(store: K, props: 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;
+}

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.1",
 	"description": "reactive state management library",
 	"main": "dist/r-state-tree.cjs",
 	"module": "dist/r-state-tree.js",