valdres 0.2.0-pre.1 → 0.2.0-pre.10

package/dist/index.js

@@ -1,6 +1,3 @@
-// src/index.ts
-import { version } from "../package.json";
-
 // src/lib/equal.ts
 var hasElementType = typeof Element !== "undefined";
 var hasMap = typeof Map === "function";
@@ -190,7 +187,7 @@ var isProd = () => {
 
 // src/lib/setValueInData.ts
 var setValueInData = (atom, value, data) => {
-  if (isProd()) {
+  if (atom.mutable || isProd()) {
     data.values.set(atom, value);
     return value;
   } else {
@@ -499,18 +496,6 @@ var propagateDirtySelectors = (updatedAtoms, selectors, data, subscriptions, fam
     }
   }
 };
-var findAllDependents = (selector, data, depsRes = new Set, subsRes = new Set) => {
-  const dependents = data.stateDependents.get(selector);
-  const subscriptions = data.subscriptions.get(selector);
-  addSetToSet(dependents, depsRes);
-  addSetToSet(subscriptions, subsRes);
-  if (dependents && dependents.size > 0) {
-    for (const dependent of dependents) {
-      findAllDependents(dependent, data, depsRes, subsRes);
-    }
-  }
-  return [depsRes, subsRes];
-};
 var recursivlyHandleSelectorUpdates = (selectors, data, collectedSubscribers, updatedInitializedAtoms, seen = new Set) => {
   const selectorsForNextPass = new Set;
   for (const selector of selectors) {
@@ -526,23 +511,10 @@ var recursivlyHandleSelectorUpdates = (selectors, data, collectedSubscribers, up
       data.values.delete(selector);
     } else {
       const [wasValueUpdated, didEvalCrash, error] = reEvaluteSelector(selector, data, updatedInitializedAtoms);
-      if (didEvalCrash) {
-        const [deps, subs] = findAllDependents(selector, data);
-        if (deps.size > 0) {
-          for (const dep of deps) {
-            data.expiredValues.set(dep, data.values.get(dep));
-            data.values.delete(dep);
-          }
-        }
-        if (subs.size > 0) {
-          addSetToSet(subs, collectedSubscribers);
-        }
-      } else {
-        if (!wasValueUpdated)
-          continue;
-        addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
-        addSetToSet(subscribers, collectedSubscribers);
-      }
+      if (!wasValueUpdated)
+        continue;
+      addSetToSet(data.stateDependents.get(selector), selectorsForNextPass);
+      addSetToSet(subscribers, collectedSubscribers);
     }
   }
   if (selectorsForNextPass.size > 0) {
@@ -756,174 +728,171 @@ var setAtoms = (pairs, data, initializedAtomsSet) => {
 };
 
 // src/lib/transaction.ts
-var findDependencies = (state, data, result = new Set) => {
-  const dependents = data.stateDependents.get(state);
-  if (dependents?.size) {
-    for (const dependent of dependents) {
-      if (!result.has(dependent)) {
-        result.add(dependent);
-        findDependencies(dependent, data, result);
-      }
-    }
-  }
-  return result;
-};
-var recursivlyResetTxnSelectorCache = (state, txnSubscribers, txnSelectorCache) => {
-  for (const dep of txnSubscribers.get(state)) {
-    txnSelectorCache.delete(dep);
-    if (txnSubscribers.get(dep)?.size) {
-      recursivlyResetTxnSelectorCache(dep, txnSubscribers, txnSelectorCache);
-    }
-  }
-};
-var captureScopedTransaction = (scopedData, parentGetInTxnOrData) => {
-  let txn;
-  transaction((scopedTxn) => {
-    txn = scopedTxn;
-  }, scopedData, false, parentGetInTxnOrData);
-  return txn;
-};
 var deleteAtomFamilyAtoms = (set, data) => {
   set.forEach((atom) => {
     data.values.delete(atom);
   });
 };
-var transaction = (callback, data, autoCommit = true, parentGetInTxnOrData) => {
-  const txnAtomMap = new Map;
-  const txnAtomDeleteSet = new Set;
-  const txnSelectorCache = new Map;
-  const txnSubscribers = new Map;
-  const dirtySelectors = new Set;
-  let scopedTransactions;
-  const getInTxnOrData = (state) => {
-    if (txnAtomMap.has(state)) {
-      return txnAtomMap.get(state);
+
+class Transaction {
+  data;
+  parentTransaction;
+  dirty;
+  _scopedTransactions;
+  _initializedAtomsSet;
+  _deleteSet;
+  _selectorDependencies;
+  _selectorCache;
+  _atomMap;
+  constructor(data, parentTransaction) {
+    this.data = data;
+    this.parentTransaction = parentTransaction;
+    this.dirty = false;
+  }
+  valueFromTxnOrData = (state) => {
+    if (this.atomMap.has(state)) {
+      return this.atomMap.get(state);
     }
-    if (data.values.has(state)) {
-      return data.values.get(state);
+    if (this.data.values.has(state)) {
+      return this.data.values.get(state);
     }
-    if (parentGetInTxnOrData) {
-      return parentGetInTxnOrData(state);
+    if (this.parentTransaction) {
+      return this.parentTransaction.valueFromTxnOrData(state);
     }
   };
-  const initializedAtomsSet = new Set;
-  const txnGet = (state) => {
-    if (isAtom(state)) {
-      const value = getInTxnOrData(state);
+  get = (state) => {
+    if (isAtom(state) || isAtomFamily(state)) {
+      const value = this.valueFromTxnOrData(state);
       if (value)
         return value;
-      return getState(state, data, initializedAtomsSet);
+      return getState(state, this.data, this.initializedAtomsSet);
     } else if (isSelector(state)) {
-      if (txnSelectorCache.has(state)) {
-        return txnSelectorCache.get(state);
+      if (this.dirty) {
+        this.selectorCache.clear();
+        this.selectorDependencies.clear();
+        this.dirty = false;
+      } else if (this.selectorCache.has(state)) {
+        return this.selectorCache.get(state);
       }
-      const deps = new Set;
       const res = state.get((s) => {
-        deps.add(s);
-        return txnGet(s);
-      }, data.id);
-      for (const dep of deps) {
-        if (!txnSubscribers.has(dep)) {
-          txnSubscribers.set(dep, new Set);
+        if (!this.selectorDependencies.has(s)) {
+          this.selectorDependencies.add(s);
         }
-        txnSubscribers.get(dep).add(state);
-      }
-      txnSelectorCache.set(state, res);
+        return this.get(s);
+      }, this.data.id);
+      this.selectorCache.set(state, res);
       return res;
-    } else if (isAtomFamily(state)) {
-      const value = getInTxnOrData(state);
-      if (value)
-        return value;
-      return getState(state, data, initializedAtomsSet);
     } else {
       throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom, value) => {
+  set = (atom, value) => {
     if (!isAtom(atom))
       throw new Error("Not an atom");
     if (isFunction(value)) {
-      const currentValue = txnGet(atom);
+      const currentValue = this.get(atom);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom, data)) {
-      dirtySelectors.add(selector);
-      txnSelectorCache.delete(selector);
-    }
-    if (txnSubscribers.get(atom)?.size) {
-      recursivlyResetTxnSelectorCache(atom, txnSubscribers, txnSelectorCache);
-    }
     if (isProd()) {
-      txnAtomMap.set(atom, value);
+      this.atomMap.set(atom, value);
     } else {
-      txnAtomMap.set(atom, deepFreeze(value));
+      this.atomMap.set(atom, deepFreeze(value));
     }
+    if (!this.dirty)
+      this.dirty = true;
     if (isFamilyAtom(atom)) {
-      const currentFamilyList = txnGet(atom.family);
+      const currentFamilyList = this.get(atom.family);
       if (!currentFamilyList.includes(atom)) {
         const newArr = [...currentFamilyList, atom];
-        txnAtomMap.set(atom.family, newArr);
+        this.atomMap.set(atom.family, newArr);
       }
     }
     return value;
   };
-  const txnReset = (atom) => {
-    const value = getAtomInitValue(atom, data, initializedAtomsSet);
-    txnAtomMap.set(atom, value);
-    return value;
-  };
-  const txnDel = (atom) => {
-    const array = txnGet(atom.family);
+  del = (atom) => {
+    const array = this.get(atom.family);
     const index = array.indexOf(atom);
     const newArr = [
       ...array.slice(0, index),
       ...array.slice(index + 1)
     ];
-    txnAtomMap.set(atom.family, newArr);
-    if (data.values.has(atom)) {
-      txnAtomDeleteSet.add(atom);
+    this.atomMap.set(atom.family, newArr);
+    if (this.data.values.has(atom)) {
+      this.deleteSet.add(atom);
     }
-    if (txnAtomMap.has(atom)) {
-      txnAtomMap.delete(atom);
+    if (this.atomMap.has(atom)) {
+      this.atomMap.delete(atom);
     }
   };
-  const commit = () => {
-    setAtoms(txnAtomMap, data, initializedAtomsSet);
-    if (txnAtomDeleteSet.size) {
-      deleteAtomFamilyAtoms(txnAtomDeleteSet, data);
+  scope = (scopeId, callback) => {
+    if (scopeId in this.data.scopes) {
+      return this.scopedTransaction(scopeId).execute(callback, false);
+    } else {
+      throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(this.data.scopes).join(", ")}`);
+    }
+  };
+  reset = (atom) => {
+    const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
+    this.atomMap.set(atom, value);
+    return value;
+  };
+  execute = (callback, autoCommit = true) => {
+    const result = callback(this);
+    if (autoCommit)
+      this.commit();
+    return result;
+  };
+  commit = () => {
+    const initializedAtomsSet = new Set;
+    setAtoms(this.atomMap, this.data, initializedAtomsSet);
+    if (this.deleteSet?.size) {
+      deleteAtomFamilyAtoms(this.deleteSet, this.data);
     }
-    dirtySelectors.clear();
-    if (scopedTransactions) {
-      for (const scopedTxn of Object.values(scopedTransactions)) {
+    if (this._scopedTransactions) {
+      for (const scopedTxn of Object.values(this._scopedTransactions)) {
         scopedTxn.commit();
       }
     }
   };
-  const result = callback({
-    set: txnSet,
-    get: txnGet,
-    del: txnDel,
-    reset: txnReset,
-    commit,
-    scope: (scopeId, callback2) => {
-      if (scopeId in data.scopes) {
-        const scopedData = data.scopes[scopeId];
-        if (scopedTransactions === undefined) {
-          scopedTransactions = {};
-        }
-        if (scopedTransactions[scopeId] === undefined) {
-          scopedTransactions[scopeId] = captureScopedTransaction(scopedData, getInTxnOrData);
-        }
-        return callback2(scopedTransactions[scopeId]);
-      } else {
-        throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(data.scopes).join(", ")}`);
-      }
-    },
-    data
-  });
-  if (autoCommit)
-    commit();
-  return result;
+  get atomMap() {
+    if (!this._atomMap)
+      this._atomMap = new Map;
+    return this._atomMap;
+  }
+  get selectorCache() {
+    if (!this._selectorCache)
+      this._selectorCache = new Map;
+    return this._selectorCache;
+  }
+  get selectorDependencies() {
+    if (!this._selectorDependencies)
+      this._selectorDependencies = new Set;
+    return this._selectorDependencies;
+  }
+  get deleteSet() {
+    if (!this._deleteSet)
+      this._deleteSet = new Set;
+    return this._deleteSet;
+  }
+  get initializedAtomsSet() {
+    if (!this._initializedAtomsSet)
+      this._initializedAtomsSet = new Set;
+    return this._initializedAtomsSet;
+  }
+  scopedTransaction(scopeId) {
+    if (!this._scopedTransactions)
+      this._scopedTransactions = {};
+    if (!this._scopedTransactions[scopeId]) {
+      const scopedData = this.data.scopes[scopeId];
+      const scopedTransaction = new Transaction(scopedData, this);
+      this._scopedTransactions[scopeId] = scopedTransaction;
+    }
+    return this._scopedTransactions[scopeId];
+  }
+}
+var transaction = (callback, data) => {
+  const txn = new Transaction(data);
+  return txn.execute(callback);
 };
 
 // src/lib/storeFromStoreData.ts
@@ -1329,9 +1298,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: ${version}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"0.2.0-pre.10"}`);
 } else {
-  globalThis.__valdres__ = version;
+  globalThis.__valdres__ = "0.2.0-pre.10";
 }
 export {
   store,

package/dist/types/{src/index.d.ts → index.d.ts}

@@ -34,3 +34,4 @@ export type { Store } from "./types/Store";
 export type { StoreData } from "./types/StoreData";
 export type { TransactionFn } from "./types/TransactionFn";
 export type { TransactionInterface } from "./types/TransactionInterface";
+export type { Transaction } from "./lib/transaction";

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

@@ -0,0 +1 @@
+export declare const isFunction: (value: any) => value is Function;

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

@@ -0,0 +1,32 @@
+import type { Atom } from "../types/Atom";
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+import type { GetValue } from "../types/GetValue";
+import type { StoreData } from "../types/StoreData";
+import type { TransactionFn } from "../types/TransactionFn";
+export declare class Transaction {
+    data: StoreData;
+    parentTransaction: Transaction | undefined;
+    dirty: boolean;
+    private _scopedTransactions;
+    private _initializedAtomsSet;
+    private _deleteSet;
+    private _selectorDependencies;
+    private _selectorCache;
+    private _atomMap;
+    constructor(data: StoreData, parentTransaction?: Transaction);
+    private valueFromTxnOrData;
+    get: GetValue;
+    set: <V>(atom: Atom<V>, value: V | ((currentValue: V) => V)) => V;
+    del: (atom: AtomFamilyAtom<any, any>) => void;
+    scope: (scopeId: string, callback: (txn: Transaction) => any) => any;
+    reset: (atom: Atom) => any;
+    execute: (callback: TransactionFn, autoCommit?: boolean) => any;
+    commit: () => void;
+    private get atomMap();
+    private get selectorCache();
+    private get selectorDependencies();
+    private get deleteSet();
+    private get initializedAtomsSet();
+    private scopedTransaction;
+}
+export declare const transaction: (callback: TransactionFn, data: StoreData) => any;

package/dist/types/{src/types → types}/Atom.d.ts

@@ -10,5 +10,6 @@ export type Atom<Value = unknown> = {
     onSet?: AtomOnSet<Value>;
     onMount?: () => void | (() => void);
     maxAge?: number;
+    mutable?: boolean;
     staleWhileRevalidate?: number;
 };

package/dist/types/{src/types → types}/AtomFamily.d.ts

@@ -5,5 +5,6 @@ export type AtomFamily<Value extends any, Args extends [any, ...any[]] = [any, .
     release: (...args: Args) => void;
     equal: EqualFunc<Value>;
     name?: string;
+    mutable?: boolean;
     __valdresAtomFamilyMap: Map<Value, AtomFamilyAtom<Value, Args>>;
 };

package/dist/types/{src/types → types}/AtomOptions.d.ts

@@ -8,6 +8,7 @@ export type AtomOptions<Value = unknown> = {
     onSet?: AtomOnSet<Value>;
     onMount?: () => () => void;
     maxAge?: number;
+    mutable?: boolean;
     staleWhileRevalidate?: number;
     equal?: EqualFunc<Value>;
 };

package/dist/types/types/TransactionFn.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from "../lib/transaction";
+export type TransactionFn = (args: Transaction) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-pre.1",
+    "version": "0.2.0-pre.10",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"

package/dist/types/src/lib/isFunction.d.ts

@@ -1 +0,0 @@
-export declare const isFunction: (value: unknown) => value is Function;

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

@@ -1,8 +0,0 @@
-import type { Atom } from "../types/Atom";
-import type { StoreData } from "../types/StoreData";
-import type { TransactionFn } from "../types/TransactionFn";
-type GetAtomValue = {
-    <V>(atom: Atom<V>): V;
-};
-export declare const transaction: (callback: TransactionFn, data: StoreData, autoCommit?: boolean, parentGetInTxnOrData?: GetAtomValue) => any;
-export {};

package/dist/types/src/types/TransactionFn.d.ts

@@ -1,2 +0,0 @@
-import type { TransactionInterface } from "./TransactionInterface";
-export type TransactionFn = (args: TransactionInterface) => any;