valdres 0.2.0-alpha.14 → 0.2.0-alpha.17

package/dist/index.js

@@ -6,6 +6,15 @@ var isPromiseLike = (object) => {
   return object && object.then && typeof object.then === "function";
 };
 
+// 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/lib/updateStateSubscribers.ts
 var updateStateSubscribers = (state, data) => {
   const subscribtions = data.subscriptions.get(state);
@@ -14,7 +23,7 @@ var updateStateSubscribers = (state, data) => {
       subscribtion.callback();
     }
   }
-  if (state.family) {
+  if (isFamilyState(state)) {
     const familySubscriptions = data.subscriptions.get(state.family);
     if (familySubscriptions?.size) {
       for (const subscribtion of familySubscriptions) {
@@ -72,9 +81,6 @@ var initAtom = (atom, data) => {
   return value;
 };
 
-// src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
-
 // src/utils/isAtomFamily.ts
 var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
 
@@ -231,7 +237,7 @@ var propagateUpdatedAtoms = (atoms, data) => {
     if (consumers && consumers.size) {
       recursivlyResetSelectorTree(consumers, data, clearedSelectors);
     }
-    if (atom.family) {
+    if (isFamilyAtom(atom)) {
       const consumersFamily = data.stateConsumers.get(atom.family);
       if (consumersFamily?.size) {
         recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
@@ -266,43 +272,64 @@ var setAtom = (atom, newValue, data, skipOnSet = false) => {
 };
 
 // src/lib/globalAtom.ts
+var getFirstItemInSet = (set) => {
+  for (let item of set) {
+    return item;
+  }
+  throw new Error("Non Empty Set");
+};
 var globalAtom = (defaultValue, options) => {
   const stores = new Set;
   let value = defaultValue;
+  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 onSet = (newValue, currentStore) => {
     value = newValue;
     if (stores.size > 1) {
       for (const store of stores) {
         if (store.id !== currentStore.id) {
-          setAtom(newAtom, value, store, true);
+          setAtom(atom, value, store, true);
         }
       }
     }
   };
-  const newAtom = {
-    defaultValue,
+  const setSelf = (newValue) => {
+    value = newValue;
+    if (stores.size > 0) {
+      getFirstItemInSet(stores);
+      const store = getFirstItemInSet(stores);
+      setAtom(atom, newValue, store);
+    }
+  };
+  const atom = {
     ...options,
-    onInit: (setSelf, store) => {
-      setSelf(value);
-      stores.add(store);
-    },
+    defaultValue,
+    label: options?.label,
+    onInit,
     onSet,
-    label: options?.label
+    setSelf
   };
-  return newAtom;
+  return atom;
 };
 
 // src/atom.ts
-var atom = (defaultValue, options) => {
+function atom(defaultValue, options) {
   if (!options)
     return { defaultValue };
-  if (options.global)
+  if (options.global) {
     return globalAtom(defaultValue, options);
+  }
   return {
     defaultValue,
     ...options
   };
-};
+}
 // src/lib/stableStringify.ts
 var stableStringifyRecurse = (x, key) => {
   if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
@@ -357,41 +384,56 @@ var stableStringify = (x) => {
   return stableStringifyRecurse(x);
 };
 
-// src/atomFamily.ts
-var createOptions = (options, key) => {
-  if (options.label) {
+// src/lib/atomFamilyAtom.ts
+function atomFamilyAtom(defaultValue, options) {
+  if (options.global) {
     return {
       ...options,
-      label: options?.label + "_" + key
+      defaultValue
     };
-  } else {
-    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) => {
+  return {
+    ...options,
+    defaultValue
+  };
+}
+
+// src/atomFamily.ts
+function atomFamily(defaultValue, options) {
   const map = new Map;
   const atomFamily2 = (key) => {
     const keyStringified = stableStringify(key);
     if (map.has(keyStringified)) {
       return map.get(keyStringified);
     }
-    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;
+    const familyAtom = atomFamilyAtom(handleDefaultValue(defaultValue, key), createOptions(options, atomFamily2, Object.freeze(key), keyStringified));
+    map.set(keyStringified, familyAtom);
+    return familyAtom;
   };
   atomFamily2.__valdresAtomFamilyMap = map;
+  atomFamily2.release = (key) => map.delete(key);
   if (options?.label)
     atomFamily2.label = options.label;
   return atomFamily2;
+}
+var createOptions = (options = {}, family, familyKey, keyStringified) => {
+  if (options.label) {
+    return {
+      ...options,
+      label: options?.label + "_" + keyStringified,
+      family,
+      familyKey
+    };
+  } else {
+    return { ...options, family, familyKey };
+  }
+};
+var handleDefaultValue = (defaultValue, key) => {
+  if (isSelectorFamily(defaultValue))
+    return defaultValue(key);
+  if (typeof defaultValue === "function")
+    return () => defaultValue(key);
+  return defaultValue;
 };
 // src/lib/createStoreData.ts
 var generateId = () => (Math.random() + 1).toString(36).substring(7);

package/dist/src/atom.d.ts

@@ -1,4 +1,16 @@
 import type { Atom } from "./types/Atom";
+import type { AtomDefaultValue } from "./types/AtomDefaultValue";
 import type { AtomOptions } from "./types/AtomOptions";
-import type { Selector } from "./types/Selector";
-export declare const atom: <Value = any, FamilyKey = undefined>(defaultValue?: Value | (() => Value | Promise<Value>) | Selector<Value>, options?: AtomOptions<Value>) => Atom<Value, FamilyKey>;
+import type { GlobalAtom } from "./types/GlobalAtom";
+/**
+ * [Docs Reference](https://valdres.dev/valdres/api/atom)
+ *
+ * @example
+ *
+ * const user = atom<string>("Default Value", { label: "userAtom"})
+ *
+ */
+export declare function atom<V>(defaultValue: AtomDefaultValue<V>, options: AtomOptions<V> & {
+    global: true;
+}): GlobalAtom<V>;
+export declare function atom<V>(defaultValue: AtomDefaultValue<V>, options?: AtomOptions<V>): Atom<V>;

package/dist/src/atomFamily.d.ts

@@ -1,8 +1,10 @@
 import type { AtomFamily } from "./types/AtomFamily";
 import type { AtomOptions } from "./types/AtomOptions";
+import type { FamilyKey } from "./types/FamilyKey";
 import type { Selector } from "./types/Selector";
 import type { SelectorFamily } from "./types/SelectorFamily";
 type DefaultValueCallback<Key, Value> = (arg: Key) => Value | Promise<Value>;
-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>;
+type AtomFamilyDefaultValue<Key, Value> = undefined | Value | DefaultValueCallback<Key, Value> | Selector<Value> | SelectorFamily<Value, Key>;
+/** [Docs Reference](https://valdres.dev/valdres/api/atomFamily) */
+export declare function atomFamily<Key = FamilyKey, Value = unknown>(defaultValue?: AtomFamilyDefaultValue<Key, Value>, options?: AtomOptions<Value>): AtomFamily<Key, Value>;
 export {};

package/dist/src/createStore.d.ts

@@ -1,2 +1 @@
-import type { Store } from "./types/Store";
-export declare const createStore: (id?: string) => Store;
+export declare const createStore: (id?: string) => import("..").Store;

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

@@ -0,0 +1,8 @@
+import type { AtomDefaultValue } from "../types/AtomDefaultValue";
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+import type { AtomFamilyGlobalAtom } from "../types/AtomFamilyGlobalAtom";
+import type { AtomOptions } from "../types/AtomOptions";
+export declare function atomFamilyAtom<V, K>(defaultValue: AtomDefaultValue<V>, options: AtomOptions<V> & {
+    global: true;
+}): AtomFamilyGlobalAtom<V, K>;
+export declare function atomFamilyAtom<V, K>(defaultValue: AtomDefaultValue<V>, options: AtomOptions<V>): AtomFamilyAtom<V, K>;

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

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

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

@@ -1,3 +1,4 @@
 import type { Atom } from "../types/Atom";
 import type { StoreData } from "../types/StoreData";
-export declare const propagateUpdatedAtoms: (atoms: Atom[], data: StoreData) => void;
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+export declare const propagateUpdatedAtoms: (atoms: (Atom<any> | AtomFamilyAtom<any, any>)[], data: StoreData) => void;

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

@@ -1,3 +1,3 @@
 import type { State } from "../types/State";
 import type { StoreData } from "../types/StoreData";
-export declare const updateStateSubscribers: (state: State, data: StoreData) => void;
+export declare const updateStateSubscribers: <V>(state: State, data: StoreData) => void;

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

@@ -1,12 +1,9 @@
-import type { AtomFamily } from "./AtomFamily";
+import type { AtomDefaultValue } from "./AtomDefaultValue";
 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>) | Selector<Value>;
+export type Atom<Value = unknown> = {
+    defaultValue?: AtomDefaultValue<Value>;
     label?: string;
-    family?: AtomFamily<Value, FamilyKey>;
-    familyKey?: FamilyKey;
     onInit?: AtomOnInit<Value>;
     onSet?: AtomOnSet<Value>;
     onMount?: () => void | (() => void);

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

@@ -0,0 +1,2 @@
+import type { Selector } from "./Selector";
+export type AtomDefaultValue<Value = any> = Value | (() => Value | Promise<Value>) | Selector<Value> | undefined;

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

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

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

@@ -0,0 +1,6 @@
+import type { Atom } from "./Atom";
+import type { AtomFamily } from "./AtomFamily";
+export type AtomFamilyAtom<Value = unknown, Key = unknown> = Atom<Value> & {
+    family: AtomFamily<Value, Key>;
+    familyKey: Key;
+};

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

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

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

@@ -0,0 +1,6 @@
+import type { Selector } from "./Selector";
+import type { SelectorFamily } from "./SelectorFamily";
+export type AtomFamilySelector<Value = unknown, Key = unknown> = Selector<Value> & {
+    family: SelectorFamily<Value, Key>;
+    familyKey: Key;
+};

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

@@ -1,2 +1,2 @@
 import type { StoreData } from "./StoreData";
-export type AtomOnSet<Value = unknown> = (value: Value, store: StoreData) => void;
+export type AtomOnSet<Value = any> = (value: Value, store: StoreData) => void;

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

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

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

@@ -0,0 +1,3 @@
+export type FamilyKey = PropertyKey | PropertyKey[] | {
+    [key: PropertyKey]: FamilyKey;
+};

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

@@ -2,7 +2,7 @@ import type { Atom } from "./Atom";
 import type { AtomFamily } from "./AtomFamily";
 import type { Selector } from "./Selector";
 export type GetValue = {
-    <V, K>(atom: Atom<V>): V;
-    <V, K>(selector: Selector<V>): V;
-    <V, K>(family: AtomFamily<V, K>): K[];
+    <V>(atom: Atom<V>): V;
+    <V>(selector: Selector<V>): V;
+    <V, K>(family: AtomFamily<K, V>): K[];
 };

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

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

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

@@ -0,0 +1 @@
+export type GlobalAtomSetSelfFunc<Value = unknown> = (value: Value) => void;

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

@@ -1,3 +1,3 @@
 import type { Atom } from "./Atom";
 import type { SetAtomValue } from "./SetAtomValue";
-export type SetAtom<V = any> = (atom: Atom<V>, value: SetAtomValue<V>) => void;
+export type SetAtom<Value = any> = (atom: Atom<Value>, value: SetAtomValue<Value>) => void;

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

@@ -1 +1 @@
-export type SetAtomValue<V> = V | ((current: V) => V);
+export type SetAtomValue<Value> = Value | ((current: Value) => Value);

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

@@ -1,9 +1,14 @@
+import type { Atom } from "./Atom";
+import type { AtomFamilyAtom } from "./AtomFamilyAtom";
 import type { GetValue } from "./GetValue";
 import type { ResetAtom } from "./ResetAtom";
-import type { SetAtom } from "./SetAtom";
 import type { StoreData } from "./StoreData";
 import type { SubscribeFn } from "./SubscribeFn";
 import type { TransactionFn } from "./TransactionFn";
+type SetAtom = {
+    <V, K>(atom: AtomFamilyAtom<V, K>, value: V): void;
+    <V>(atom: Atom<V>, value: V): void;
+};
 export type Store = {
     data: StoreData;
     get: GetValue;
@@ -12,3 +17,4 @@ export type Store = {
     reset: ResetAtom;
     txn: (callback: TransactionFn) => void;
 };
+export {};

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

@@ -1,2 +1,2 @@
 import type { Atom } from "../types/Atom";
-export declare const isAtom: (state: any) => state is Atom;
+export declare const isAtom: <V>(state: any) => state is Atom<V>;

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
+import type { AtomFamilySelector } from "../types/AtomFamilySelector";
+export declare const isFamilyState: <K, V>(state: any) => state is AtomFamilyAtom<K, V> | AtomFamilySelector<K, V>;

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

@@ -1,2 +1,2 @@
 import type { Selector } from "../types/Selector";
-export declare const isSelector: (state: any) => state is Selector;
+export declare const isSelector: <V>(state: any) => state is Selector<V>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.14",
+    "version": "0.2.0-alpha.17",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -39,5 +39,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "2a0e8feb476402603356206cb15d6e894dcecf81"
+    "gitHead": "40d44bfa3d776180101f17371766c5746bb9cd3f"
 }