r-state-tree 0.4.1 → 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.
@@ -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;
 }
@@ -251,15 +355,15 @@ class TodoModel extends Model {
 Use decorators to configure model properties:
 
 ```ts
-import { Model, state, identifier, child, modelRef } 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
@@ -282,7 +386,7 @@ Reference models by ID using `@modelRef`:
 
 ```ts
 class ProjectModel extends Model {
-	@identifier id = 0;
+	@id id = 0;
 	@child users: User[] = [];
 	@modelRef owner?: User; // Single reference
 	@modelRef assignees: User[] = []; // Array of references
@@ -310,7 +414,7 @@ Both `@child` and `@modelRef` support runtime type switching between single valu
 
 ```ts
 class ItemModel extends Model {
-	@identifier id = 0;
+	@id id = 0;
 	@state value = 0;
 }
 
@@ -330,6 +434,57 @@ class ContainerModel extends Model {
 }
 ```
 
+## 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/decorators.d.ts

@@ -2,5 +2,5 @@ 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 id: any;
 export declare const state: any;

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

@@ -1,7 +1,12 @@
 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;
+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>;
@@ -12,3 +17,4 @@ export default class Store<PropsType extends Props = Props> {
     storeDidMount(): void;
     storeWillUnmount(): void;
 }
+export {};

package/package.json

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