valdres 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/index.js

@@ -417,96 +417,97 @@ var evaluateSelector = (selector, data, initializedAtomsSet, circularDependencyS
     throw new SelectorCircularDependencyError;
   }
   circularDependencySet.add(selector);
-  const prev = data.abortControllers.get(selector);
-  let options;
-  if (prev === false) {
-    let cached = syncOptionsCache.get(data);
-    if (!cached) {
-      cached = { signal: neverAbortedSignal, storeId: data.id };
-      syncOptionsCache.set(data, cached);
-    }
-    options = cached;
-  } else {
-    if (prev)
-      prev.abort();
-    const abortController = new AbortController;
-    data.abortControllers.set(selector, abortController);
-    options = { signal: abortController.signal, storeId: data.id };
-  }
-  let allDepsThisEval;
-  let result;
   try {
-    result = selector.get((state) => {
-      if (evaluationComplete) {
-        if (!evalCtx.revoked && allDepsThisEval) {
-          allDepsThisEval.add(state);
+    const prev = data.abortControllers.get(selector);
+    let options;
+    if (prev === false) {
+      let cached = syncOptionsCache.get(data);
+      if (!cached) {
+        cached = { signal: neverAbortedSignal, storeId: data.id };
+        syncOptionsCache.set(data, cached);
+      }
+      options = cached;
+    } else {
+      if (prev)
+        prev.abort();
+      const abortController = new AbortController;
+      data.abortControllers.set(selector, abortController);
+      options = { signal: abortController.signal, storeId: data.id };
+    }
+    let allDepsThisEval;
+    let result;
+    try {
+      result = selector.get((state) => {
+        if (evaluationComplete) {
+          if (!evalCtx.revoked && allDepsThisEval) {
+            allDepsThisEval.add(state);
+          }
+          if (evalCtx.revoked) {
+            return getState(state, data, new Set);
+          }
+          return lateGet(state, selector, data);
         }
-        if (evalCtx.revoked) {
-          return getState(state, data, new Set);
+        const value = getState(state, data, initializedAtomsSet, circularDependencySet);
+        updatedDepsArray.push(state);
+        if (!depsChanged && (!currentDependencies || !currentDependencies.has(state))) {
+          depsChanged = true;
         }
-        return lateGet(state, selector, data);
-      }
-      const value = getState(state, data, initializedAtomsSet, circularDependencySet);
-      updatedDepsArray.push(state);
-      if (!depsChanged && (!currentDependencies || !currentDependencies.has(state))) {
-        depsChanged = true;
+        if (isPromiseLike(value))
+          throw new SuspendAndWaitForResolveError(value);
+        return value;
+      }, options);
+    } catch (error) {
+      if (error instanceof NeedsInitError)
+        throw error;
+      if (error instanceof SuspendAndWaitForResolveError) {
+        result = error;
+      } else if (error instanceof SelectorEvaluationError) {
+        throw error;
+      } else {
+        throw new SelectorEvaluationError(error);
       }
-      if (isPromiseLike(value))
-        throw new SuspendAndWaitForResolveError(value);
-      return value;
-    }, options);
-  } catch (error) {
-    if (error instanceof NeedsInitError) {
-      circularDependencySet.delete(selector);
-      throw error;
-    }
-    if (error instanceof SuspendAndWaitForResolveError) {
-      result = error;
-    } else if (error instanceof SelectorEvaluationError) {
-      throw error;
-    } else {
-      throw new SelectorEvaluationError(error);
     }
-  }
-  evaluationComplete = true;
-  const isAsyncResult = result instanceof SuspendAndWaitForResolveError || isPromiseLike(result);
-  if (!isAsyncResult && !depsChanged && currentDependencies && currentDependencies.size !== updatedDepsArray.length) {
-    depsChanged = true;
-  }
-  if (depsChanged || !currentDependencies) {
-    const updatedDependencies = new Set(updatedDepsArray);
-    if (isAsyncResult && currentDependencies) {
-      for (const dep of currentDependencies) {
-        updatedDependencies.add(dep);
-      }
+    evaluationComplete = true;
+    const isAsyncResult = result instanceof SuspendAndWaitForResolveError || isPromiseLike(result);
+    if (!isAsyncResult && !depsChanged && currentDependencies && currentDependencies.size !== updatedDepsArray.length) {
+      depsChanged = true;
     }
-    const prev2 = currentDependencies ?? new Set;
-    for (const state of updatedDependencies) {
-      if (!prev2.has(state)) {
-        const set = getOrInitDependentsSet(state, data);
-        set.add(selector);
-        if (addedDepsOut)
-          addedDepsOut.add(state);
+    if (depsChanged || !currentDependencies) {
+      const updatedDependencies = new Set(updatedDepsArray);
+      if (isAsyncResult && currentDependencies) {
+        for (const dep of currentDependencies) {
+          updatedDependencies.add(dep);
+        }
       }
-    }
-    if (!isAsyncResult) {
-      for (const state of prev2) {
-        if (!updatedDependencies.has(state)) {
+      const prev2 = currentDependencies ?? new Set;
+      for (const state of updatedDependencies) {
+        if (!prev2.has(state)) {
           const set = getOrInitDependentsSet(state, data);
-          set.delete(selector);
-          if (removedDepsOut)
-            removedDepsOut.add(state);
+          set.add(selector);
+          if (addedDepsOut)
+            addedDepsOut.add(state);
         }
       }
+      if (!isAsyncResult) {
+        for (const state of prev2) {
+          if (!updatedDependencies.has(state)) {
+            const set = getOrInitDependentsSet(state, data);
+            set.delete(selector);
+            if (removedDepsOut)
+              removedDepsOut.add(state);
+          }
+        }
+      }
+      data.stateDependencies.set(selector, updatedDependencies);
     }
-    data.stateDependencies.set(selector, updatedDependencies);
-  }
-  if (isPromiseLike(result)) {
-    allDepsThisEval = new Set(updatedDepsArray);
-    pendingAsyncDeps.set(result, allDepsThisEval);
+    if (isPromiseLike(result)) {
+      allDepsThisEval = new Set(updatedDepsArray);
+      pendingAsyncDeps.set(result, allDepsThisEval);
+    }
+    return result;
+  } finally {
+    circularDependencySet.delete(selector);
   }
-  circularDependencySet.delete(selector);
-  return result;
 };
 var handleSelectorResult = (value, selector, data) => {
   if (value instanceof SuspendAndWaitForResolveError) {
@@ -1566,14 +1567,17 @@ class Transaction {
   set = (atom, value) => {
     if (!isAtom(atom))
       throw new Error("Not an atom");
+    let resolved;
     if (isFunction(value)) {
       const currentValue = this.get(atom);
-      value = value(currentValue);
+      resolved = value(currentValue);
+    } else {
+      resolved = value;
     }
-    if (!atom.mutable && !isProd() && value !== null && (typeof value === "object" || typeof value === "function")) {
-      value = deepFreeze(value);
+    if (!atom.mutable && !isProd() && resolved !== null && (typeof resolved === "object" || typeof resolved === "function")) {
+      resolved = deepFreeze(resolved);
     }
-    this._atomMap.set(atom, value);
+    this._atomMap.set(atom, resolved);
     if (!this.dirty)
       this.dirty = true;
     if (isFamilyAtom(atom)) {
@@ -1587,7 +1591,7 @@ class Transaction {
       index.renderedArray = null;
       this.recursivelyUpdateAtomFamilyIndexes(atom.family);
     }
-    return value;
+    return resolved;
   };
   batchSetFamilyAtoms = (family, pairs) => {
     if (!this._atomMap.has(family)) {
@@ -2399,9 +2403,9 @@ var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 
 // src/index.ts
 if (globalThis.__valdres__) {
-  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.0"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"1.0.0-beta.2"}`);
 } else {
-  globalThis.__valdres__ = "1.0.0-beta.0";
+  globalThis.__valdres__ = "1.0.0-beta.2";
 }
 export {
   store,

package/dist/types/atomFamily.d.ts

@@ -1,3 +1,13 @@
+import type { AtomFamily } from "./types/AtomFamily";
 import type { AtomFamilyDefaultValue } from "./types/AtomFamilyDefaultValue";
+import type { AtomFamilyAtom } from "./types/AtomFamilyAtom";
 import type { AtomOptions } from "./types/AtomOptions";
-export declare function atomFamily<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue?: AtomFamilyDefaultValue<Value, Args>, options?: AtomOptions<Value>): import(".").AtomFamily<Value, Args>;
+import type { GlobalAtom } from "./types/GlobalAtom";
+type GlobalAtomFamily<Value, Args extends [any, ...any[]] = [any, ...any[]]> = Omit<AtomFamily<Value, Args>, never> & {
+    (...args: Args): AtomFamilyAtom<Value, Args> & GlobalAtom<Value>;
+};
+export declare function atomFamily<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args> | undefined, options: AtomOptions<Value> & {
+    global: true;
+}): GlobalAtomFamily<Value, Args>;
+export declare function atomFamily<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue?: AtomFamilyDefaultValue<Value, Args>, options?: AtomOptions<Value>): AtomFamily<Value, Args>;
+export {};

package/dist/types/index.d.ts

@@ -27,12 +27,16 @@ export type { AtomFamily } from "./types/AtomFamily";
 export type { FamilyKey } from "./types/FamilyKey";
 export type { GetValue } from "./types/GetValue";
 export type { Reactive } from "./types/Reactive";
-export type { GlobalAtom } from "./types/GlobalAtom";
+export type { GlobalAtom, MaxAgeInterval } from "./types/GlobalAtom";
+export type { GlobalAtomGetSelfFunc } from "./types/GlobalAtomGetSelfFunc";
+export type { GlobalAtomResetSelfFunc } from "./types/GlobalAtomResetSelfFunc";
+export type { GlobalAtomSetSelfFunc } from "./types/GlobalAtomSetSelfFunc";
 export type { ResetAtom } from "./types/ResetAtom";
 export type { Selector, SelectorGetOptions } from "./types/Selector";
 export type { SelectorFamily } from "./types/SelectorFamily";
 export type { SetAtom } from "./types/SetAtom";
 export type { SetAtomValue } from "./types/SetAtomValue";
+export type { SyncSetAtom } from "./types/SyncSetAtom";
 export type { State } from "./types/State";
 export type { Store } from "./types/Store";
 export type { StoreData } from "./types/StoreData";

package/dist/types/lib/createGlobalAtomFamily.d.ts

@@ -1,4 +1,4 @@
 import type { AtomFamily } from "../types/AtomFamily";
 import type { AtomFamilyDefaultValue } from "../types/AtomFamilyDefaultValue";
 import type { AtomOptions } from "../types/AtomOptions";
-export declare const createGlobalAtomFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;
+export declare const createGlobalAtomFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;

package/dist/types/lib/initAtom.d.ts

@@ -2,4 +2,4 @@ import type { Atom } from "../types/Atom";
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 import type { StoreData } from "../types/StoreData";
 export declare const getAtomInitValue: <V = any>(atom: Atom<V>, data: StoreData, initializedAtomsSet: Set<Atom>) => any;
-export declare const initAtom: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value> | AtomFamilyAtom<Value, Args>, data: StoreData, initializedAtomsSet: Set<Atom>) => void;
+export declare const initAtom: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value> | AtomFamilyAtom<Value, Args>, data: StoreData, initializedAtomsSet: Set<Atom>) => void;

package/dist/types/lib/initSelector.d.ts

@@ -19,6 +19,6 @@ export declare let _evalDepth: number;
  *  Each level uses ~8-10 JS stack frames, so 100 levels ≈ 800-1000 frames,
  *  safely under the typical ~10000 frame limit. */
 export declare const MAX_EVAL_DEPTH = 100;
-export declare const evaluateSelector: <V>(selector: Selector<V>, data: StoreData, initializedAtomsSet: Set<Atom>, circularDependencySet?: WeakSet<WeakKey>, addedDepsOut?: Set<State>, removedDepsOut?: Set<State>) => SuspendAndWaitForResolveError | V | Promise<V>;
-export declare const handleSelectorResult: <Value>(value: Value | Promise<Value> | SuspendAndWaitForResolveError, selector: Selector<Value>, data: StoreData) => Promise<any> | Value;
+export declare const evaluateSelector: <V>(selector: Selector<V>, data: StoreData, initializedAtomsSet: Set<Atom>, circularDependencySet?: WeakSet<WeakKey>, addedDepsOut?: Set<State>, removedDepsOut?: Set<State>) => V | Promise<V> | SuspendAndWaitForResolveError;
+export declare const handleSelectorResult: <Value>(value: Value | Promise<Value> | SuspendAndWaitForResolveError, selector: Selector<Value>, data: StoreData) => Value | Promise<any>;
 export declare const initSelector: <V>(selector: Selector<V>, data: StoreData, initializedAtomsSet: Set<Atom>, circularDependencySet?: WeakSet<WeakKey>) => boolean;

package/dist/types/lib/transaction.d.ts

@@ -17,7 +17,7 @@ export declare class Transaction {
     private hasTxnOrData;
     private valueFromTxnOrData;
     get: GetValue;
-    set: <V>(atom: Atom<V>, value: V | ((currentValue: V) => V)) => V | ((currentValue: V) => V);
+    set: <V>(atom: Atom<V>, value: V | ((currentValue: V) => V)) => V;
     batchSetFamilyAtoms: (family: any, pairs: any) => void;
     del: (atom: AtomFamilyAtom<any, any>) => void;
     scope: (scopeId: string, callback: (txn: Transaction) => any) => any;

package/dist/types/types/SyncSetAtom.d.ts

@@ -0,0 +1,4 @@
+import type { Atom } from "./Atom";
+export type SyncSetAtom = {
+    <V>(atom: Atom<V>, value: V | ((current: V) => V)): V;
+};

package/dist/types/types/TransactionInterface.d.ts

@@ -1,15 +1,11 @@
-import type { Atom } from "./Atom";
 import type { AtomFamilyAtom } from "./AtomFamilyAtom";
 import type { GetValue } from "./GetValue";
 import type { ResetAtom } from "./ResetAtom";
-import type { SetAtom } from "./SetAtom";
 import type { StoreData } from "./StoreData";
+import type { SyncSetAtom } from "./SyncSetAtom";
 import type { TransactionFn } from "./TransactionFn";
-export type SetAtom2 = {
-    <V>(atom: Atom<V>, value: V): V;
-};
 export type TransactionInterface = {
-    set: SetAtom;
+    set: SyncSetAtom;
     get: GetValue;
     del: (atom: AtomFamilyAtom<any, any>) => void;
     reset: ResetAtom;

package/dist/types/utils/isFamily.d.ts

@@ -1 +1 @@
-export declare const isFamily: (state: any) => state is import("..").SelectorFamily<unknown, [any, ...any[]]> | import("..").AtomFamily<unknown, [any, ...any[]]>;
+export declare const isFamily: (state: any) => state is import("..").AtomFamily<unknown, [any, ...any[]]> | import("..").SelectorFamily<unknown, [any, ...any[]]>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "1.0.0-beta.0",
+    "version": "1.0.0-beta.2",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"