valdres 0.2.0-alpha.8 → 0.2.0-alpha.9

package/dist/index.js

@@ -1,109 +1,11 @@
-// src/atom.ts
-var atom = (defaultValue, options) => {
-  if (!options)
-    return { defaultValue };
-  return {
-    defaultValue,
-    ...options
-  };
-};
+// src/lib/setAtom.ts
+import equal4 from "fast-deep-equal";
+
 // src/utils/isPromiseLike.ts
 var isPromiseLike = (object) => {
   return object && object.then && typeof object.then === "function";
 };
 
-// src/lib/stableStringify.ts
-var stableStringifyRecurse = (x, key) => {
-  if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
-    return `"${x}"`;
-  }
-  switch (typeof x) {
-    case "undefined":
-      return "";
-    case "boolean":
-      return x ? "true" : "false";
-    case "number":
-    case "symbol":
-      return String(x);
-    case "string":
-      return JSON.stringify(x);
-    case "function":
-      return `__FUNCTION(${x.toString()})__`;
-  }
-  if (x === null) {
-    return "null";
-  }
-  if (typeof x !== "object") {
-    return JSON.stringify(x) ?? "";
-  }
-  if (isPromiseLike(x)) {
-    return "__PROMISE__";
-  }
-  if (Array.isArray(x)) {
-    return `[${x.map((v, i) => stableStringifyRecurse(v, i.toString()))}]`;
-  }
-  if (typeof x.toJSON === "function") {
-    return stableStringifyRecurse(x.toJSON(key), key);
-  }
-  if (x instanceof Map) {
-    const obj = {};
-    for (const [k, v] of x) {
-      obj[typeof k === "string" ? k : stringify(k, opt)] = v;
-    }
-    return stableStringifyRecurse(obj, key);
-  }
-  if (x instanceof Set) {
-    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
-  }
-  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
-    return stableStringifyRecurse(Array.from(x), key);
-  }
-  return `{${Object.keys(x).filter((k) => x[k] !== undefined).sort().map((k) => `${stableStringifyRecurse(k)}:${stableStringifyRecurse(x[k], k)}`).join(",")}}`;
-};
-var stableStringify = (x) => {
-  if (typeof x === "string" || typeof x === "boolean" || typeof x === "number")
-    return x;
-  return stableStringifyRecurse(x);
-};
-
-// src/atomFamily.ts
-var atomFamily = (defaultValue, debugLabel) => {
-  const map = new Map;
-  const atomFamily2 = (key, defaultOverride) => {
-    const keyStringified = stableStringify(key);
-    if (map.has(keyStringified)) {
-      return map.get(keyStringified);
-    }
-    const atomDebugLabel = debugLabel && debugLabel + "_" + keyStringified;
-    const newAtom = atom(typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue, {
-      label: atomDebugLabel
-    });
-    newAtom.family = atomFamily2;
-    newAtom.familyKey = Object.freeze(key);
-    map.set(keyStringified, newAtom);
-    return newAtom;
-  };
-  atomFamily2._map = map;
-  return atomFamily2;
-};
-// src/lib/createStoreData.ts
-var generateId = () => (Math.random() + 1).toString(36).substring(7);
-var createStoreData = (id = generateId()) => ({
-  id,
-  values: new WeakMap,
-  expiredValues: new WeakMap,
-  subscriptions: new WeakMap,
-  subscriptionsRequireEqualCheck: new WeakMap,
-  stateConsumers: new WeakMap,
-  stateDependencies: new WeakMap
-});
-
-// src/utils/isAtom.ts
-var isAtom = (state) => Object.hasOwn(state, "defaultValue");
-
-// src/lib/getState.ts
-import equal4 from "fast-deep-equal";
-
 // src/lib/updateStateSubscribers.ts
 var updateStateSubscribers = (state, data) => {
   const subscribtions = data.subscriptions.get(state);
@@ -123,10 +25,76 @@ var updateStateSubscribers = (state, data) => {
 };
 
 // src/lib/updateSelectorSubscribers.ts
-import equal2 from "fast-deep-equal";
+import equal3 from "fast-deep-equal";
 
 // src/lib/initSelector.ts
+import equal2 from "fast-deep-equal";
+
+// src/lib/getState.ts
 import equal from "fast-deep-equal";
+
+// src/lib/initAtom.ts
+var getAtomInitValue = (atom, data) => {
+  if (atom.defaultValue === undefined) {
+    let promiseResolve;
+    const promise = new Promise((resolve) => {
+      promiseResolve = resolve;
+    });
+    promise.__isEmptyAtomPromise__ = true;
+    promise.__resolveEmptyAtomPromise__ = promiseResolve;
+    return promise;
+  } else if (typeof atom.defaultValue === "function") {
+    const value = atom.defaultValue();
+    if (isPromiseLike(value)) {
+      value.then((resolvedValue) => {
+        data.values.set(atom, resolvedValue);
+        propagateUpdatedAtoms([atom], data);
+      });
+    }
+    return value;
+  } else {
+    return atom.defaultValue;
+  }
+};
+var initAtom = (atom, data) => {
+  let value = getAtomInitValue(atom, data);
+  data.values.set(atom, value);
+  if (atom.onInit)
+    atom.onInit((newVal) => {
+      value = newVal;
+      setAtom(atom, newVal, data, true);
+    }, data);
+  return value;
+};
+
+// src/utils/isAtom.ts
+var isAtom = (state) => Object.hasOwn(state, "defaultValue");
+
+// src/utils/isSelector.ts
+var isSelector = (state) => Object.hasOwn(state, "get");
+
+// src/utils/isFamily.ts
+var isFamily = (state) => Object.hasOwn(state, "_map");
+
+// src/lib/getState.ts
+function getState(state, data) {
+  if (data.values.has(state))
+    return data.values.get(state);
+  if (isAtom(state))
+    return initAtom(state, data);
+  if (isSelector(state))
+    return initSelector(state, data);
+  if (isFamily(state)) {
+    const array = Array.from(state._map.keys());
+    if (equal(array, state._keyArray))
+      return state._keyArray;
+    state._keyArray = array;
+    return array;
+  }
+  throw new Error("Invalid object passed to get");
+}
+
+// src/lib/initSelector.ts
 class SuspendAndWaitForResolveError extends Error {
   promise;
   constructor(promise) {
@@ -143,7 +111,6 @@ var getOrInitConsumersSet = (state, data) => {
   return newSet;
 };
 var evaluateSelector = (selector, data) => {
-  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
   const updatedDependencies = new Set;
   let result;
   try {
@@ -153,7 +120,7 @@ var evaluateSelector = (selector, data) => {
       if (isPromiseLike(value))
         throw new SuspendAndWaitForResolveError(value);
       return value;
-    });
+    }, data.id);
   } catch (error) {
     if (error instanceof SuspendAndWaitForResolveError) {
       result = error;
@@ -161,6 +128,7 @@ var evaluateSelector = (selector, data) => {
       throw error;
     }
   }
+  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
   const added = updatedDependencies?.difference(currentDependencies);
   const removed = currentDependencies?.difference(updatedDependencies);
   for (const state of added) {
@@ -194,7 +162,7 @@ var initSelector = (selector, data) => {
   const value = handleSelectorResult(tmpValue, selector, data);
   if (data.expiredValues.has(selector)) {
     const expiredValue = data.expiredValues.get(selector);
-    if (equal(expiredValue, value)) {
+    if (equal2(expiredValue, value)) {
       data.values.set(selector, expiredValue);
       return expiredValue;
     }
@@ -213,7 +181,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) {
     }
@@ -246,13 +214,13 @@ var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
 };
 var propagateUpdatedAtoms = (atoms, data) => {
   const clearedSelectors = new Set;
-  for (const atom2 of atoms) {
-    const consumers = data.stateConsumers.get(atom2);
+  for (const atom of atoms) {
+    const consumers = data.stateConsumers.get(atom);
     if (consumers && consumers.size) {
       recursivlyResetSelectorTree(consumers, data, clearedSelectors);
     }
-    if (atom2.family) {
-      const consumersFamily = data.stateConsumers.get(atom2.family);
+    if (atom.family) {
+      const consumersFamily = data.stateConsumers.get(atom.family);
       if (consumersFamily?.size) {
         recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
       }
@@ -261,86 +229,151 @@ var propagateUpdatedAtoms = (atoms, data) => {
   for (const selector of clearedSelectors) {
     updateSelectorSubscribers(selector, data);
   }
-  for (const atom2 of atoms) {
-    updateStateSubscribers(atom2, data);
+  for (const atom of atoms) {
+    updateStateSubscribers(atom, data);
   }
 };
 
 // src/lib/setAtom.ts
-import equal3 from "fast-deep-equal";
-var setAtom = (atom2, newValue, data) => {
-  const currentValue = getState(atom2, data);
+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 (equal3(currentValue, newValue))
+  if (equal4(currentValue, newValue))
     return;
-  data.values.set(atom2, newValue);
+  data.values.set(atom, newValue);
+  if (atom.onSet && !skipOnSet)
+    atom.onSet(newValue, data);
   if (currentValue?.__isEmptyAtomPromise__) {
     currentValue.__resolveEmptyAtomPromise__(newValue);
   }
-  propagateUpdatedAtoms([atom2], data);
+  propagateUpdatedAtoms([atom], data);
 };
 
-// src/lib/initAtom.ts
-var getAtomInitValue = (atom2, data) => {
-  if (atom2.defaultValue === undefined) {
-    let promiseResolve;
-    const promise = new Promise((resolve) => {
-      promiseResolve = resolve;
-    });
-    promise.__isEmptyAtomPromise__ = true;
-    promise.__resolveEmptyAtomPromise__ = promiseResolve;
-    return promise;
-  } else if (typeof atom2.defaultValue === "function") {
-    const value = atom2.defaultValue();
-    if (isPromiseLike(value)) {
-      value.then((resolvedValue) => {
-        data.values.set(atom2, resolvedValue);
-        propagateUpdatedAtoms([atom2], data);
-      });
+// src/atom.ts
+var globalAtom = (defaultValue, options) => {
+  const stores = new Set;
+  let value = defaultValue;
+  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);
+        }
+      }
     }
-    return value;
-  } else {
-    return atom2.defaultValue;
+  };
+  const newAtom = {
+    defaultValue,
+    ...options,
+    onInit: (setSelf, store) => {
+      setSelf(value);
+      stores.add(store);
+    },
+    onSet,
+    label: options?.label
+  };
+  return newAtom;
+};
+var atom = (defaultValue, options) => {
+  if (!options)
+    return { defaultValue };
+  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("\\")) {
+    return `"${x}"`;
+  }
+  switch (typeof x) {
+    case "undefined":
+      return "";
+    case "boolean":
+      return x ? "true" : "false";
+    case "number":
+    case "symbol":
+      return String(x);
+    case "string":
+      return JSON.stringify(x);
+    case "function":
+      return `__FUNCTION(${x.toString()})__`;
+  }
+  if (x === null) {
+    return "null";
+  }
+  if (typeof x !== "object") {
+    return JSON.stringify(x) ?? "";
+  }
+  if (isPromiseLike(x)) {
+    return "__PROMISE__";
+  }
+  if (Array.isArray(x)) {
+    return `[${x.map((v, i) => stableStringifyRecurse(v, i.toString()))}]`;
+  }
+  if (typeof x.toJSON === "function") {
+    return stableStringifyRecurse(x.toJSON(key), key);
+  }
+  if (x instanceof Map) {
+    const obj = {};
+    for (const [k, v] of x) {
+      obj[typeof k === "string" ? k : stringify(k, opt)] = v;
+    }
+    return stableStringifyRecurse(obj, key);
   }
+  if (x instanceof Set) {
+    return stableStringifyRecurse(Array.from(x).sort((a, b) => stableStringifyRecurse(a).localeCompare(stableStringifyRecurse(b))), key);
+  }
+  if (Symbol !== undefined && x[Symbol.iterator] != null && typeof x[Symbol.iterator] === "function") {
+    return stableStringifyRecurse(Array.from(x), key);
+  }
+  return `{${Object.keys(x).filter((k) => x[k] !== undefined).sort().map((k) => `${stableStringifyRecurse(k)}:${stableStringifyRecurse(x[k], k)}`).join(",")}}`;
 };
-var initAtom = (atom2, data) => {
-  let value = getAtomInitValue(atom2, data);
-  data.values.set(atom2, value);
-  if (atom2.onInit)
-    atom2.onInit((newVal) => {
-      value = newVal;
-      setAtom(atom2, newVal, data);
-    });
-  return value;
+var stableStringify = (x) => {
+  if (typeof x === "string" || typeof x === "boolean" || typeof x === "number")
+    return x;
+  return stableStringifyRecurse(x);
 };
 
-// src/utils/isSelector.ts
-var isSelector = (state) => Object.hasOwn(state, "get");
-
-// src/utils/isFamily.ts
-var isFamily = (state) => Object.hasOwn(state, "_map");
-
-// src/lib/getState.ts
-function getState(state, data) {
-  if (data.values.has(state))
-    return data.values.get(state);
-  if (isAtom(state))
-    return initAtom(state, data);
-  if (isSelector(state))
-    return initSelector(state, data);
-  if (isFamily(state)) {
-    const array = Array.from(state._map.keys());
-    if (equal4(array, state._keyArray))
-      return state._keyArray;
-    state._keyArray = array;
-    return array;
-  }
-  throw new Error("Invalid object passed to get");
-}
+// src/atomFamily.ts
+var atomFamily = (defaultValue, debugLabel) => {
+  const map = new Map;
+  const atomFamily2 = (key, defaultOverride) => {
+    const keyStringified = stableStringify(key);
+    if (map.has(keyStringified)) {
+      return map.get(keyStringified);
+    }
+    const atomDebugLabel = debugLabel && debugLabel + "_" + keyStringified;
+    const newAtom = atom(typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue, {
+      label: atomDebugLabel
+    });
+    newAtom.family = atomFamily2;
+    newAtom.familyKey = Object.freeze(key);
+    map.set(keyStringified, newAtom);
+    return newAtom;
+  };
+  atomFamily2._map = map;
+  return atomFamily2;
+};
+// src/lib/createStoreData.ts
+var generateId = () => (Math.random() + 1).toString(36).substring(7);
+var createStoreData = (id = generateId()) => ({
+  id,
+  values: new WeakMap,
+  expiredValues: new WeakMap,
+  subscriptions: new WeakMap,
+  subscriptionsRequireEqualCheck: new WeakMap,
+  stateConsumers: new WeakMap,
+  stateDependencies: new WeakMap
+});
 
 // src/lib/resetAtom.ts
 var resetAtom = (atom2, data) => {
@@ -474,7 +507,7 @@ var transaction = (callback, data) => {
       const res = state.get((s) => {
         deps.add(s);
         return txnGet(s);
-      });
+      }, data.id);
       for (const dep of deps) {
         if (!txnSubscribers.has(dep)) {
           txnSubscribers.set(dep, new Set);

package/dist/src/atom.d.ts

@@ -1,8 +1,13 @@
 import type { Atom } from "./types/Atom";
-type AtomOptions<Value> = {
+import type { AtomOnSet } from "./types/AtomOnSet";
+import type { StoreData } from "./types/StoreData";
+type AtomOptions<Value = any> = {
+    global?: boolean;
     label?: string;
-    onInit?: (setSelf: (value: Value) => void) => void;
+    onInit?: (setSelf: (value: Value) => void, store: StoreData) => void;
+    onSet?: AtomOnSet<Value>;
     onMount?: () => () => void;
 };
-export declare const atom: <Value, FamilyKey = undefined>(defaultValue?: Value | (() => Value | Promise<Value>), options?: AtomOptions<Value>) => Atom<Value, FamilyKey>;
+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 {};

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

@@ -1,3 +1,3 @@
 import type { Atom } from "../types/Atom";
 import type { StoreData } from "../types/StoreData";
-export declare const setAtom: <V>(atom: Atom<V>, newValue: V, data: StoreData) => void;
+export declare const setAtom: <Value = any>(atom: Atom<Value>, newValue: Value, data: StoreData, skipOnSet?: boolean) => void;

package/dist/src/selector.d.ts

@@ -1,3 +1,3 @@
 import type { GetValue } from "./types/GetValue";
 import type { Selector } from "./types/Selector";
-export declare const selector: <Value, FamilyKey = undefined>(get: (get: GetValue) => Value, debugLabel?: string) => Selector<Value, FamilyKey>;
+export declare const selector: <Value, FamilyKey = undefined>(get: (get: GetValue, storeId: string) => Value, debugLabel?: string) => Selector<Value, FamilyKey>;

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 import type { GetValue } from "./GetValue";
 import type { SelectorFamily } from "./SelectorFamily";
 export type Selector<Value = unknown, FamilyKey = undefined> = {
-    get: (get: GetValue) => Value;
+    get: (get: GetValue, storeId: string) => Value;
     debugLabel?: string;
     family?: SelectorFamily<Value, FamilyKey>;
     familyKey?: FamilyKey;

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 = unknown> = (atom: Atom<V>, value: SetAtomValue<V>) => void;
+export type SetAtom<V = any> = (atom: Atom<V>, value: SetAtomValue<V>) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.8",
+    "version": "0.2.0-alpha.9",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -39,5 +39,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "c7f6e2d76adc15985444d02244522841d52aa233"
+    "gitHead": "e912b2bc8ae395473d0e843cceaf4037bc624b40"
 }