valdres 0.2.0-alpha.11 → 0.2.0-alpha.12

package/dist/index.js

@@ -33,6 +33,9 @@ import equal2 from "fast-deep-equal";
 // src/lib/getState.ts
 import equal from "fast-deep-equal";
 
+// src/utils/isSelector.ts
+var isSelector = (state) => state && Object.hasOwn(state, "get");
+
 // src/lib/initAtom.ts
 var getAtomInitValue = (atom, data) => {
   if (atom.defaultValue === undefined) {
@@ -52,6 +55,8 @@ var getAtomInitValue = (atom, data) => {
       });
     }
     return value;
+  } else if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data);
   } else {
     return atom.defaultValue;
   }
@@ -70,11 +75,11 @@ var initAtom = (atom, data) => {
 // src/utils/isAtom.ts
 var isAtom = (state) => Object.hasOwn(state, "defaultValue");
 
-// src/utils/isSelector.ts
-var isSelector = (state) => Object.hasOwn(state, "get");
+// src/utils/isAtomFamily.ts
+var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
 
-// src/utils/isFamily.ts
-var isFamily = (state) => Object.hasOwn(state, "_map");
+// src/utils/isSelectorFamily.ts
+var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
 
 // src/lib/getState.ts
 function getState(state, data) {
@@ -84,8 +89,15 @@ function getState(state, data) {
     return initAtom(state, data);
   if (isSelector(state))
     return initSelector(state, data);
-  if (isFamily(state)) {
-    const array = Array.from(state._map.keys());
+  if (isAtomFamily(state)) {
+    const array = Array.from(state.__valdresAtomFamilyMap.keys());
+    if (equal(array, state._keyArray))
+      return state._keyArray;
+    state._keyArray = array;
+    return array;
+  }
+  if (isSelectorFamily(state)) {
+    const array = Array.from(state.__valdresSelectorFamilyMap.keys());
     if (equal(array, state._keyArray))
       return state._keyArray;
     state._keyArray = array;
@@ -354,6 +366,13 @@ var createOptions = (options, key) => {
     return options;
   }
 };
+var handleDefaultValue = (defaultValue, key) => {
+  if (isSelectorFamily(defaultValue))
+    return defaultValue(key);
+  if (typeof defaultValue === "function")
+    return () => defaultValue(key);
+  return defaultValue;
+};
 var atomFamily = (defaultValue, options) => {
   const map = new Map;
   const atomFamily2 = (key) => {
@@ -361,13 +380,13 @@ var atomFamily = (defaultValue, options) => {
     if (map.has(keyStringified)) {
       return map.get(keyStringified);
     }
-    const newAtom = atom(typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue, options ? createOptions(options, keyStringified) : undefined);
+    const newAtom = atom(handleDefaultValue(defaultValue, key), options ? createOptions(options, keyStringified) : undefined);
     newAtom.family = atomFamily2;
     newAtom.familyKey = Object.freeze(key);
     map.set(keyStringified, newAtom);
     return newAtom;
   };
-  atomFamily2._map = map;
+  atomFamily2.__valdresAtomFamilyMap = map;
   if (options?.label)
     atomFamily2.label = options.label;
   return atomFamily2;
@@ -386,15 +405,19 @@ var createStoreData = (id = generateId()) => ({
 
 // src/lib/resetAtom.ts
 var resetAtom = (atom2, data) => {
-  const res = initAtom(atom2, data);
-  if (!isPromiseLike(res)) {
+  let value = getAtomInitValue(atom2, data);
+  data.values.set(atom2, value);
+  if (!isPromiseLike(value)) {
     propagateUpdatedAtoms([atom2], data);
   }
-  return res;
+  return value;
 };
 
+// src/utils/isFamily.ts
+var isFamily = (state) => isAtomFamily(state) || isSelectorFamily(state);
+
 // src/lib/unsubscribe.ts
-var unsubscribe = (state, subscription, data, mount) => {
+var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
   const subscribers = data.subscriptions.get(state);
   if (subscribers) {
     subscribers.delete(subscription);
@@ -410,6 +433,10 @@ var unsubscribe = (state, subscription, data, mount) => {
         data.subscriptionsRequireEqualCheck.delete(state);
       }
     }
+    if (subscribers.size === 0) {
+      if (maxAgeCleanup)
+        maxAgeCleanup();
+    }
     if (mount) {
       if (subscribers.size === mount.mountSubscriptions.size) {
         if (typeof mount.onUnmount === "function") {
@@ -446,23 +473,50 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   }
   subscribers.add(subscription);
   let mount;
-  if (subscribers.size === 1 && state.onMount) {
-    const store = storeFromStoreData(data);
-    const mountSubscriptions = new Set;
-    const originalSub = store.sub;
-    store.sub = (state2, callback2) => {
-      mountSubscriptions.add(callback2);
-      return originalSub(state2, callback2);
-    };
-    mount = {
-      onUnmount: state.onMount(store, state),
-      mountSubscriptions
-    };
+  let maxAgeCleanup;
+  if (subscribers.size === 1) {
+    if (isAtom(state) && state.maxAge) {
+      let timeout;
+      const interval = setInterval(() => {
+        let value = getAtomInitValue(state, data);
+        if (isPromiseLike(value)) {
+          if (state.staleWhileRevalidate) {
+            const oldValue = data.values.get(state);
+            timeout = setTimeout(() => {
+              const nowValue = data.values.get(state);
+              console.log("todo", oldValue);
+            }, state.staleWhileRevalidate);
+            value.then((res) => clearTimeout(timeout));
+          }
+        } else {
+          data.values.set(state, value);
+          propagateUpdatedAtoms([state], data);
+        }
+      }, state.maxAge);
+      maxAgeCleanup = () => {
+        clearInterval(interval);
+        if (timeout)
+          clearTimeout(timeout);
+      };
+    }
+    if (state.onMount) {
+      const store = storeFromStoreData(data);
+      const mountSubscriptions = new Set;
+      const originalSub = store.sub;
+      store.sub = (state2, callback2) => {
+        mountSubscriptions.add(callback2);
+        return originalSub(state2, callback2);
+      };
+      mount = {
+        onUnmount: state.onMount(store, state),
+        mountSubscriptions
+      };
+    }
   }
   if (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state) !== true) {
     data.subscriptionsRequireEqualCheck.set(state, true);
   }
-  return () => unsubscribe(state, subscription, data, mount);
+  return () => unsubscribe(state, subscription, data, mount, maxAgeCleanup);
 };
 
 // src/lib/setAtoms.ts
@@ -636,7 +690,9 @@ var selectorFamily = (get, options) => {
     map.set(keyStringified, newSelector);
     return newSelector;
   };
-  selectorFamily2._map = map;
+  selectorFamily2.__valdresSelectorFamilyMap = map;
+  if (options?.label)
+    selectorFamily2.label = options.label;
   return selectorFamily2;
 };
 export {

package/dist/src/atom.d.ts

@@ -1,4 +1,5 @@
 import type { Atom } from "./types/Atom";
 import type { AtomOptions } from "./types/AtomOptions";
+import type { Selector } from "./types/Selector";
 export declare const globalAtom: <Value = any, FamilyKey = undefined>(defaultValue: Value | (() => Value | Promise<Value>), options: AtomOptions<Value>) => Atom<Value>;
-export declare const atom: <Value = any, FamilyKey = undefined>(defaultValue?: Value | (() => Value | Promise<Value>), options?: AtomOptions<Value>) => Atom<Value, FamilyKey>;
+export declare const atom: <Value = any, FamilyKey = undefined>(defaultValue?: Value | (() => Value | Promise<Value>) | Selector<Value>, options?: AtomOptions<Value>) => Atom<Value, FamilyKey>;

package/dist/src/atomFamily.d.ts

@@ -1,5 +1,8 @@
 import type { AtomFamily } from "./types/AtomFamily";
 import type { AtomOptions } from "./types/AtomOptions";
+import type { Selector } from "./types/Selector";
+import type { SelectorFamily } from "./types/SelectorFamily";
 type DefaultValueCallback<Key, Value> = (arg: Key) => Value | Promise<Value>;
-export declare const atomFamily: <Value = unknown, Key = unknown>(defaultValue?: Value | DefaultValueCallback<Key, Value>, options?: AtomOptions<Value>) => AtomFamily<Value, Key>;
+type AtomFamilyDefaultValue<Value, Key> = undefined | Value | DefaultValueCallback<Key, Value> | Selector<Value> | SelectorFamily<Value, Key>;
+export declare const atomFamily: <Value = unknown, Key = unknown>(defaultValue?: AtomFamilyDefaultValue<Value, Key>, options?: AtomOptions<Value>) => AtomFamily<Value, Key>;
 export {};

package/dist/src/lib/unsubscribe.d.ts

@@ -2,4 +2,4 @@ import type { Family } from "../types/Family";
 import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
 import type { Subscription } from "../types/Subscription";
-export declare const unsubscribe: <V>(state: State<V> | Family<V>, subscription: Subscription, data: StoreData, mount?: any) => void;
+export declare const unsubscribe: <V>(state: State<V> | Family<V>, subscription: Subscription, data: StoreData, mount?: any, maxAgeCleanup?: any) => void;

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

@@ -1,12 +1,15 @@
 import type { AtomFamily } from "./AtomFamily";
 import type { AtomOnInit } from "./AtomOnInit";
 import type { AtomOnSet } from "./AtomOnSet";
+import type { Selector } from "./Selector";
 export type Atom<Value = any, FamilyKey = undefined> = {
-    defaultValue?: Value | (() => Value | Promise<Value>);
+    defaultValue?: Value | (() => Value | Promise<Value>) | Selector<Value>;
     label?: string;
     family?: AtomFamily<Value, FamilyKey>;
     familyKey?: FamilyKey;
     onInit?: AtomOnInit<Value>;
     onSet?: AtomOnSet<Value>;
     onMount?: () => void | (() => void);
+    maxAge?: number;
+    staleWhileRevalidate?: number;
 };

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

@@ -1,6 +1,6 @@
 import type { Atom } from "./Atom";
-export type AtomFamily<Value, Key> = {
+export type AtomFamily<Value = any, Key = any> = {
     (key: Key, defaultOverride?: any): Atom<Value>;
     label?: string;
-    _map: Map<Key, Atom<Value, Key>>;
+    __valdresAtomFamilyMap: Map<Key, Atom<Value, Key>>;
 };

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

@@ -1,5 +1,5 @@
 import type { Selector } from "./Selector";
-export type SelectorFamily<Value, Key> = {
+export type SelectorFamily<Value = any, Key = any> = {
     (key: Key, defaultOverride?: any): Selector<Value>;
-    _map: Map<Key, Selector<Value, Key>>;
+    __valdresSelectorFamilyMap: Map<Key, Selector<Value, Key>>;
 };

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

@@ -0,0 +1,2 @@
+import type { AtomFamily } from "../types/AtomFamily";
+export declare const isAtomFamily: (state: any) => state is AtomFamily;

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

@@ -1 +1 @@
-export declare const isFamily: (state: any) => boolean;
+export declare const isFamily: (state: any) => state is import("../..").AtomFamily | import("../..").SelectorFamily;

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

@@ -0,0 +1,2 @@
+import type { SelectorFamily } from "../types/SelectorFamily";
+export declare const isSelectorFamily: (state: any) => state is SelectorFamily;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.11",
+    "version": "0.2.0-alpha.12",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -39,5 +39,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "081fe9031067f895bb2f79dec2648a88ac891cc9"
+    "gitHead": "a4d1c93d890e47c6d2fc17639b1b08282466b11b"
 }