valdres 0.2.0-alpha.29 → 0.2.0-alpha.30

package/dist/index.js

@@ -1,31 +1,31 @@
-// src/lib/setAtom.ts
-import equal4 from "fast-deep-equal/es6";
+// src/utils/isAtom.ts
+var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+
+// src/utils/isFamilyState.ts
+var isFamilyState = (state) => state && Object.hasOwn(state, "family");
+
+// src/utils/isFamilyAtom.ts
+var isFamilyAtom = (state) => isFamilyState(state) && isAtom(state);
 
 // src/utils/isPromiseLike.ts
 var isPromiseLike = (object) => {
   return object && object.then && typeof object.then === "function";
 };
 
-// src/lib/getState.ts
-import equal3 from "fast-deep-equal/es6";
+// src/utils/isSelector.ts
+var isSelector = (state) => state && Object.hasOwn(state, "get");
 
-// src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+// src/lib/getState.ts
+import equal2 from "fast-deep-equal/es6";
 
 // src/utils/isAtomFamily.ts
 var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
 
-// src/utils/isSelector.ts
-var isSelector = (state) => state && Object.hasOwn(state, "get");
-
 // src/utils/isSelectorFamily.ts
 var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
 
-// src/utils/isFamilyState.ts
-var isFamilyState = (state) => state && Object.hasOwn(state, "family");
-
-// src/utils/isFamilyAtom.ts
-var isFamilyAtom = (state) => isFamilyState(state) && isAtom(state);
+// src/lib/initSelector.ts
+import equal from "fast-deep-equal/es6";
 
 // src/lib/updateStateSubscribers.ts
 var updateStateSubscribers = (state, data) => {
@@ -45,11 +45,7 @@ var updateStateSubscribers = (state, data) => {
   }
 };
 
-// src/lib/updateSelectorSubscribers.ts
-import equal2 from "fast-deep-equal/es6";
-
 // src/lib/initSelector.ts
-import equal from "fast-deep-equal/es6";
 class SuspendAndWaitForResolveError extends Error {
   promise;
   constructor(promise) {
@@ -126,7 +122,43 @@ var initSelector = (selector, data) => {
   return value;
 };
 
+// src/lib/getState.ts
+function getState(state, data) {
+  if (data.values.has(state))
+    return data.values.get(state);
+  if (isAtom(state)) {
+    if ("parent" in data)
+      return getState(state, data.parent);
+    return initAtom(state, data);
+  }
+  if (isSelector(state))
+    return initSelector(state, data);
+  if (isAtomFamily(state)) {
+    if ("parent" in data) {
+      const closestData = findClosestStoreWithAtomInitialized(state.__keysAtom, data);
+      return getState(state.__keysSelector, closestData);
+    }
+    return getState(state.__keysSelector, data);
+  }
+  if (isSelectorFamily(state)) {
+    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
+    if (equal2(array, state._keyArray))
+      return state._keyArray;
+    state._keyArray = array;
+    return array;
+  }
+  throw new Error("Invalid object passed to get");
+}
+var findClosestStoreWithAtomInitialized = (atom, data) => {
+  if ("parent" in data === false)
+    return data;
+  if (data.values.has(atom))
+    return data;
+  return findClosestStoreWithAtomInitialized(atom, data.parent);
+};
+
 // src/lib/updateSelectorSubscribers.ts
+import equal3 from "fast-deep-equal/es6";
 var updateSelectorSubscribers = (selector, data) => {
   const subscribtions = data.subscriptions.get(selector);
   const familySubscriptions = selector.family && data.subscriptions.get(selector.family);
@@ -136,7 +168,7 @@ var updateSelectorSubscribers = (selector, data) => {
     try {
       const oldValue = data.expiredValues.get(selector);
       const newValue = initSelector(selector, data);
-      if (equal2(newValue, oldValue))
+      if (equal3(newValue, oldValue))
         return;
     } catch (e) {
     }
@@ -189,6 +221,26 @@ var propagateUpdatedAtoms = (atoms, data) => {
   }
 };
 
+// src/lib/setAtom.ts
+import equal4 from "fast-deep-equal/es6";
+var setAtom = (atom, newValue, data, skipOnSet = false) => {
+  const currentValue = getState(atom, data);
+  if (typeof newValue === "function") {
+    newValue = newValue(currentValue);
+    if (isPromiseLike(newValue) || isPromiseLike(currentValue))
+      throw new Error("Todo, how should we handle this?");
+  }
+  if (equal4(currentValue, newValue))
+    return;
+  data.values.set(atom, newValue);
+  if (atom.onSet && !skipOnSet)
+    atom.onSet(newValue, data);
+  if (currentValue?.__isEmptyAtomPromise__) {
+    currentValue.__resolveEmptyAtomPromise__(newValue);
+  }
+  propagateUpdatedAtoms([atom], data);
+};
+
 // src/lib/initAtom.ts
 var getAtomInitValue = (atom, data) => {
   if (atom.defaultValue === undefined) {
@@ -233,60 +285,6 @@ var initAtom = (atom, data) => {
   return value;
 };
 
-// src/lib/getState.ts
-function getState(state, data) {
-  if (data.values.has(state))
-    return data.values.get(state);
-  if (isAtom(state)) {
-    if ("parent" in data)
-      return getState(state, data.parent);
-    return initAtom(state, data);
-  }
-  if (isSelector(state))
-    return initSelector(state, data);
-  if (isAtomFamily(state)) {
-    if ("parent" in data) {
-      const closestData = findClosestStoreWithAtomInitialized(state.__keysAtom, data);
-      return getState(state.__keysSelector, closestData);
-    }
-    return getState(state.__keysSelector, data);
-  }
-  if (isSelectorFamily(state)) {
-    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
-    if (equal3(array, state._keyArray))
-      return state._keyArray;
-    state._keyArray = array;
-    return array;
-  }
-  throw new Error("Invalid object passed to get");
-}
-var findClosestStoreWithAtomInitialized = (atom, data) => {
-  if ("parent" in data === false)
-    return data;
-  if (data.values.has(atom))
-    return data;
-  return findClosestStoreWithAtomInitialized(atom, data.parent);
-};
-
-// src/lib/setAtom.ts
-var setAtom = (atom, newValue, data, skipOnSet = false) => {
-  const currentValue = getState(atom, data);
-  if (typeof newValue === "function") {
-    newValue = newValue(currentValue);
-    if (isPromiseLike(newValue) || isPromiseLike(currentValue))
-      throw new Error("Todo, how should we handle this?");
-  }
-  if (equal4(currentValue, newValue))
-    return;
-  data.values.set(atom, newValue);
-  if (atom.onSet && !skipOnSet)
-    atom.onSet(newValue, data);
-  if (currentValue?.__isEmptyAtomPromise__) {
-    currentValue.__resolveEmptyAtomPromise__(newValue);
-  }
-  propagateUpdatedAtoms([atom], data);
-};
-
 // src/lib/globalAtom.ts
 var getFirstItemInSet = (set) => {
   for (let item of set) {
@@ -297,13 +295,27 @@ var getFirstItemInSet = (set) => {
 var globalAtom = (defaultValue, options) => {
   const stores = new Set;
   let value = defaultValue;
+  let initialized = false;
+  let onReset;
   if (options.onSet)
     throw new Error("onSet on globalAtom is currently not supported");
-  if (options.onInit)
-    throw new Error("onInit on globalAtom is currently not supported");
-  const onInit = (setSelf2, store) => {
-    setSelf2(value);
-    stores.add(store);
+  const onInit = (setSelf2, data) => {
+    if (!initialized) {
+      if (value === defaultValue) {
+        value = getAtomInitValue(atom, data);
+      }
+      setSelf2(value);
+      initialized = true;
+      if (options.onInit) {
+        onReset = options.onInit((newVal) => {
+          setSelf2(newVal);
+          value = newVal;
+        }, data);
+      }
+    } else {
+      setSelf2(value);
+    }
+    stores.add(data);
   };
   const onSet = (newValue, currentStore) => {
     value = newValue;
@@ -323,6 +335,20 @@ var globalAtom = (defaultValue, options) => {
       setAtom(atom, newValue, store);
     }
   };
+  const resetSelf = () => {
+    value = defaultValue;
+    initialized = false;
+    for (const store of stores) {
+      if (store.stateDependencies.has(atom)) {
+        throw new Error("TODO: Reset support for stateDependencies");
+      }
+      store.values.delete(atom);
+      store.expiredValues.delete(atom);
+      propagateUpdatedAtoms([atom], store);
+      stores.delete(store);
+      onReset?.();
+    }
+  };
   const atom = {
     ...options,
     defaultValue,
@@ -330,6 +356,7 @@ var globalAtom = (defaultValue, options) => {
     onInit,
     onSet,
     setSelf,
+    resetSelf,
     get currentValue() {
       return value;
     }

package/dist/types/index.d.ts

@@ -16,6 +16,7 @@ export { isSelectorFamily } from "./src/utils/isSelectorFamily";
 export type { Atom } from "./src/types/Atom";
 export type { AtomFamily } from "./src/types/AtomFamily";
 export type { GetValue } from "./src/types/GetValue";
+export type { GlobalAtom } from "./src/types/GlobalAtom";
 export type { ResetAtom } from "./src/types/ResetAtom";
 export type { Selector } from "./src/types/Selector";
 export type { SelectorFamily } from "./src/types/SelectorFamily";

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

@@ -1,4 +1,4 @@
-import type { GlobalAtom } from "./../types/GlobalAtom";
-import type { AtomOptions } from "./../types/AtomOptions";
 import type { AtomDefaultValue } from "../types/AtomDefaultValue";
+import type { AtomOptions } from "./../types/AtomOptions";
+import type { GlobalAtom } from "./../types/GlobalAtom";
 export declare const globalAtom: <Value = any>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value>) => GlobalAtom<Value>;

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

@@ -1,5 +1,3 @@
 import type { AtomFamilyAtom } from "./AtomFamilyAtom";
-import type { GlobalAtomSetSelfFunc } from "./GlobalAtomSetSelfFunc";
-export type AtomFamilyGlobalAtom<Key = unknown, Value = unknown> = AtomFamilyAtom<Key, Value> & {
-    setSelf: GlobalAtomSetSelfFunc<Value>;
-};
+import type { GlobalAtom } from "./GlobalAtom";
+export type AtomFamilyGlobalAtom<Key = unknown, Value = unknown> = AtomFamilyAtom<Key, Value> & GlobalAtom<Value>;

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

@@ -3,7 +3,7 @@ import type { StoreData } from "./StoreData";
 export type AtomOptions<Value = unknown> = {
     global?: boolean;
     label?: string;
-    onInit?: (setSelf: (value: Value) => void, store: StoreData) => void;
+    onInit?: (setSelf: (value: Value) => void, store: StoreData) => (() => void) | void;
     onSet?: AtomOnSet<Value>;
     onMount?: () => () => void;
     maxAge?: number;

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

@@ -1,5 +1,7 @@
 import type { Atom } from "./Atom";
 import type { GlobalAtomSetSelfFunc } from "./GlobalAtomSetSelfFunc";
+import type { GlobalAtomResetSelfFunc } from "./GlobalAtomResetSelfFunc";
 export type GlobalAtom<Value = unknown> = Atom<Value> & {
     setSelf: GlobalAtomSetSelfFunc<Value>;
+    resetSelf: GlobalAtomResetSelfFunc;
 };

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

@@ -0,0 +1 @@
+export type GlobalAtomResetSelfFunc = () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.29",
+    "version": "0.2.0-alpha.30",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -39,5 +39,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "0c2a2c8d8c2697b2dc8dd67f12629528d51da1a7"
+    "gitHead": "5b94699fe0e875ccfd7e95e535bec8a7ecedcb30"
 }