@tanstack/store 0.9.0 → 0.9.1

package/dist/cjs/index.cjs

@@ -7,6 +7,7 @@ exports.createAsyncAtom = atom.createAsyncAtom;
 exports.createAtom = atom.createAtom;
 exports.flush = atom.flush;
 exports.toObserver = atom.toObserver;
+exports.ReadonlyStore = store.ReadonlyStore;
 exports.Store = store.Store;
 exports.createStore = store.createStore;
 exports.batch = batch.batch;

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}

package/dist/cjs/store.cjs

@@ -20,12 +20,29 @@ class Store {
     return this.atom.subscribe(atom.toObserver(observerOrFn));
   }
 }
+class ReadonlyStore {
+  constructor(valueOrFn) {
+    this.atom = atom.createAtom(
+      valueOrFn
+    );
+  }
+  get state() {
+    return this.atom.get();
+  }
+  get() {
+    return this.state;
+  }
+  subscribe(observerOrFn) {
+    return this.atom.subscribe(atom.toObserver(observerOrFn));
+  }
+}
 function createStore(valueOrFn) {
   if (typeof valueOrFn === "function") {
-    return new Store(valueOrFn);
+    return new ReadonlyStore(valueOrFn);
   }
   return new Store(valueOrFn);
 }
+exports.ReadonlyStore = ReadonlyStore;
 exports.Store = Store;
 exports.createStore = createStore;
 //# sourceMappingURL=store.cjs.map

package/dist/cjs/store.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"store.cjs","sources":["../../src/store.ts"],"sourcesContent":["import { createAtom, toObserver } from './atom'\nimport type { Atom, Observer, Subscription } from './types'\n\nexport class Store<T> {\n  private atom: Atom<T>\n  constructor(getValue: (prev?: NoInfer<T>) => T)\n  constructor(initialValue: T)\n  constructor(valueOrFn: T | ((prev?: T) => T)) {\n    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values\n    // Store always needs Atom<T> for setState, so we assert the return type\n    this.atom = createAtom(\n      valueOrFn as T | ((prev?: NoInfer<T>) => T),\n    ) as Atom<T>\n  }\n  public setState(updater: (prev: T) => T) {\n    this.atom.set(updater)\n  }\n  public get state() {\n    return this.atom.get()\n  }\n  public get() {\n    return this.state\n  }\n  public subscribe(\n    observerOrFn: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    return this.atom.subscribe(toObserver(observerOrFn))\n  }\n}\n\nexport function createStore<T>(getValue: (prev?: NoInfer<T>) => T): Store<T>\nexport function createStore<T>(initialValue: T): Store<T>\nexport function createStore<T>(valueOrFn: T | ((prev?: T) => T)): Store<T> {\n  if (typeof valueOrFn === 'function') {\n    return new Store(valueOrFn as (prev?: NoInfer<T>) => T)\n  }\n  return new Store(valueOrFn)\n}\n"],"names":["createAtom","toObserver"],"mappings":";;;AAGO,MAAM,MAAS;AAAA,EAIpB,YAAY,WAAkC;AAG5C,SAAK,OAAOA,KAAAA;AAAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAAA,EACO,SAAS,SAAyB;AACvC,SAAK,KAAK,IAAI,OAAO;AAAA,EACvB;AAAA,EACA,IAAW,QAAQ;AACjB,WAAO,KAAK,KAAK,IAAA;AAAA,EACnB;AAAA,EACO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EACO,UACL,cACc;AACd,WAAO,KAAK,KAAK,UAAUC,KAAAA,WAAW,YAAY,CAAC;AAAA,EACrD;AACF;AAIO,SAAS,YAAe,WAA4C;AACzE,MAAI,OAAO,cAAc,YAAY;AACnC,WAAO,IAAI,MAAM,SAAqC;AAAA,EACxD;AACA,SAAO,IAAI,MAAM,SAAS;AAC5B;;;"}
+{"version":3,"file":"store.cjs","sources":["../../src/store.ts"],"sourcesContent":["import { createAtom, toObserver } from './atom'\nimport type { Atom, Observer, Subscription } from './types'\n\nexport class Store<T> {\n  private atom: Atom<T>\n  constructor(getValue: (prev?: NoInfer<T>) => T)\n  constructor(initialValue: T)\n  constructor(valueOrFn: T | ((prev?: T) => T)) {\n    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values\n    // Store always needs Atom<T> for setState, so we assert the return type\n    this.atom = createAtom(\n      valueOrFn as T | ((prev?: NoInfer<T>) => T),\n    ) as Atom<T>\n  }\n  public setState(updater: (prev: T) => T) {\n    this.atom.set(updater)\n  }\n  public get state() {\n    return this.atom.get()\n  }\n  public get() {\n    return this.state\n  }\n  public subscribe(\n    observerOrFn: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    return this.atom.subscribe(toObserver(observerOrFn))\n  }\n}\n\nexport class ReadonlyStore<T> implements Omit<Store<T>, 'setState'> {\n  private atom: Atom<T>\n  constructor(getValue: (prev?: NoInfer<T>) => T)\n  constructor(initialValue: T)\n  constructor(valueOrFn: T | ((prev?: T) => T)) {\n    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values\n    // Store always needs Atom<T> for setState, so we assert the return type\n    this.atom = createAtom(\n      valueOrFn as T | ((prev?: NoInfer<T>) => T),\n    ) as Atom<T>\n  }\n  public get state() {\n    return this.atom.get()\n  }\n  public get() {\n    return this.state\n  }\n  public subscribe(\n    observerOrFn: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    return this.atom.subscribe(toObserver(observerOrFn))\n  }\n}\n\nexport function createStore<T>(\n  getValue: (prev?: NoInfer<T>) => T,\n): ReadonlyStore<T>\nexport function createStore<T>(initialValue: T): Store<T>\nexport function createStore<T>(\n  valueOrFn: T | ((prev?: T) => T),\n): Store<T> | ReadonlyStore<T> {\n  if (typeof valueOrFn === 'function') {\n    return new ReadonlyStore(valueOrFn as (prev?: NoInfer<T>) => T)\n  }\n  return new Store(valueOrFn)\n}\n"],"names":["createAtom","toObserver"],"mappings":";;;AAGO,MAAM,MAAS;AAAA,EAIpB,YAAY,WAAkC;AAG5C,SAAK,OAAOA,KAAAA;AAAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAAA,EACO,SAAS,SAAyB;AACvC,SAAK,KAAK,IAAI,OAAO;AAAA,EACvB;AAAA,EACA,IAAW,QAAQ;AACjB,WAAO,KAAK,KAAK,IAAA;AAAA,EACnB;AAAA,EACO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EACO,UACL,cACc;AACd,WAAO,KAAK,KAAK,UAAUC,KAAAA,WAAW,YAAY,CAAC;AAAA,EACrD;AACF;AAEO,MAAM,cAAuD;AAAA,EAIlE,YAAY,WAAkC;AAG5C,SAAK,OAAOD,KAAAA;AAAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAAA,EACA,IAAW,QAAQ;AACjB,WAAO,KAAK,KAAK,IAAA;AAAA,EACnB;AAAA,EACO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EACO,UACL,cACc;AACd,WAAO,KAAK,KAAK,UAAUC,KAAAA,WAAW,YAAY,CAAC;AAAA,EACrD;AACF;AAMO,SAAS,YACd,WAC6B;AAC7B,MAAI,OAAO,cAAc,YAAY;AACnC,WAAO,IAAI,cAAc,SAAqC;AAAA,EAChE;AACA,SAAO,IAAI,MAAM,SAAS;AAC5B;;;;"}

package/dist/cjs/store.d.cts

@@ -8,5 +8,13 @@ export declare class Store<T> {
     get(): T;
     subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;
 }
-export declare function createStore<T>(getValue: (prev?: NoInfer<T>) => T): Store<T>;
+export declare class ReadonlyStore<T> implements Omit<Store<T>, 'setState'> {
+    private atom;
+    constructor(getValue: (prev?: NoInfer<T>) => T);
+    constructor(initialValue: T);
+    get state(): T;
+    get(): T;
+    subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;
+}
+export declare function createStore<T>(getValue: (prev?: NoInfer<T>) => T): ReadonlyStore<T>;
 export declare function createStore<T>(initialValue: T): Store<T>;

package/dist/esm/index.js

@@ -1,7 +1,8 @@
 import { createAsyncAtom, createAtom, flush, toObserver } from "./atom.js";
-import { Store, createStore } from "./store.js";
+import { ReadonlyStore, Store, createStore } from "./store.js";
 import { batch } from "./batch.js";
 export {
+  ReadonlyStore,
   Store,
   batch,
   createAsyncAtom,

package/dist/esm/store.d.ts

@@ -8,5 +8,13 @@ export declare class Store<T> {
     get(): T;
     subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;
 }
-export declare function createStore<T>(getValue: (prev?: NoInfer<T>) => T): Store<T>;
+export declare class ReadonlyStore<T> implements Omit<Store<T>, 'setState'> {
+    private atom;
+    constructor(getValue: (prev?: NoInfer<T>) => T);
+    constructor(initialValue: T);
+    get state(): T;
+    get(): T;
+    subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;
+}
+export declare function createStore<T>(getValue: (prev?: NoInfer<T>) => T): ReadonlyStore<T>;
 export declare function createStore<T>(initialValue: T): Store<T>;

package/dist/esm/store.js

@@ -18,13 +18,30 @@ class Store {
     return this.atom.subscribe(toObserver(observerOrFn));
   }
 }
+class ReadonlyStore {
+  constructor(valueOrFn) {
+    this.atom = createAtom(
+      valueOrFn
+    );
+  }
+  get state() {
+    return this.atom.get();
+  }
+  get() {
+    return this.state;
+  }
+  subscribe(observerOrFn) {
+    return this.atom.subscribe(toObserver(observerOrFn));
+  }
+}
 function createStore(valueOrFn) {
   if (typeof valueOrFn === "function") {
-    return new Store(valueOrFn);
+    return new ReadonlyStore(valueOrFn);
   }
   return new Store(valueOrFn);
 }
 export {
+  ReadonlyStore,
   Store,
   createStore
 };

package/dist/esm/store.js.map

@@ -1 +1 @@
-{"version":3,"file":"store.js","sources":["../../src/store.ts"],"sourcesContent":["import { createAtom, toObserver } from './atom'\nimport type { Atom, Observer, Subscription } from './types'\n\nexport class Store<T> {\n  private atom: Atom<T>\n  constructor(getValue: (prev?: NoInfer<T>) => T)\n  constructor(initialValue: T)\n  constructor(valueOrFn: T | ((prev?: T) => T)) {\n    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values\n    // Store always needs Atom<T> for setState, so we assert the return type\n    this.atom = createAtom(\n      valueOrFn as T | ((prev?: NoInfer<T>) => T),\n    ) as Atom<T>\n  }\n  public setState(updater: (prev: T) => T) {\n    this.atom.set(updater)\n  }\n  public get state() {\n    return this.atom.get()\n  }\n  public get() {\n    return this.state\n  }\n  public subscribe(\n    observerOrFn: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    return this.atom.subscribe(toObserver(observerOrFn))\n  }\n}\n\nexport function createStore<T>(getValue: (prev?: NoInfer<T>) => T): Store<T>\nexport function createStore<T>(initialValue: T): Store<T>\nexport function createStore<T>(valueOrFn: T | ((prev?: T) => T)): Store<T> {\n  if (typeof valueOrFn === 'function') {\n    return new Store(valueOrFn as (prev?: NoInfer<T>) => T)\n  }\n  return new Store(valueOrFn)\n}\n"],"names":[],"mappings":";AAGO,MAAM,MAAS;AAAA,EAIpB,YAAY,WAAkC;AAG5C,SAAK,OAAO;AAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAAA,EACO,SAAS,SAAyB;AACvC,SAAK,KAAK,IAAI,OAAO;AAAA,EACvB;AAAA,EACA,IAAW,QAAQ;AACjB,WAAO,KAAK,KAAK,IAAA;AAAA,EACnB;AAAA,EACO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EACO,UACL,cACc;AACd,WAAO,KAAK,KAAK,UAAU,WAAW,YAAY,CAAC;AAAA,EACrD;AACF;AAIO,SAAS,YAAe,WAA4C;AACzE,MAAI,OAAO,cAAc,YAAY;AACnC,WAAO,IAAI,MAAM,SAAqC;AAAA,EACxD;AACA,SAAO,IAAI,MAAM,SAAS;AAC5B;"}
+{"version":3,"file":"store.js","sources":["../../src/store.ts"],"sourcesContent":["import { createAtom, toObserver } from './atom'\nimport type { Atom, Observer, Subscription } from './types'\n\nexport class Store<T> {\n  private atom: Atom<T>\n  constructor(getValue: (prev?: NoInfer<T>) => T)\n  constructor(initialValue: T)\n  constructor(valueOrFn: T | ((prev?: T) => T)) {\n    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values\n    // Store always needs Atom<T> for setState, so we assert the return type\n    this.atom = createAtom(\n      valueOrFn as T | ((prev?: NoInfer<T>) => T),\n    ) as Atom<T>\n  }\n  public setState(updater: (prev: T) => T) {\n    this.atom.set(updater)\n  }\n  public get state() {\n    return this.atom.get()\n  }\n  public get() {\n    return this.state\n  }\n  public subscribe(\n    observerOrFn: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    return this.atom.subscribe(toObserver(observerOrFn))\n  }\n}\n\nexport class ReadonlyStore<T> implements Omit<Store<T>, 'setState'> {\n  private atom: Atom<T>\n  constructor(getValue: (prev?: NoInfer<T>) => T)\n  constructor(initialValue: T)\n  constructor(valueOrFn: T | ((prev?: T) => T)) {\n    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values\n    // Store always needs Atom<T> for setState, so we assert the return type\n    this.atom = createAtom(\n      valueOrFn as T | ((prev?: NoInfer<T>) => T),\n    ) as Atom<T>\n  }\n  public get state() {\n    return this.atom.get()\n  }\n  public get() {\n    return this.state\n  }\n  public subscribe(\n    observerOrFn: Observer<T> | ((value: T) => void),\n  ): Subscription {\n    return this.atom.subscribe(toObserver(observerOrFn))\n  }\n}\n\nexport function createStore<T>(\n  getValue: (prev?: NoInfer<T>) => T,\n): ReadonlyStore<T>\nexport function createStore<T>(initialValue: T): Store<T>\nexport function createStore<T>(\n  valueOrFn: T | ((prev?: T) => T),\n): Store<T> | ReadonlyStore<T> {\n  if (typeof valueOrFn === 'function') {\n    return new ReadonlyStore(valueOrFn as (prev?: NoInfer<T>) => T)\n  }\n  return new Store(valueOrFn)\n}\n"],"names":[],"mappings":";AAGO,MAAM,MAAS;AAAA,EAIpB,YAAY,WAAkC;AAG5C,SAAK,OAAO;AAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAAA,EACO,SAAS,SAAyB;AACvC,SAAK,KAAK,IAAI,OAAO;AAAA,EACvB;AAAA,EACA,IAAW,QAAQ;AACjB,WAAO,KAAK,KAAK,IAAA;AAAA,EACnB;AAAA,EACO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EACO,UACL,cACc;AACd,WAAO,KAAK,KAAK,UAAU,WAAW,YAAY,CAAC;AAAA,EACrD;AACF;AAEO,MAAM,cAAuD;AAAA,EAIlE,YAAY,WAAkC;AAG5C,SAAK,OAAO;AAAA,MACV;AAAA,IAAA;AAAA,EAEJ;AAAA,EACA,IAAW,QAAQ;AACjB,WAAO,KAAK,KAAK,IAAA;AAAA,EACnB;AAAA,EACO,MAAM;AACX,WAAO,KAAK;AAAA,EACd;AAAA,EACO,UACL,cACc;AACd,WAAO,KAAK,KAAK,UAAU,WAAW,YAAY,CAAC;AAAA,EACrD;AACF;AAMO,SAAS,YACd,WAC6B;AAC7B,MAAI,OAAO,cAAc,YAAY;AACnC,WAAO,IAAI,cAAc,SAAqC;AAAA,EAChE;AACA,SAAO,IAAI,MAAM,SAAS;AAC5B;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/store",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Framework agnostic type-safe store w/ reactive framework adapters",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/store.ts

@@ -28,11 +28,39 @@ export class Store<T> {
   }
 }
 
-export function createStore<T>(getValue: (prev?: NoInfer<T>) => T): Store<T>
+export class ReadonlyStore<T> implements Omit<Store<T>, 'setState'> {
+  private atom: Atom<T>
+  constructor(getValue: (prev?: NoInfer<T>) => T)
+  constructor(initialValue: T)
+  constructor(valueOrFn: T | ((prev?: T) => T)) {
+    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values
+    // Store always needs Atom<T> for setState, so we assert the return type
+    this.atom = createAtom(
+      valueOrFn as T | ((prev?: NoInfer<T>) => T),
+    ) as Atom<T>
+  }
+  public get state() {
+    return this.atom.get()
+  }
+  public get() {
+    return this.state
+  }
+  public subscribe(
+    observerOrFn: Observer<T> | ((value: T) => void),
+  ): Subscription {
+    return this.atom.subscribe(toObserver(observerOrFn))
+  }
+}
+
+export function createStore<T>(
+  getValue: (prev?: NoInfer<T>) => T,
+): ReadonlyStore<T>
 export function createStore<T>(initialValue: T): Store<T>
-export function createStore<T>(valueOrFn: T | ((prev?: T) => T)): Store<T> {
+export function createStore<T>(
+  valueOrFn: T | ((prev?: T) => T),
+): Store<T> | ReadonlyStore<T> {
   if (typeof valueOrFn === 'function') {
-    return new Store(valueOrFn as (prev?: NoInfer<T>) => T)
+    return new ReadonlyStore(valueOrFn as (prev?: NoInfer<T>) => T)
   }
   return new Store(valueOrFn)
 }