@tanstack/store 0.8.1 → 0.9.0

package/dist/cjs/atom.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atom.cjs","sources":["../../src/atom.ts"],"sourcesContent":["import { ReactiveFlags, createReactiveSystem, getBatchDepth } from './alien'\n\nimport type { ReactiveNode } from './alien'\nimport type {\n  Atom,\n  AtomOptions,\n  Observer,\n  ReadonlyAtom,\n  Subscription,\n} from './types'\n\nexport function toObserver<T>(\n  nextHandler?: Observer<T> | ((value: T) => void),\n  errorHandler?: (error: any) => void,\n  completionHandler?: () => void,\n): Observer<T> {\n  const isObserver = typeof nextHandler === 'object'\n  const self = isObserver ? nextHandler : undefined\n\n  return {\n    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),\n    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),\n    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(\n      self,\n    ),\n  }\n}\n\ninterface InternalAtom<T> extends ReactiveNode {\n  _snapshot: T\n  _update: (getValue?: T | ((snapshot: T) => T)) => boolean\n  get: () => T\n  subscribe: (observerOrFn: Observer<T> | ((value: T) => void)) => Subscription\n}\n\nconst queuedEffects: Array<Effect | undefined> = []\nlet cycle = 0\nconst { link, unlink, propagate, checkDirty, shallowPropagate } =\n  createReactiveSystem({\n    update(atom: InternalAtom<any>): boolean {\n      return atom._update()\n    },\n    // eslint-disable-next-line no-shadow\n    notify(effect: Effect): void {\n      queuedEffects[queuedEffectsLength++] = effect\n      effect.flags &= ~ReactiveFlags.Watching\n    },\n    unwatched(atom: InternalAtom<any>): void {\n      if (atom.depsTail !== undefined) {\n        atom.depsTail = undefined\n        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty\n        purgeDeps(atom)\n      }\n    },\n  })\n\nlet notifyIndex = 0\nlet queuedEffectsLength = 0\nlet activeSub: ReactiveNode | undefined\n\nfunction purgeDeps(sub: ReactiveNode) {\n  const depsTail = sub.depsTail\n  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps\n  while (dep !== undefined) {\n    dep = unlink(dep, sub)\n  }\n}\n\nexport function flush(): void {\n  if (getBatchDepth() > 0) {\n    return\n  }\n  while (notifyIndex < queuedEffectsLength) {\n    // eslint-disable-next-line no-shadow\n    const effect = queuedEffects[notifyIndex]!\n    queuedEffects[notifyIndex++] = undefined\n    effect.notify()\n  }\n  notifyIndex = 0\n  queuedEffectsLength = 0\n}\n\ntype AsyncAtomState<TData, TError = unknown> =\n  | { status: 'pending' }\n  | { status: 'done'; data: TData }\n  | { status: 'error'; error: TError }\n\nexport function createAsyncAtom<T>(\n  getValue: () => Promise<T>,\n  options?: AtomOptions<AsyncAtomState<T>>,\n): ReadonlyAtom<AsyncAtomState<T>> {\n  const ref: { current?: InternalAtom<AsyncAtomState<T>> } = {}\n  const atom = createAtom<AsyncAtomState<T>>(() => {\n    getValue().then(\n      (data) => {\n        const internalAtom = ref.current!\n        if (internalAtom._update({ status: 'done', data })) {\n          const subs = internalAtom.subs\n          if (subs !== undefined) {\n            propagate(subs)\n            shallowPropagate(subs)\n            flush()\n          }\n        }\n      },\n      (error) => {\n        const internalAtom = ref.current!\n        if (internalAtom._update({ status: 'error', error })) {\n          const subs = internalAtom.subs\n          if (subs !== undefined) {\n            propagate(subs)\n            shallowPropagate(subs)\n            flush()\n          }\n        }\n      },\n    )\n\n    return { status: 'pending' }\n  }, options)\n  ref.current = atom as unknown as InternalAtom<AsyncAtomState<T>>\n\n  return atom\n}\n\nexport function createAtom<T>(\n  getValue: (prev?: NoInfer<T>) => T,\n  options?: AtomOptions<T>,\n): ReadonlyAtom<T>\nexport function createAtom<T>(\n  initialValue: T,\n  options?: AtomOptions<T>,\n): Atom<T>\nexport function createAtom<T>(\n  valueOrFn: T | ((prev?: T) => T),\n  options?: AtomOptions<T>,\n): Atom<T> | ReadonlyAtom<T> {\n  const isComputed = typeof valueOrFn === 'function'\n  const getter = valueOrFn as (prev?: T) => T\n\n  // Create plain object atom\n  const atom: InternalAtom<T> = {\n    _snapshot: isComputed ? undefined! : valueOrFn,\n\n    subs: undefined,\n    subsTail: undefined,\n    deps: undefined,\n    depsTail: undefined,\n    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,\n\n    get(): T {\n      if (activeSub !== undefined) {\n        link(atom, activeSub, cycle)\n      }\n      return atom._snapshot\n    },\n\n    subscribe(observerOrFn: Observer<T> | ((value: T) => void)) {\n      const obs = toObserver(observerOrFn)\n      const observed = { current: false }\n      const e = effect(() => {\n        atom.get()\n        if (!observed.current) {\n          observed.current = true\n        } else {\n          obs.next?.(atom._snapshot)\n        }\n      })\n\n      return {\n        unsubscribe: () => {\n          e.stop()\n        },\n      }\n    },\n    _update(getValue?: T | ((snapshot: T) => T)): boolean {\n      const prevSub = activeSub\n      const compare = options?.compare ?? Object.is\n      activeSub = atom\n      ++cycle\n      atom.depsTail = undefined\n      if (isComputed) {\n        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck\n      }\n      try {\n        const oldValue = atom._snapshot\n        const newValue =\n          typeof getValue === 'function'\n            ? (getValue as (snapshot: T) => T)(oldValue)\n            : getValue === undefined && isComputed\n              ? getter(oldValue)\n              : getValue!\n        if (oldValue === undefined || !compare(oldValue, newValue)) {\n          atom._snapshot = newValue\n          return true\n        }\n        return false\n      } finally {\n        activeSub = prevSub\n        if (isComputed) {\n          atom.flags &= ~ReactiveFlags.RecursedCheck\n        }\n        purgeDeps(atom)\n      }\n    },\n  }\n\n  if (isComputed) {\n    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty\n    atom.get = function (): T {\n      const flags = atom.flags\n      if (\n        flags & ReactiveFlags.Dirty ||\n        (flags & ReactiveFlags.Pending && checkDirty(atom.deps!, atom))\n      ) {\n        if (atom._update()) {\n          const subs = atom.subs\n          if (subs !== undefined) {\n            shallowPropagate(subs)\n          }\n        }\n      } else if (flags & ReactiveFlags.Pending) {\n        atom.flags = flags & ~ReactiveFlags.Pending\n      }\n      if (activeSub !== undefined) {\n        link(atom, activeSub, cycle)\n      }\n      return atom._snapshot\n    }\n  } else {\n    ;(atom as unknown as Atom<T>).set = function (\n      // eslint-disable-next-line no-shadow\n      valueOrFn: T | ((prev: T) => T),\n    ): void {\n      if (atom._update(valueOrFn)) {\n        const subs = atom.subs\n        if (subs !== undefined) {\n          propagate(subs)\n          shallowPropagate(subs)\n          flush()\n        }\n      }\n    }\n  }\n\n  return atom as unknown as Atom<T> | ReadonlyAtom<T>\n}\n\ninterface Effect extends ReactiveNode {\n  notify: () => void\n  stop: () => void\n}\n\nfunction effect<T>(fn: () => T): Effect {\n  const run = (): T => {\n    const prevSub = activeSub\n    activeSub = effectObj\n    ++cycle\n    effectObj.depsTail = undefined\n    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck\n    try {\n      return fn()\n    } finally {\n      activeSub = prevSub\n      effectObj.flags &= ~ReactiveFlags.RecursedCheck\n      purgeDeps(effectObj)\n    }\n  }\n  const effectObj: Effect = {\n    deps: undefined,\n    depsTail: undefined,\n    subs: undefined,\n    subsTail: undefined,\n    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,\n\n    notify(): void {\n      const flags = this.flags\n      if (\n        flags & ReactiveFlags.Dirty ||\n        (flags & ReactiveFlags.Pending && checkDirty(this.deps!, this))\n      ) {\n        run()\n      } else {\n        this.flags = ReactiveFlags.Watching\n      }\n    },\n\n    stop(): void {\n      this.flags = ReactiveFlags.None\n      this.depsTail = undefined\n      purgeDeps(this)\n    },\n  }\n\n  run()\n\n  return effectObj\n}\n"],"names":["createReactiveSystem","effect","ReactiveFlags","getBatchDepth","valueOrFn"],"mappings":"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"}

package/dist/cjs/atom.d.cts

@@ -0,0 +1,16 @@
+import { Atom, AtomOptions, Observer, ReadonlyAtom } from './types.cjs';
+export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
+export declare function flush(): void;
+type AsyncAtomState<TData, TError = unknown> = {
+    status: 'pending';
+} | {
+    status: 'done';
+    data: TData;
+} | {
+    status: 'error';
+    error: TError;
+};
+export declare function createAsyncAtom<T>(getValue: () => Promise<T>, options?: AtomOptions<AsyncAtomState<T>>): ReadonlyAtom<AsyncAtomState<T>>;
+export declare function createAtom<T>(getValue: (prev?: NoInfer<T>) => T, options?: AtomOptions<T>): ReadonlyAtom<T>;
+export declare function createAtom<T>(initialValue: T, options?: AtomOptions<T>): Atom<T>;
+export {};

package/dist/cjs/batch.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const alien = require("./alien.cjs");
+const atom = require("./atom.cjs");
+function batch(fn) {
+  try {
+    alien.startBatch();
+    fn();
+  } finally {
+    alien.endBatch();
+    atom.flush();
+  }
+}
+exports.batch = batch;
+//# sourceMappingURL=batch.cjs.map

package/dist/cjs/batch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.cjs","sources":["../../src/batch.ts"],"sourcesContent":["import { endBatch, startBatch } from './alien'\nimport { flush } from './atom'\n\nexport function batch(fn: () => void) {\n  try {\n    startBatch()\n    fn()\n  } finally {\n    endBatch()\n    flush()\n  }\n}\n"],"names":["startBatch","endBatch","flush"],"mappings":";;;;AAGO,SAAS,MAAM,IAAgB;AACpC,MAAI;AACFA,qBAAA;AACA,OAAA;AAAA,EACF,UAAA;AACEC,mBAAA;AACAC,eAAA;AAAA,EACF;AACF;;"}

package/dist/cjs/batch.d.cts

@@ -0,0 +1 @@
+export declare function batch(fn: () => void): void;

package/dist/cjs/index.cjs

@@ -1,17 +1,13 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const derived = require("./derived.cjs");
-const effect = require("./effect.cjs");
+const atom = require("./atom.cjs");
 const store = require("./store.cjs");
-const types = require("./types.cjs");
-const scheduler = require("./scheduler.cjs");
-exports.Derived = derived.Derived;
-exports.Effect = effect.Effect;
+const batch = require("./batch.cjs");
+exports.createAsyncAtom = atom.createAsyncAtom;
+exports.createAtom = atom.createAtom;
+exports.flush = atom.flush;
+exports.toObserver = atom.toObserver;
 exports.Store = store.Store;
-exports.isUpdaterFunction = types.isUpdaterFunction;
-exports.__depsThatHaveWrittenThisTick = scheduler.__depsThatHaveWrittenThisTick;
-exports.__derivedToStore = scheduler.__derivedToStore;
-exports.__flush = scheduler.__flush;
-exports.__storeToDerived = scheduler.__storeToDerived;
-exports.batch = scheduler.batch;
+exports.createStore = store.createStore;
+exports.batch = batch.batch;
 //# sourceMappingURL=index.cjs.map

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/index.d.cts

@@ -1,5 +1,4 @@
-export * from './derived.cjs';
-export * from './effect.cjs';
-export * from './store.cjs';
 export * from './types.cjs';
-export * from './scheduler.cjs';
+export * from './atom.cjs';
+export * from './store.cjs';
+export * from './batch.cjs';

package/dist/cjs/store.cjs

@@ -1,38 +1,31 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const scheduler = require("./scheduler.cjs");
-const types = require("./types.cjs");
+const atom = require("./atom.cjs");
 class Store {
-  constructor(initialState, options) {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.subscribe = (listener) => {
-      var _a, _b;
-      this.listeners.add(listener);
-      const unsub = (_b = (_a = this.options) == null ? void 0 : _a.onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
-      return () => {
-        this.listeners.delete(listener);
-        unsub == null ? void 0 : unsub();
-      };
-    };
-    this.prevState = initialState;
-    this.state = initialState;
-    this.options = options;
+  constructor(valueOrFn) {
+    this.atom = atom.createAtom(
+      valueOrFn
+    );
   }
   setState(updater) {
-    var _a, _b, _c;
-    this.prevState = this.state;
-    if ((_a = this.options) == null ? void 0 : _a.updateFn) {
-      this.state = this.options.updateFn(this.prevState)(updater);
-    } else {
-      if (types.isUpdaterFunction(updater)) {
-        this.state = updater(this.prevState);
-      } else {
-        this.state = updater;
-      }
-    }
-    (_c = (_b = this.options) == null ? void 0 : _b.onUpdate) == null ? void 0 : _c.call(_b);
-    scheduler.__flush(this);
+    this.atom.set(updater);
   }
+  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 Store(valueOrFn);
 }
 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 { __flush } from './scheduler'\nimport { isUpdaterFunction } from './types'\nimport type { AnyUpdater, Listener, Updater } from './types'\n\nexport interface StoreOptions<\n  TState,\n  TUpdater extends AnyUpdater = (cb: TState) => TState,\n> {\n  /**\n   * Replace the default update function with a custom one.\n   */\n  updateFn?: (previous: TState) => (updater: TUpdater) => TState\n  /**\n   * Called when a listener subscribes to the store.\n   *\n   * @return a function to unsubscribe the listener\n   */\n  onSubscribe?: (\n    listener: Listener<TState>,\n    store: Store<TState, TUpdater>,\n  ) => () => void\n  /**\n   * Called after the state has been updated, used to derive other state.\n   */\n  onUpdate?: () => void\n}\n\nexport class Store<\n  TState,\n  TUpdater extends AnyUpdater = (cb: TState) => TState,\n> {\n  listeners = new Set<Listener<TState>>()\n  state: TState\n  prevState: TState\n  options?: StoreOptions<TState, TUpdater>\n\n  constructor(initialState: TState, options?: StoreOptions<TState, TUpdater>) {\n    this.prevState = initialState\n    this.state = initialState\n    this.options = options\n  }\n\n  subscribe = (listener: Listener<TState>) => {\n    this.listeners.add(listener)\n    const unsub = this.options?.onSubscribe?.(listener, this)\n    return () => {\n      this.listeners.delete(listener)\n      unsub?.()\n    }\n  }\n\n  /**\n   * Update the store state safely with improved type checking\n   */\n  setState(updater: (prevState: TState) => TState): void\n  setState(updater: TState): void\n  setState(updater: TUpdater): void\n  setState(updater: Updater<TState> | TUpdater): void {\n    this.prevState = this.state\n\n    if (this.options?.updateFn) {\n      this.state = this.options.updateFn(this.prevState)(updater as TUpdater)\n    } else {\n      if (isUpdaterFunction(updater)) {\n        this.state = updater(this.prevState)\n      } else {\n        this.state = updater as TState\n      }\n    }\n\n    // Always run onUpdate, regardless of batching\n    this.options?.onUpdate?.()\n\n    // Attempt to flush\n    __flush(this as never)\n  }\n}\n"],"names":["isUpdaterFunction","__flush"],"mappings":";;;;AA2BO,MAAM,MAGX;AAAA,EAMA,YAAY,cAAsB,SAA0C;AAL5E,SAAA,gCAAgB,IAAA;AAWhB,SAAA,YAAY,CAAC,aAA+B;;AAC1C,WAAK,UAAU,IAAI,QAAQ;AAC3B,YAAM,SAAQ,gBAAK,YAAL,mBAAc,gBAAd,4BAA4B,UAAU;AACpD,aAAO,MAAM;AACX,aAAK,UAAU,OAAO,QAAQ;AAC9B;AAAA,MACF;AAAA,IACF;AAZE,SAAK,YAAY;AACjB,SAAK,QAAQ;AACb,SAAK,UAAU;AAAA,EACjB;AAAA,EAiBA,SAAS,SAA2C;;AAClD,SAAK,YAAY,KAAK;AAEtB,SAAI,UAAK,YAAL,mBAAc,UAAU;AAC1B,WAAK,QAAQ,KAAK,QAAQ,SAAS,KAAK,SAAS,EAAE,OAAmB;AAAA,IACxE,OAAO;AACL,UAAIA,MAAAA,kBAAkB,OAAO,GAAG;AAC9B,aAAK,QAAQ,QAAQ,KAAK,SAAS;AAAA,MACrC,OAAO;AACL,aAAK,QAAQ;AAAA,MACf;AAAA,IACF;AAGA,qBAAK,YAAL,mBAAc,aAAd;AAGAC,cAAAA,QAAQ,IAAa;AAAA,EACvB;AACF;;"}
+{"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;;;"}

package/dist/cjs/store.d.cts

@@ -1,31 +1,12 @@
-import { AnyUpdater, Listener } from './types.cjs';
-export interface StoreOptions<TState, TUpdater extends AnyUpdater = (cb: TState) => TState> {
-    /**
-     * Replace the default update function with a custom one.
-     */
-    updateFn?: (previous: TState) => (updater: TUpdater) => TState;
-    /**
-     * Called when a listener subscribes to the store.
-     *
-     * @return a function to unsubscribe the listener
-     */
-    onSubscribe?: (listener: Listener<TState>, store: Store<TState, TUpdater>) => () => void;
-    /**
-     * Called after the state has been updated, used to derive other state.
-     */
-    onUpdate?: () => void;
-}
-export declare class Store<TState, TUpdater extends AnyUpdater = (cb: TState) => TState> {
-    listeners: Set<Listener<TState>>;
-    state: TState;
-    prevState: TState;
-    options?: StoreOptions<TState, TUpdater>;
-    constructor(initialState: TState, options?: StoreOptions<TState, TUpdater>);
-    subscribe: (listener: Listener<TState>) => () => void;
-    /**
-     * Update the store state safely with improved type checking
-     */
-    setState(updater: (prevState: TState) => TState): void;
-    setState(updater: TState): void;
-    setState(updater: TUpdater): void;
+import { Observer, Subscription } from './types.cjs';
+export declare class Store<T> {
+    private atom;
+    constructor(getValue: (prev?: NoInfer<T>) => T);
+    constructor(initialValue: T);
+    setState(updater: (prev: T) => T): void;
+    get state(): 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 function createStore<T>(initialValue: T): Store<T>;

package/dist/cjs/types.d.cts

@@ -1,23 +1,50 @@
-/**
- * @private
- */
-export type AnyUpdater = (prev: any) => any;
-/**
- * Type-safe updater that can be either a function or direct value
- */
-export type Updater<T> = ((prev: T) => T) | T;
-/**
- * @private
- */
-export interface ListenerValue<T> {
-    readonly prevVal: T;
-    readonly currentVal: T;
+import { ReactiveNode } from './alien.cjs';
+export type Selection<TSelected> = Readable<TSelected>;
+export interface InteropSubscribable<T> {
+    subscribe: (observer: Observer<T>) => Subscription;
+}
+export type Observer<T> = {
+    next?: (value: T) => void;
+    error?: (err: unknown) => void;
+    complete?: () => void;
+};
+export interface Subscription {
+    unsubscribe: () => void;
+}
+export interface Subscribable<T> extends InteropSubscribable<T> {
+    subscribe: ((observer: Observer<T>) => Subscription) & ((next: (value: T) => void, error?: (error: any) => void, complete?: () => void) => Subscription);
+}
+export interface Readable<T> extends Subscribable<T> {
+    get: () => T;
+}
+export interface BaseAtom<T> extends Subscribable<T>, Readable<T> {
+}
+export interface InternalBaseAtom<T> extends Subscribable<T>, Readable<T> {
+    /** @internal */
+    _snapshot: T;
+    /** @internal */
+    _update: (getValue?: T | ((snapshot: T) => T)) => boolean;
+}
+export interface Atom<T> extends BaseAtom<T> {
+    /** Sets the value of the atom using a function. */
+    set: ((fn: (prevVal: T) => T) => void) & ((value: T) => void);
+}
+export interface AtomOptions<T> {
+    compare?: (prev: T, next: T) => boolean;
+}
+export type AnyAtom = BaseAtom<any>;
+export interface InternalReadonlyAtom<T> extends InternalBaseAtom<T>, ReactiveNode {
 }
 /**
- * @private
- */
-export type Listener<T> = (value: ListenerValue<T>) => void;
-/**
- * Type guard to check if updater is a function
+ * An atom that is read-only and cannot be set.
+ *
+ * @example
+ *
+ * ```ts
+ * const atom = createAtom(() => 42);
+ * // @ts-expect-error - Cannot set a readonly atom
+ * atom.set(43);
+ * ```
  */
-export declare function isUpdaterFunction<T>(updater: Updater<T>): updater is (prev: T) => T;
+export interface ReadonlyAtom<T> extends BaseAtom<T> {
+}

package/dist/esm/alien.d.ts

@@ -0,0 +1,57 @@
+export interface ReactiveNode {
+    deps?: Link;
+    depsTail?: Link;
+    subs?: Link;
+    subsTail?: Link;
+    flags: ReactiveFlags;
+}
+export interface Link {
+    version: number;
+    dep: ReactiveNode;
+    sub: ReactiveNode;
+    prevSub: Link | undefined;
+    nextSub: Link | undefined;
+    prevDep: Link | undefined;
+    nextDep: Link | undefined;
+}
+export declare const enum ReactiveFlags {
+    None = 0,
+    Mutable = 1,
+    Watching = 2,
+    RecursedCheck = 4,
+    Recursed = 8,
+    Dirty = 16,
+    Pending = 32
+}
+export declare function createReactiveSystem({ update, notify, unwatched, }: {
+    update(sub: ReactiveNode): boolean;
+    notify(sub: ReactiveNode): void;
+    unwatched(sub: ReactiveNode): void;
+}): {
+    link: (dep: ReactiveNode, sub: ReactiveNode, version: number) => void;
+    unlink: (link: Link, sub?: ReactiveNode) => Link | undefined;
+    propagate: (link: Link) => void;
+    checkDirty: (link: Link, sub: ReactiveNode) => boolean;
+    shallowPropagate: (link: Link) => void;
+};
+export declare function getActiveSub(): ReactiveNode | undefined;
+export declare function setActiveSub(sub?: ReactiveNode): ReactiveNode | undefined;
+export declare function getBatchDepth(): number;
+export declare function startBatch(): void;
+export declare function endBatch(): void;
+export declare function isSignal(fn: () => void): boolean;
+export declare function isComputed(fn: () => void): boolean;
+export declare function isEffect(fn: () => void): boolean;
+export declare function isEffectScope(fn: () => void): boolean;
+export declare function signal<T>(): {
+    (): T | undefined;
+    (value: T | undefined): void;
+};
+export declare function signal<T>(initialValue: T): {
+    (): T;
+    (value: T): void;
+};
+export declare function computed<T>(getter: (previousValue?: T) => T): () => T;
+export declare function effect(fn: () => void): () => void;
+export declare function effectScope(fn: () => void): () => void;
+export declare function trigger(fn: () => void): void;