valdres 0.2.0-pre.15 → 0.2.0-pre.16

package/dist/index.js

@@ -278,7 +278,7 @@ function getState(state, data, initializedAtomsSet, circularDependencySet) {
       const closestData = findClosestStoreWithAtomInitialized(state, data);
       return getState(state, closestData, initializedAtomsSet, circularDependencySet);
     }
-    data.values.set(state, new FamilyIndex(state, data).toArray());
+    data.values.set(state, renderAtomFamilyIndex(createAtomFamilyIndex()));
     initializedAtomsSet.add(state);
     return data.values.get(state);
   }
@@ -422,74 +422,75 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-class FamilyIndex {
-  map;
-  family;
-  data;
-  parentIndex;
-  constructor(family, data, parentIndex, map) {
-    this.family = family;
-    this.data = data;
-    this.parentIndex = parentIndex;
-    this.map = new Map(map);
-  }
-  add(atoms) {
-    atoms.forEach((atom) => {
-      this.map.set(atom, true);
-    });
-  }
-  delete(atoms) {
-    atoms.forEach((atom) => {
-      this.map.set(atom, false);
-    });
-  }
-  has(atom) {
-    return this.map.has(atom);
-  }
-  clone() {
-    return new FamilyIndex(this.family, this.data, this.parentIndex, this.map);
-  }
-  toSet() {
-    let set;
-    if (this.parentIndex) {
-      set = new Set(this.parentIndex.toSet());
-    } else {
-      set = new Set;
-    }
-    for (const [key, value] of this.map) {
-      if (value === true)
-        set.add(key);
-      if (value === false)
-        set.delete(key);
-    }
-    return set;
+var getAtomFamilyRenderedMap = (index) => {
+  if (index.rendered)
+    return index.rendered;
+  const result = new Map(index.parentIndex ? getAtomFamilyRenderedMap(index.parentIndex) : undefined);
+  for (const [atom, timestamp] of index.created) {
+    result.set(atom, timestamp);
   }
-  toArray() {
-    const arr = [...this.toSet()];
-    arr.__index = this;
-    return arr;
+  for (const [atom, timestamp] of index.deleted) {
+    result.delete(atom, timestamp);
   }
-}
-var deleteFamilyAtomsFromSet = (family, familyAtoms, data) => {
+  index.rendered = result;
+  return result;
+};
+var getSortedKeysByValues = (map) => {
+  return Array.from(map.entries()).sort((a, b) => a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0).map((entry) => entry[0]);
+};
+var renderAtomFamilyIndex = (index) => {
+  if (index.renderedArray) {
+    console.log("Using cached rendered array");
+    return index.renderedArray;
+  }
+  const renderedMap = getAtomFamilyRenderedMap(index);
+  const array = getSortedKeysByValues(renderedMap);
+  array.__index = index;
+  index.renderedArray = array;
+  return array;
+};
+var cloneAtomFamilyIndex = (index, parentIndexOverride) => {
+  return {
+    created: new Map(index.created),
+    deleted: new Map(index.deleted),
+    rendered: null,
+    renderedArray: null,
+    parentIndex: parentIndexOverride || index.parentIndex
+  };
+};
+var createAtomFamilyIndex = (parentIndex) => {
+  return {
+    created: new Map,
+    deleted: new Map,
+    rendered: null,
+    renderedArray: null,
+    parentIndex
+  };
+};
+var deleteFamilyAtomsFromSet = (family, familyAtoms, data, timestamp) => {
+  if (familyAtoms.size === 0)
+    return;
   const index = findFamilyIndex(family, data);
-  index.delete(familyAtoms);
-  data.values.set(family, index.toArray());
+  for (const atom of familyAtoms) {
+    index.deleted.set(atom, timestamp);
+  }
+  index.rendered = null;
+  index.renderedArray = null;
+  data.values.set(family, renderAtomFamilyIndex(index));
   recursivlyUpdateIndexes(data, family);
 };
 var initFamilyIndex = (family, data) => {
   if (data.values.has(family))
-    return;
+    return data.values.get(family).__index;
+  let parentIndex;
   if ("parent" in data) {
-    initFamilyIndex(family, data.parent);
-    const parentIndex = data.parent.values.get(family).__index;
+    parentIndex = initFamilyIndex(family, data.parent);
     if (!parentIndex)
       throw new Error("Parent index is missing");
-    const index = new FamilyIndex(family, data, parentIndex);
-    data.values.set(family, index.toArray());
-  } else {
-    const index = new FamilyIndex(family, data);
-    data.values.set(family, index.toArray());
   }
+  const index = createAtomFamilyIndex(parentIndex);
+  data.values.set(family, renderAtomFamilyIndex(index));
+  return index;
 };
 var findFamilyIndex = (family, data) => {
   if (!data.values.has(family)) {
@@ -507,19 +508,31 @@ var recursivlyUpdateIndexes = (data, family) => {
     const scopedData = data.scopes[scopeKey];
     if (scopeKey) {
       if (scopedData.values.has(family)) {
-        scopedData.values.set(family, scopedData.values.get(family).__index.toArray());
+        const index = scopedData.values.get(family).__index;
+        index.rendered = null;
+        index.renderedArray = null;
+        scopedData.values.set(family, renderAtomFamilyIndex(index));
       }
       recursivlyUpdateIndexes(scopedData, family);
     }
   });
 };
-var addFamilyAtomsToSet = (family, familyAtoms, data) => {
+var addFamilyAtomsToSet = (family, familyAtoms, data, timestamp) => {
+  if (familyAtoms.size === 0)
+    return;
   const index = findFamilyIndex(family, data);
-  index.add(familyAtoms);
-  data.values.set(family, index.toArray());
+  if (!index)
+    throw new Error("index not found");
+  for (const atom of familyAtoms) {
+    index.created.set(atom, timestamp);
+    index.deleted.delete(atom);
+  }
+  index.rendered = null;
+  index.renderedArray = null;
+  data.values.set(family, renderAtomFamilyIndex(index));
   recursivlyUpdateIndexes(data, family);
 };
-var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map) => {
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map, timestamp = performance.now()) => {
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
@@ -537,12 +550,12 @@ var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = ne
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
         throw new Error("Should not be possible");
-      deleteFamilyAtomsFromSet(family, familyAtoms, data);
+      deleteFamilyAtomsFromSet(family, familyAtoms, data, timestamp);
     }
   }
   propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
 };
-var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false) => {
+var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false, timestamp = performance.now()) => {
   const selectors = new Set;
   for (const atom of atoms) {
     addSetToSet(data.stateDependents.get(atom), selectors);
@@ -560,7 +573,7 @@ var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = ne
       addSetToSet(data.subscriptions.get(family), subscriptions);
       if (familyAtoms.size === 0)
         throw new Error("Should not be possible");
-      addFamilyAtomsToSet(family, familyAtoms, data);
+      addFamilyAtomsToSet(family, familyAtoms, data, timestamp);
     }
   }
   if (!isRecursive) {
@@ -833,10 +846,15 @@ class Transaction {
   _selectorDependencies;
   _selectorCache;
   _atomMap;
-  constructor(data, parentTransaction) {
+  constructor(data, parentTransaction, childTransaction) {
     this.data = data;
     this.parentTransaction = parentTransaction;
     this.dirty = false;
+    if (childTransaction) {
+      this._scopedTransactions = new Map([
+        [childTransaction.data.id, childTransaction]
+      ]);
+    }
   }
   valueFromTxnOrData = (state) => {
     if (this.atomMap.has(state)) {
@@ -890,20 +908,29 @@ class Transaction {
     if (!this.dirty)
       this.dirty = true;
     if (isFamilyAtom(atom)) {
-      const currentFamilyList = this.get(atom.family);
-      if (currentFamilyList && !currentFamilyList.__index.has(atom)) {
-        const index = currentFamilyList ? currentFamilyList.__index.clone() : new FamilyIndex(atom.family, this.data);
-        index.add([atom]);
-        this.atomMap.set(atom.family, index.toArray());
+      if (!this.atomMap.has(atom.family)) {
+        this.cloneFamilyIntoTxn(atom.family);
       }
+      const index = this.atomMap.get(atom.family).__index;
+      index.created.set(atom, performance.now());
+      index.deleted.delete(atom);
+      index.rendered = null;
+      index.renderedArray = null;
+      this.recursivlyUpdateAtomFamilyIndexes(atom.family);
     }
     return value;
   };
   del = (atom) => {
-    const index = this.get(atom.family).__index;
-    const cloned = index.clone();
-    cloned.delete([atom]);
-    this.atomMap.set(atom.family, cloned.toArray());
+    if (!this.atomMap.has(atom.family)) {
+      this.cloneFamilyIntoTxn(atom.family);
+    }
+    const index = this.atomMap.get(atom.family).__index;
+    index.created.delete(atom);
+    index.deleted.set(atom, performance.now());
+    index.rendered = null;
+    index.renderedArray = null;
+    this.atomMap.set(atom.family, renderAtomFamilyIndex(index));
+    this.recursivlyUpdateAtomFamilyIndexes(atom.family);
     if (this.data.values.has(atom)) {
       this.deleteSet.add(atom);
     }
@@ -919,10 +946,10 @@ class Transaction {
     }
   };
   parentScope = (callback) => {
-    if (!this._parentTransaction) {
-      this._parentTransaction = new Transaction(this.data.parent);
+    if (!this.parentTransaction) {
+      this.parentTransaction = new Transaction(this.data.parent, undefined, this);
     }
-    return this._parentTransaction.execute(callback, false);
+    return this.parentTransaction.execute(callback, false);
   };
   reset = (atom) => {
     const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
@@ -932,9 +959,16 @@ class Transaction {
   execute = (callback, autoCommit = true) => {
     const result = callback(this);
     if (autoCommit)
-      this.commit();
+      this.txnCommit();
     return result;
   };
+  txnCommit = () => {
+    if (this.parentTransaction) {
+      this.parentTransaction.txnCommit();
+    } else {
+      this.commit();
+    }
+  };
   commit = () => {
     const initializedAtomsSet = new Set;
     setAtoms(this.atomMap, this.data, initializedAtomsSet);
@@ -942,13 +976,10 @@ class Transaction {
       deleteAtomFamilyAtoms(this.deleteSet, this.data);
     }
     if (this._scopedTransactions) {
-      for (const scopedTxn of Object.values(this._scopedTransactions)) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
         scopedTxn.commit();
       }
     }
-    if (this._parentTransaction) {
-      this._parentTransaction.commit();
-    }
   };
   get atomMap() {
     if (!this._atomMap)
@@ -977,13 +1008,37 @@ class Transaction {
   }
   scopedTransaction(scopeId) {
     if (!this._scopedTransactions)
-      this._scopedTransactions = {};
-    if (!this._scopedTransactions[scopeId]) {
+      this._scopedTransactions = new Map;
+    if (!this._scopedTransactions.has(scopeId)) {
       const scopedData = this.data.scopes[scopeId];
       const scopedTransaction = new Transaction(scopedData, this);
-      this._scopedTransactions[scopeId] = scopedTransaction;
+      this._scopedTransactions.set(scopeId, scopedTransaction);
+    }
+    return this._scopedTransactions.get(scopeId);
+  }
+  cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent = true) {
+    if (moveUpIfParent && this.parentTransaction)
+      return this.parentTransaction.cloneFamilyIntoTxn(family, parentIndex, moveUpIfParent);
+    const currentFamilyList = this.get(family);
+    const clonedIndex = cloneAtomFamilyIndex(currentFamilyList.__index, parentIndex);
+    if (this._scopedTransactions?.size) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
+        scopedTxn.cloneFamilyIntoTxn(family, clonedIndex, false);
+      }
+    }
+    this.atomMap.set(family, renderAtomFamilyIndex(clonedIndex));
+  }
+  recursivlyUpdateAtomFamilyIndexes(atomFamily) {
+    const currentIndex = this.atomMap.get(atomFamily).__index;
+    currentIndex.rendered = null;
+    currentIndex.renderedArray = null;
+    const updatedValue = renderAtomFamilyIndex(currentIndex);
+    this.atomMap.set(atomFamily, updatedValue);
+    if (this._scopedTransactions?.size) {
+      for (const [, scopedTxn] of this._scopedTransactions) {
+        scopedTxn.recursivlyUpdateAtomFamilyIndexes(atomFamily);
+      }
     }
-    return this._scopedTransactions[scopeId];
   }
 }
 var transaction = (callback, data) => {
@@ -1031,7 +1086,10 @@ function storeFromStoreData(data, detach) {
       scopedStoreData.scopeConsumers.delete(detach2);
       if (scopedStoreData.scopeConsumers.size === 0) {
         delete data.scopes[scopeId];
+        return true;
       }
+      console.warn(`Scope still has ${scopedStoreData.scopeConsumers.size} consumers, will not detach`);
+      return false;
     };
     scopedStoreData.scopeConsumers.add(detach2);
     const newStore = storeFromStoreData(data.scopes[scopeId], detach2);
@@ -1394,9 +1452,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: ${"0.2.0-pre.15"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"0.2.0-pre.16"}`);
 } else {
-  globalThis.__valdres__ = "0.2.0-pre.15";
+  globalThis.__valdres__ = "0.2.0-pre.16";
 }
 export {
   store,

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

@@ -5,21 +5,21 @@ import type { Family } from "../types/Family";
 import type { Selector } from "../types/Selector";
 import type { StoreData } from "../types/StoreData";
 import type { Subscription } from "../types/Subscription";
-export declare class FamilyIndex {
-    map: Map<AtomFamilyAtom<any>, boolean>;
-    family: Family<any>;
-    data: StoreData;
-    parentIndex: FamilyIndex | undefined;
-    constructor(family: Family<any>, data: StoreData, parentIndex?: FamilyIndex, map?: Map<AtomFamilyAtom<any>, boolean>);
-    add(atoms: AtomFamilyAtom<any>[]): void;
-    delete(atoms: AtomFamilyAtom<any>[]): void;
-    has(atom: AtomFamilyAtom<any>): boolean;
-    clone(): FamilyIndex;
-    toSet(): Set<AtomFamilyAtom<any>>;
-    toArray(): AtomFamilyAtom<any>[];
-}
-export declare const deleteFamilyAtomsFromSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData) => void;
-export declare const addFamilyAtomsToSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData) => void;
-export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>) => void;
-export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>)[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isRecursive?: boolean) => void;
+export declare const renderAtomFamilyIndex: (index: AtomFamilyIndex) => unknown[];
+type AtomFamilyIndex = {
+    created: Map<AtomFamilyAtom<any, any>, Number>;
+    deleted: Map<AtomFamilyAtom<any, any>, Number>;
+    rendered: Map<AtomFamilyAtom<any, any>, Number> | null;
+    renderedArray: (AtomFamilyAtom<any, any>[] & {
+        __index: AtomFamilyIndex;
+    }) | null;
+    parentIndex?: AtomFamilyIndex;
+};
+export declare const cloneAtomFamilyIndex: (index: AtomFamilyIndex, parentIndexOverride?: AtomFamilyIndex) => AtomFamilyIndex;
+export declare const createAtomFamilyIndex: (parentIndex?: AtomFamilyIndex) => AtomFamilyIndex;
+export declare const deleteFamilyAtomsFromSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: number) => void;
+export declare const addFamilyAtomsToSet: (family: Family<any>, familyAtoms: Set<AtomFamilyAtom<any>>, data: StoreData, timestamp: Number) => void;
+export declare const propagateDeletedAtoms: (atoms: AtomFamilyAtom<any, any>[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, timestamp?: number) => void;
+export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any> | AtomFamily<any, any>)[], data: StoreData, subscriptions?: Set<Subscription>, families?: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>, isRecursive?: boolean, timestamp?: number) => void;
 export declare const propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>) => void;
+export {};

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

@@ -13,7 +13,7 @@ export declare class Transaction {
     private _selectorDependencies;
     private _selectorCache;
     private _atomMap;
-    constructor(data: StoreData, parentTransaction?: Transaction);
+    constructor(data: StoreData, parentTransaction?: Transaction, childTransaction?: Transaction);
     private valueFromTxnOrData;
     get: GetValue;
     set: <V>(atom: Atom<V>, value: V | ((currentValue: V) => V)) => V;
@@ -22,6 +22,7 @@ export declare class Transaction {
     parentScope: (callback: (txn: Transaction) => any) => any;
     reset: (atom: Atom) => any;
     execute: (callback: TransactionFn, autoCommit?: boolean) => any;
+    private txnCommit;
     commit: () => void;
     private get atomMap();
     private get selectorCache();
@@ -29,5 +30,7 @@ export declare class Transaction {
     private get deleteSet();
     private get initializedAtomsSet();
     private scopedTransaction;
+    private cloneFamilyIntoTxn;
+    private recursivlyUpdateAtomFamilyIndexes;
 }
 export declare const transaction: (callback: TransactionFn, data: StoreData) => any;

package/package.json

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