valdres 0.2.0-pre.12 → 0.2.0-pre.15

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, []);
+    data.values.set(state, new FamilyIndex(state, data).toArray());
     initializedAtomsSet.add(state);
     return data.values.get(state);
   }
@@ -422,28 +422,125 @@ var addSetToSet = (fromSet, toSet) => {
     }
   }
 };
-var findClosestStoreWithAtomInitialized2 = (atom, data) => {
-  if ("parent" in data === false)
-    return data;
-  if (data.values.has(atom))
-    return data;
-  return findClosestStoreWithAtomInitialized2(atom, data.parent);
+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;
+  }
+  toArray() {
+    const arr = [...this.toSet()];
+    arr.__index = this;
+    return arr;
+  }
+}
+var deleteFamilyAtomsFromSet = (family, familyAtoms, data) => {
+  const index = findFamilyIndex(family, data);
+  index.delete(familyAtoms);
+  data.values.set(family, index.toArray());
+  recursivlyUpdateIndexes(data, family);
+};
+var initFamilyIndex = (family, data) => {
+  if (data.values.has(family))
+    return;
+  if ("parent" in data) {
+    initFamilyIndex(family, data.parent);
+    const parentIndex = data.parent.values.get(family).__index;
+    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());
+  }
 };
-var findInClosestStore = (state, data) => {
-  const store = findClosestStoreWithAtomInitialized2(state, data);
-  return store.values.get(state);
+var findFamilyIndex = (family, data) => {
+  if (!data.values.has(family)) {
+    initFamilyIndex(family, data);
+  }
+  const value = data.values.get(family);
+  if (!value?.__index) {
+    console.log("value", value);
+    throw new Error("Family index is missing");
+  }
+  return value.__index;
+};
+var recursivlyUpdateIndexes = (data, family) => {
+  Object.keys(data.scopes).forEach((scopeKey) => {
+    const scopedData = data.scopes[scopeKey];
+    if (scopeKey) {
+      if (scopedData.values.has(family)) {
+        scopedData.values.set(family, scopedData.values.get(family).__index.toArray());
+      }
+      recursivlyUpdateIndexes(scopedData, family);
+    }
+  });
 };
 var addFamilyAtomsToSet = (family, familyAtoms, data) => {
-  const currentAtoms = findInClosestStore(family, data) || [];
-  const atomsToAdd = [];
-  for (const familyAtom of familyAtoms) {
-    if (!currentAtoms.includes(familyAtom)) {
-      atomsToAdd.push(familyAtom);
+  const index = findFamilyIndex(family, data);
+  index.add(familyAtoms);
+  data.values.set(family, index.toArray());
+  recursivlyUpdateIndexes(data, family);
+};
+var propagateDeletedAtoms = (atoms, data, subscriptions = new Set, families = new Map) => {
+  const selectors = new Set;
+  for (const atom of atoms) {
+    addSetToSet(data.stateDependents.get(atom), selectors);
+    addSetToSet(data.subscriptions.get(atom), subscriptions);
+    if (isFamilyAtom(atom)) {
+      if (!families.has(atom.family)) {
+        families.set(atom.family, new Set);
+      }
+      families.get(atom.family).add(atom);
     }
   }
-  if (atomsToAdd.length > 0) {
-    data.values.set(family, [...currentAtoms, ...atomsToAdd]);
+  if (families.size > 0) {
+    for (const [family, familyAtoms] of families) {
+      addSetToSet(data.stateDependents.get(family), selectors);
+      addSetToSet(data.subscriptions.get(family), subscriptions);
+      if (familyAtoms.size === 0)
+        throw new Error("Should not be possible");
+      deleteFamilyAtomsFromSet(family, familyAtoms, data);
+    }
   }
+  propagateDirtySelectors(atoms, selectors, data, subscriptions, families);
 };
 var propagateUpdatedAtoms = (atoms, data, subscriptions = new Set, families = new Map, isRecursive = false) => {
   const selectors = new Set;
@@ -550,16 +647,8 @@ function createStoreData(id, parent) {
 
 // src/lib/deleteFamilyAtom.ts
 var deleteFamilyAtom = (atom, data) => {
-  const array = data.values.get(atom.family);
-  const index = array.indexOf(atom);
-  const newArray = [
-    ...array.slice(0, index),
-    ...array.slice(index + 1)
-  ];
   data.values.delete(atom);
-  propagateUpdatedAtoms([atom], data);
-  setValueInData(atom.family, newArray, data);
-  propagateUpdatedAtoms([atom.family], data);
+  propagateDeletedAtoms([atom], data);
 };
 
 // src/lib/resetAtom.ts
@@ -802,21 +891,19 @@ class Transaction {
       this.dirty = true;
     if (isFamilyAtom(atom)) {
       const currentFamilyList = this.get(atom.family);
-      if (!currentFamilyList.includes(atom)) {
-        const newArr = [...currentFamilyList, atom];
-        this.atomMap.set(atom.family, newArr);
+      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());
       }
     }
     return value;
   };
   del = (atom) => {
-    const array = this.get(atom.family);
-    const index = array.indexOf(atom);
-    const newArr = [
-      ...array.slice(0, index),
-      ...array.slice(index + 1)
-    ];
-    this.atomMap.set(atom.family, newArr);
+    const index = this.get(atom.family).__index;
+    const cloned = index.clone();
+    cloned.delete([atom]);
+    this.atomMap.set(atom.family, cloned.toArray());
     if (this.data.values.has(atom)) {
       this.deleteSet.add(atom);
     }
@@ -831,6 +918,12 @@ class Transaction {
       throw new Error(`Scope '${scopeId}' not found. Registered scopes: ${Object.keys(this.data.scopes).join(", ")}`);
     }
   };
+  parentScope = (callback) => {
+    if (!this._parentTransaction) {
+      this._parentTransaction = new Transaction(this.data.parent);
+    }
+    return this._parentTransaction.execute(callback, false);
+  };
   reset = (atom) => {
     const value = getAtomInitValue(atom, this.data, this.initializedAtomsSet);
     this.atomMap.set(atom, value);
@@ -853,6 +946,9 @@ class Transaction {
         scopedTxn.commit();
       }
     }
+    if (this._parentTransaction) {
+      this._parentTransaction.commit();
+    }
   };
   get atomMap() {
     if (!this._atomMap)
@@ -1298,9 +1394,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.12"}`);
+  throw new Error(`Error! An instance of valdres is already loaded. Loaded: ${globalThis.__valdres__}. Attempted to load: ${"0.2.0-pre.15"}`);
 } else {
-  globalThis.__valdres__ = "0.2.0-pre.12";
+  globalThis.__valdres__ = "0.2.0-pre.15";
 }
 export {
   store,

package/dist/types/indexConstructor.d.ts

@@ -1,5 +1,5 @@
 import type { AtomFamily } from "./types/AtomFamily";
 import type { Selector } from "./types/Selector";
-export declare const index: <Term, Value extends unknown, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(family: AtomFamily<Value, FamilyArgs>, callback: (value: Value, term: Term) => boolean, options?: {
+export declare const index: <Term, Value extends any, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(family: AtomFamily<Value, FamilyArgs>, callback: (value: Value, term: Term) => boolean, options?: {
     name?: string;
 }) => ((term: Term) => Selector<Term[]>);

package/dist/types/lib/createAtomFamily.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 createAtomFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options?: AtomOptions<Value>) => AtomFamily<Value, Args>;
+export declare const createAtomFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options?: AtomOptions<Value>) => AtomFamily<Value, Args>;

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 unknown, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;
+export declare const createGlobalAtomFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(defaultValue: AtomFamilyDefaultValue<Value, Args>, options: AtomOptions<Value>) => AtomFamily<Value, Args>;

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

@@ -1,8 +1,8 @@
 import type { Atom } from "../types/Atom";
 import type { AtomFamily } from "../types/AtomFamily";
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 import type { Selector } from "../types/Selector";
 import type { StoreData } from "../types/StoreData";
-import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 export declare function getState<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value>, data: StoreData, initializedAtomsSet: Set<Atom>, circularDependencySet?: WeakSet<Selector>): Value;
 export declare function getState<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(selector: Selector<Value>, data: StoreData, initializedAtomsSet: Set<Atom>, circularDependencySet?: WeakSet<Selector>): Value;
 export declare function getState<Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(family: AtomFamily<Value, Args>, data: StoreData, initializedAtomsSet: Set<Atom>, circularDependencySet?: WeakSet<Selector>): AtomFamilyAtom<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 unknown, Args extends [any, ...any[]] = [any, ...any[]]>(atom: Atom<Value> | AtomFamilyAtom<Value, Args>, data: StoreData, initializedAtomsSet: Set<Atom>) => void;
+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;

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

@@ -5,6 +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 propagateDirtySelectors: (updatedAtoms: Atom[], selectors: Set<Selector>, data: StoreData, subscriptions: Set<Subscription>, families: Map<AtomFamily<any>, Set<AtomFamilyAtom<any>>>) => void;

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

@@ -19,6 +19,7 @@ export declare class Transaction {
     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;
+    parentScope: (callback: (txn: Transaction) => any) => any;
     reset: (atom: Atom) => any;
     execute: (callback: TransactionFn, autoCommit?: boolean) => any;
     commit: () => void;

package/dist/types/selector.d.ts

@@ -1,4 +1,4 @@
 import type { GetValue } from "./types/GetValue";
 import type { Selector } from "./types/Selector";
 import type { SelectorOptions } from "./types/SelectorOptions";
-export declare const selector: <Value extends unknown, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(get: (get: GetValue, storeId: string) => Value | Promise<Value>, options?: SelectorOptions<Value>) => Selector<Value, FamilyArgs>;
+export declare const selector: <Value extends any, FamilyArgs extends [any, ...any[]] = [any, ...any[]]>(get: (get: GetValue, storeId: string) => Value | Promise<Value>, options?: SelectorOptions<Value>) => Selector<Value, FamilyArgs>;

package/dist/types/selectorFamily.d.ts

@@ -1,4 +1,4 @@
 import type { GetValue } from "./types/GetValue";
 import type { SelectorFamily } from "./types/SelectorFamily";
 import type { SelectorOptions } from "./types/SelectorOptions";
-export declare const selectorFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(callback: (...args: Args) => (get: GetValue) => Value | Promise<Value>, options?: SelectorOptions<Value>) => SelectorFamily<Value, Args>;
+export declare const selectorFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(callback: (...args: Args) => (get: GetValue) => Value | Promise<Value>, options?: SelectorOptions<Value>) => SelectorFamily<Value, Args>;

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

@@ -1,2 +1,2 @@
 import type { AtomFamily } from "../types/AtomFamily";
-export declare const isAtomFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamily<Value, Args>;
+export declare const isAtomFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamily<Value, Args>;

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

@@ -1,2 +1,2 @@
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
-export declare const isFamilyAtom: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilyAtom<Value, Args>;
+export declare const isFamilyAtom: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilyAtom<Value, Args>;

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

@@ -1,2 +1,2 @@
 import type { AtomFamilySelector } from "../types/AtomFamilySelector";
-export declare const isFamilySelector: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilySelector<Value, Args>;
+export declare const isFamilySelector: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilySelector<Value, Args>;

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

@@ -1,3 +1,3 @@
 import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 import type { AtomFamilySelector } from "../types/AtomFamilySelector";
-export declare const isFamilyState: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilyAtom<Value, Args> | AtomFamilySelector<Value, Args>;
+export declare const isFamilyState: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is AtomFamilyAtom<Value, Args> | AtomFamilySelector<Value, Args>;

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

@@ -1,2 +1,2 @@
 import type { SelectorFamily } from "../types/SelectorFamily";
-export declare const isSelectorFamily: <Value extends unknown, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is SelectorFamily<Value, Args>;
+export declare const isSelectorFamily: <Value extends any, Args extends [any, ...any[]] = [any, ...any[]]>(state: any) => state is SelectorFamily<Value, Args>;

package/package.json

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