context-scoped-state 0.0.1

package/README.md

@@ -0,0 +1,204 @@
+# context-scoped-state
+
+**State management that respects component boundaries.**
+
+Unlike global state libraries (Redux, Zustand), `context-scoped-state` keeps your state where it belongs — scoped to the component tree that needs it. Each context provider creates an independent store instance, making your components truly reusable and your tests truly isolated.
+
+## Why Scoped State?
+
+Global state is convenient, but it comes with hidden costs:
+
+- **Testing nightmares** — State leaks between tests, requiring complex cleanup
+- **Component coupling** — Reusing components means sharing their global state
+- **Implicit dependencies** — Components magically depend on global singletons
+
+`context-scoped-state` solves this by leveraging React's Context API the right way. Same API simplicity, but with proper encapsulation.
+
+## Installation
+
+```bash
+npm install context-scoped-state
+```
+
+```bash
+yarn add context-scoped-state
+```
+
+```bash
+pnpm add context-scoped-state
+```
+
+> **Peer Dependencies:** React 18+
+
+## Quick Start
+
+### 1. Define Your Store
+
+```tsx
+import { Store } from 'context-scoped-state';
+
+class CounterStore extends Store<{ count: number }> {
+  protected getInitialState() {
+    return { count: 0 };
+  }
+
+  increment() {
+    this.setState({ count: this.getState().count + 1 });
+  }
+
+  decrement() {
+    this.setState({ count: this.getState().count - 1 });
+  }
+}
+```
+
+### 2. Create the Hook
+
+```tsx
+import { createStoreHook } from 'context-scoped-state';
+
+const useCounterStore = createStoreHook(CounterStore);
+```
+
+### 3. Use in Components
+
+```tsx
+function Counter() {
+  const store = useCounterStore();
+
+  return (
+    <div>
+      <span>{store.state.count}</span>
+      <button onClick={() => store.increment()}>+</button>
+      <button onClick={() => store.decrement()}>-</button>
+    </div>
+  );
+}
+
+// Wrap with Context provider
+function App() {
+  return (
+    <useCounterStore.Context>
+      <Counter />
+    </useCounterStore.Context>
+  );
+}
+```
+
+That's it. No providers at the root, no selectors, no reducers, no actions, no dispatch.
+
+## Examples
+
+### Independent Nested Stores
+
+Each `Context` creates a completely independent store instance. Perfect for reusable widget patterns:
+
+```tsx
+function PlayerScore() {
+  const store = useScoreStore();
+  return <span>Score: {store.state.score}</span>;
+}
+
+function Game() {
+  return (
+    <div>
+      {/* Player 1 has their own score */}
+      <useScoreStore.Context>
+        <h2>Player 1</h2>
+        <PlayerScore />
+      </useScoreStore.Context>
+
+      {/* Player 2 has their own score */}
+      <useScoreStore.Context>
+        <h2>Player 2</h2>
+        <PlayerScore />
+      </useScoreStore.Context>
+    </div>
+  );
+}
+```
+
+Both players have completely independent state — no configuration needed.
+
+### Testing with MockContext
+
+Test components in any state without complex setup:
+
+```tsx
+import { render, screen } from '@testing-library/react';
+
+test('shows warning when balance is low', () => {
+  render(
+    <useAccountStore.MockContext state={{ balance: 5, currency: 'USD' }}>
+      <AccountStatus />
+    </useAccountStore.MockContext>,
+  );
+
+  expect(screen.getByText('Low balance warning')).toBeInTheDocument();
+});
+
+test('shows normal status when balance is healthy', () => {
+  render(
+    <useAccountStore.MockContext state={{ balance: 1000, currency: 'USD' }}>
+      <AccountStatus />
+    </useAccountStore.MockContext>,
+  );
+
+  expect(screen.queryByText('Low balance warning')).not.toBeInTheDocument();
+});
+```
+
+No mocking libraries. No global state cleanup. Just render with the state you need.
+
+## Why context-scoped-state Over Other Libraries?
+
+| Feature                | context-scoped-state | Redux                        | Zustand        |
+| ---------------------- | -------------------- | ---------------------------- | -------------- |
+| **Scoped by default**  | Yes                  | No                           | No             |
+| **Multiple instances** | Automatic            | Manual wiring                | Manual wiring  |
+| **Test isolation**     | Built-in MockContext | Requires setup               | Requires reset |
+| **Boilerplate**        | Low                  | High                         | Low            |
+| **Type safety**        | Full                 | Requires setup               | Good           |
+| **Learning curve**     | Just classes         | Actions, reducers, selectors | Simple         |
+
+### The Core Difference
+
+**Global state libraries** make you fight against React's component model. You end up with:
+
+- Selector functions to prevent re-renders
+- Complex test fixtures to reset global state
+- Workarounds for component reusability
+
+**context-scoped-state** works _with_ React:
+
+- State lives in the component tree, just like React intended
+- Each provider = new instance, automatically
+- Testing is just rendering with different props
+
+### When to Use What
+
+**Use context-scoped-state when:**
+
+- Building reusable components with internal state
+- You want test isolation without extra setup
+- State naturally belongs to a subtree, not the whole app
+- You prefer OOP patterns (classes, methods)
+
+**Need global state?** Just place the Context at your app root — same API, app-wide access.
+
+### Why Not Just Use useState or useReducer?
+
+**vs useState:**
+
+- `useState` binds state logic directly to the component, making it hard to reuse or test independently
+- With `context-scoped-state`, state logic lives in a separate class — reusable across components and easily testable
+
+**vs useReducer:**
+
+- No action types, switch statements, or dispatch boilerplate
+- Just call methods directly: `store.increment()` instead of `dispatch({ type: 'INCREMENT' })`
+- Full TypeScript autocomplete for your actions
+
+---
+
+**context-scoped-state** — Because not all state needs to be global.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Store } from './lib/Store';
+export { createStoreHook } from './lib/createStore';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,550 @@
+import { jsx as C } from "react/jsx-runtime";
+import f from "react";
+var _ = function(e, r) {
+  return _ = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, n) {
+    t.__proto__ = n;
+  } || function(t, n) {
+    for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
+  }, _(e, r);
+};
+function h(e, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+  _(e, r);
+  function t() {
+    this.constructor = e;
+  }
+  e.prototype = r === null ? Object.create(r) : (t.prototype = r.prototype, new t());
+}
+function w(e) {
+  var r = typeof Symbol == "function" && Symbol.iterator, t = r && e[r], n = 0;
+  if (t) return t.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(r ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function E(e, r) {
+  var t = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!t) return e;
+  var n = t.call(e), o, i = [], s;
+  try {
+    for (; (r === void 0 || r-- > 0) && !(o = n.next()).done; ) i.push(o.value);
+  } catch (u) {
+    s = { error: u };
+  } finally {
+    try {
+      o && !o.done && (t = n.return) && t.call(n);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return i;
+}
+function x(e, r, t) {
+  if (t || arguments.length === 2) for (var n = 0, o = r.length, i; n < o; n++)
+    (i || !(n in r)) && (i || (i = Array.prototype.slice.call(r, 0, n)), i[n] = r[n]);
+  return e.concat(i || Array.prototype.slice.call(r));
+}
+function l(e) {
+  return typeof e == "function";
+}
+function U(e) {
+  var r = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, t = e(r);
+  return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+var m = U(function(e) {
+  return function(t) {
+    e(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(n, o) {
+      return o + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function g(e, r) {
+  if (e) {
+    var t = e.indexOf(r);
+    0 <= t && e.splice(t, 1);
+  }
+}
+var S = (function() {
+  function e(r) {
+    this.initialTeardown = r, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var r, t, n, o, i;
+    if (!this.closed) {
+      this.closed = !0;
+      var s = this._parentage;
+      if (s)
+        if (this._parentage = null, Array.isArray(s))
+          try {
+            for (var u = w(s), c = u.next(); !c.done; c = u.next()) {
+              var v = c.value;
+              v.remove(this);
+            }
+          } catch (a) {
+            r = { error: a };
+          } finally {
+            try {
+              c && !c.done && (t = u.return) && t.call(u);
+            } finally {
+              if (r) throw r.error;
+            }
+          }
+        else
+          s.remove(this);
+      var j = this.initialTeardown;
+      if (l(j))
+        try {
+          j();
+        } catch (a) {
+          i = a instanceof m ? a.errors : [a];
+        }
+      var P = this._finalizers;
+      if (P) {
+        this._finalizers = null;
+        try {
+          for (var b = w(P), p = b.next(); !p.done; p = b.next()) {
+            var V = p.value;
+            try {
+              A(V);
+            } catch (a) {
+              i = i ?? [], a instanceof m ? i = x(x([], E(i)), E(a.errors)) : i.push(a);
+            }
+          }
+        } catch (a) {
+          n = { error: a };
+        } finally {
+          try {
+            p && !p.done && (o = b.return) && o.call(b);
+          } finally {
+            if (n) throw n.error;
+          }
+        }
+      }
+      if (i)
+        throw new m(i);
+    }
+  }, e.prototype.add = function(r) {
+    var t;
+    if (r && r !== this)
+      if (this.closed)
+        A(r);
+      else {
+        if (r instanceof e) {
+          if (r.closed || r._hasParent(this))
+            return;
+          r._addParent(this);
+        }
+        (this._finalizers = (t = this._finalizers) !== null && t !== void 0 ? t : []).push(r);
+      }
+  }, e.prototype._hasParent = function(r) {
+    var t = this._parentage;
+    return t === r || Array.isArray(t) && t.includes(r);
+  }, e.prototype._addParent = function(r) {
+    var t = this._parentage;
+    this._parentage = Array.isArray(t) ? (t.push(r), t) : t ? [t, r] : r;
+  }, e.prototype._removeParent = function(r) {
+    var t = this._parentage;
+    t === r ? this._parentage = null : Array.isArray(t) && g(t, r);
+  }, e.prototype.remove = function(r) {
+    var t = this._finalizers;
+    t && g(t, r), r instanceof e && r._removeParent(this);
+  }, e.EMPTY = (function() {
+    var r = new e();
+    return r.closed = !0, r;
+  })(), e;
+})(), M = S.EMPTY;
+function Y(e) {
+  return e instanceof S || e && "closed" in e && l(e.remove) && l(e.add) && l(e.unsubscribe);
+}
+function A(e) {
+  l(e) ? e() : e.unsubscribe();
+}
+var H = {
+  Promise: void 0
+}, $ = {
+  setTimeout: function(e, r) {
+    for (var t = [], n = 2; n < arguments.length; n++)
+      t[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, x([e, r], E(t)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function q(e) {
+  $.setTimeout(function() {
+    throw e;
+  });
+}
+function I() {
+}
+function y(e) {
+  e();
+}
+var F = (function(e) {
+  h(r, e);
+  function r(t) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, t ? (n.destination = t, Y(t) && t.add(n)) : n.destination = J, n;
+  }
+  return r.create = function(t, n, o) {
+    return new O(t, n, o);
+  }, r.prototype.next = function(t) {
+    this.isStopped || this._next(t);
+  }, r.prototype.error = function(t) {
+    this.isStopped || (this.isStopped = !0, this._error(t));
+  }, r.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, r.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, r.prototype._next = function(t) {
+    this.destination.next(t);
+  }, r.prototype._error = function(t) {
+    try {
+      this.destination.error(t);
+    } finally {
+      this.unsubscribe();
+    }
+  }, r.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, r;
+})(S), D = (function() {
+  function e(r) {
+    this.partialObserver = r;
+  }
+  return e.prototype.next = function(r) {
+    var t = this.partialObserver;
+    if (t.next)
+      try {
+        t.next(r);
+      } catch (n) {
+        d(n);
+      }
+  }, e.prototype.error = function(r) {
+    var t = this.partialObserver;
+    if (t.error)
+      try {
+        t.error(r);
+      } catch (n) {
+        d(n);
+      }
+    else
+      d(r);
+  }, e.prototype.complete = function() {
+    var r = this.partialObserver;
+    if (r.complete)
+      try {
+        r.complete();
+      } catch (t) {
+        d(t);
+      }
+  }, e;
+})(), O = (function(e) {
+  h(r, e);
+  function r(t, n, o) {
+    var i = e.call(this) || this, s;
+    return l(t) || !t ? s = {
+      next: t ?? void 0,
+      error: n ?? void 0,
+      complete: o ?? void 0
+    } : s = t, i.destination = new D(s), i;
+  }
+  return r;
+})(F);
+function d(e) {
+  q(e);
+}
+function G(e) {
+  throw e;
+}
+var J = {
+  closed: !0,
+  next: I,
+  error: G,
+  complete: I
+}, K = (function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})();
+function L(e) {
+  return e;
+}
+function Q(e) {
+  return e.length === 0 ? L : e.length === 1 ? e[0] : function(t) {
+    return e.reduce(function(n, o) {
+      return o(n);
+    }, t);
+  };
+}
+var T = (function() {
+  function e(r) {
+    r && (this._subscribe = r);
+  }
+  return e.prototype.lift = function(r) {
+    var t = new e();
+    return t.source = this, t.operator = r, t;
+  }, e.prototype.subscribe = function(r, t, n) {
+    var o = this, i = X(r) ? r : new O(r, t, n);
+    return y(function() {
+      var s = o, u = s.operator, c = s.source;
+      i.add(u ? u.call(i, c) : c ? o._subscribe(i) : o._trySubscribe(i));
+    }), i;
+  }, e.prototype._trySubscribe = function(r) {
+    try {
+      return this._subscribe(r);
+    } catch (t) {
+      r.error(t);
+    }
+  }, e.prototype.forEach = function(r, t) {
+    var n = this;
+    return t = k(t), new t(function(o, i) {
+      var s = new O({
+        next: function(u) {
+          try {
+            r(u);
+          } catch (c) {
+            i(c), s.unsubscribe();
+          }
+        },
+        error: i,
+        complete: o
+      });
+      n.subscribe(s);
+    });
+  }, e.prototype._subscribe = function(r) {
+    var t;
+    return (t = this.source) === null || t === void 0 ? void 0 : t.subscribe(r);
+  }, e.prototype[K] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var r = [], t = 0; t < arguments.length; t++)
+      r[t] = arguments[t];
+    return Q(r)(this);
+  }, e.prototype.toPromise = function(r) {
+    var t = this;
+    return r = k(r), new r(function(n, o) {
+      var i;
+      t.subscribe(function(s) {
+        return i = s;
+      }, function(s) {
+        return o(s);
+      }, function() {
+        return n(i);
+      });
+    });
+  }, e.create = function(r) {
+    return new e(r);
+  }, e;
+})();
+function k(e) {
+  var r;
+  return (r = e ?? H.Promise) !== null && r !== void 0 ? r : Promise;
+}
+function W(e) {
+  return e && l(e.next) && l(e.error) && l(e.complete);
+}
+function X(e) {
+  return e && e instanceof F || W(e) && Y(e);
+}
+var Z = U(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), B = (function(e) {
+  h(r, e);
+  function r() {
+    var t = e.call(this) || this;
+    return t.closed = !1, t.currentObservers = null, t.observers = [], t.isStopped = !1, t.hasError = !1, t.thrownError = null, t;
+  }
+  return r.prototype.lift = function(t) {
+    var n = new R(this, this);
+    return n.operator = t, n;
+  }, r.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new Z();
+  }, r.prototype.next = function(t) {
+    var n = this;
+    y(function() {
+      var o, i;
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.currentObservers || (n.currentObservers = Array.from(n.observers));
+        try {
+          for (var s = w(n.currentObservers), u = s.next(); !u.done; u = s.next()) {
+            var c = u.value;
+            c.next(t);
+          }
+        } catch (v) {
+          o = { error: v };
+        } finally {
+          try {
+            u && !u.done && (i = s.return) && i.call(s);
+          } finally {
+            if (o) throw o.error;
+          }
+        }
+      }
+    });
+  }, r.prototype.error = function(t) {
+    var n = this;
+    y(function() {
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.hasError = n.isStopped = !0, n.thrownError = t;
+        for (var o = n.observers; o.length; )
+          o.shift().error(t);
+      }
+    });
+  }, r.prototype.complete = function() {
+    var t = this;
+    y(function() {
+      if (t._throwIfClosed(), !t.isStopped) {
+        t.isStopped = !0;
+        for (var n = t.observers; n.length; )
+          n.shift().complete();
+      }
+    });
+  }, r.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(r.prototype, "observed", {
+    get: function() {
+      var t;
+      return ((t = this.observers) === null || t === void 0 ? void 0 : t.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), r.prototype._trySubscribe = function(t) {
+    return this._throwIfClosed(), e.prototype._trySubscribe.call(this, t);
+  }, r.prototype._subscribe = function(t) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(t), this._innerSubscribe(t);
+  }, r.prototype._innerSubscribe = function(t) {
+    var n = this, o = this, i = o.hasError, s = o.isStopped, u = o.observers;
+    return i || s ? M : (this.currentObservers = null, u.push(t), new S(function() {
+      n.currentObservers = null, g(u, t);
+    }));
+  }, r.prototype._checkFinalizedStatuses = function(t) {
+    var n = this, o = n.hasError, i = n.thrownError, s = n.isStopped;
+    o ? t.error(i) : s && t.complete();
+  }, r.prototype.asObservable = function() {
+    var t = new T();
+    return t.source = this, t;
+  }, r.create = function(t, n) {
+    return new R(t, n);
+  }, r;
+})(T), R = (function(e) {
+  h(r, e);
+  function r(t, n) {
+    var o = e.call(this) || this;
+    return o.destination = t, o.source = n, o;
+  }
+  return r.prototype.next = function(t) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.next) === null || o === void 0 || o.call(n, t);
+  }, r.prototype.error = function(t) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.error) === null || o === void 0 || o.call(n, t);
+  }, r.prototype.complete = function() {
+    var t, n;
+    (n = (t = this.destination) === null || t === void 0 ? void 0 : t.complete) === null || n === void 0 || n.call(t);
+  }, r.prototype._subscribe = function(t) {
+    var n, o;
+    return (o = (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(t)) !== null && o !== void 0 ? o : M;
+  }, r;
+})(B), z = (function(e) {
+  h(r, e);
+  function r(t) {
+    var n = e.call(this) || this;
+    return n._value = t, n;
+  }
+  return Object.defineProperty(r.prototype, "value", {
+    get: function() {
+      return this.getValue();
+    },
+    enumerable: !1,
+    configurable: !0
+  }), r.prototype._subscribe = function(t) {
+    var n = e.prototype._subscribe.call(this, t);
+    return !n.closed && t.next(this._value), n;
+  }, r.prototype.getValue = function() {
+    var t = this, n = t.hasError, o = t.thrownError, i = t._value;
+    if (n)
+      throw o;
+    return this._throwIfClosed(), i;
+  }, r.prototype.next = function(t) {
+    e.prototype.next.call(this, this._value = t);
+  }, r;
+})(B);
+class rt {
+  _stateSubject;
+  constructor() {
+    this.state = this.getInitialState(), this._stateSubject = new z(this.getInitialState());
+  }
+  getState() {
+    return this._stateSubject.value;
+  }
+  state$() {
+    return this._stateSubject.asObservable();
+  }
+  state;
+  setState(r) {
+    this._stateSubject.next(r);
+  }
+}
+function et(e) {
+  const r = f.createContext(void 0);
+  function t() {
+    const n = f.useContext(r);
+    if (!n)
+      throw new Error(
+        `Store hook used outside of its Context provider.
+
+If you created your hook like:
+  const useYourStore = createStoreHook(${e.name});
+
+Then wrap your component with:
+  <useYourStore.Context>
+    <YourComponent />
+  </useYourStore.Context>`
+      );
+    const [o, i] = f.useState(n.getState());
+    return f.useEffect(() => {
+      const s = n.state$().subscribe(i);
+      return () => s.unsubscribe();
+    }, []), n.state = o, n;
+  }
+  return t.Context = function({
+    children: o
+  }) {
+    const i = f.useRef(new e());
+    return /* @__PURE__ */ C(r.Provider, { value: i.current, children: o });
+  }, t.MockContext = function({
+    children: o,
+    state: i
+  }) {
+    const s = () => {
+      if (i === void 0)
+        return new e();
+      class c extends e {
+        getInitialState() {
+          return i;
+        }
+      }
+      return new c();
+    }, u = f.useRef(s());
+    return /* @__PURE__ */ C(r.Provider, { value: u.current, children: o });
+  }, t;
+}
+export {
+  rt as Store,
+  et as createStoreHook
+};

package/dist/lib/Store.d.ts

@@ -0,0 +1,11 @@
+declare abstract class Store<T> {
+    protected abstract getInitialState(): T;
+    private readonly _stateSubject;
+    constructor();
+    getState(): T;
+    state$(): import('rxjs').Observable<T>;
+    state: T;
+    protected setState(newState: T): void;
+}
+export { Store };
+//# sourceMappingURL=Store.d.ts.map

package/dist/lib/Store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../src/lib/Store.ts"],"names":[],"mappings":"AAEA,uBAAe,KAAK,CAAC,CAAC;IACpB,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,CAAC;IAEvC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;;IAOnD,QAAQ,IAAI,CAAC;IAIb,MAAM;IAIC,KAAK,EAAE,CAAC,CAAC;IAEhB,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;CAGtC;AAED,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/lib/createStore.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { Store } from './Store';
+declare function createStoreHook<T extends Store<any>>(storeClass: new () => T): {
+    (): T;
+    Context({ children, }: {
+        children: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    MockContext({ children, state, }: {
+        children: React.ReactNode;
+        state?: ReturnType<T["getState"]>;
+    }): import("react/jsx-runtime").JSX.Element;
+};
+export { createStoreHook };
+//# sourceMappingURL=createStore.d.ts.map

package/dist/lib/createStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStore.d.ts","sourceRoot":"","sources":["../../src/lib/createStore.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,iBAAS,eAAe,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC;QAG/C,CAAC;2BA+BnB;QACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;KAC3B;sCAaE;QACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;QAC1B,KAAK,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;KACnC;EAuBF;AACD,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "context-scoped-state",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@context-store-react/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  }
+}