valdres 0.2.0-alpha.5 → 0.2.0-alpha.7

package/dist/index.js

@@ -101,8 +101,8 @@ var createStoreData = (id = generateId()) => ({
 // src/utils/isAtom.ts
 var isAtom = (state) => Object.hasOwn(state, "defaultValue");
 
-// src/utils/isSelector.ts
-var isSelector = (state) => Object.hasOwn(state, "get");
+// src/lib/getState.ts
+import equal4 from "fast-deep-equal";
 
 // src/lib/updateStateSubscribers.ts
 var updateStateSubscribers = (state, data) => {
@@ -148,7 +148,7 @@ var evaluateSelector = (selector, data) => {
   let result;
   try {
     result = selector.get((state) => {
-      const value = getState2(state, data);
+      const value = getState(state, data);
       updatedDependencies.add(state);
       if (isPromiseLike(value))
         throw new SuspendAndWaitForResolveError(value);
@@ -182,6 +182,7 @@ var handleSelectorResult = (value, selector, data) => {
     value.then((resolved) => {
       data.values.set(selector, resolved);
       updateStateSubscribers(selector, data);
+      console.log("Should we reEvaluate?");
     });
     return value;
   } else {
@@ -208,7 +209,7 @@ var updateSelectorSubscribers = (selector, data) => {
   const familySubscriptions = selector.family && data.subscriptions.get(selector.family);
   if (!subscribtions?.size && !familySubscriptions?.size)
     return;
-  if (subscribtions?.size && data.subscriptionsRequireEqualCheck.get(selector) || familySubscriptions?.size && data.subscriptionsRequireEqualCheck.get(selector.family)) {
+  if (subscribtions?.size && data.subscriptionsRequireEqualCheck.get(selector) || familySubscriptions?.size && selector.family && data.subscriptionsRequireEqualCheck.get(selector.family)) {
     try {
       const oldValue = data.expiredValues.get(selector);
       const newValue = initSelector(selector, data);
@@ -245,13 +246,13 @@ var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
 };
 var propagateUpdatedAtoms = (atoms, data) => {
   const clearedSelectors = new Set;
-  for (const atom3 of atoms) {
-    const consumers = data.stateConsumers.get(atom3);
+  for (const atom2 of atoms) {
+    const consumers = data.stateConsumers.get(atom2);
     if (consumers && consumers.size) {
       recursivlyResetSelectorTree(consumers, data, clearedSelectors);
     }
-    if (atom3.family) {
-      const consumersFamily = data.stateConsumers.get(atom3.family);
+    if (atom2.family) {
+      const consumersFamily = data.stateConsumers.get(atom2.family);
       if (consumersFamily?.size) {
         recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
       }
@@ -260,15 +261,15 @@ var propagateUpdatedAtoms = (atoms, data) => {
   for (const selector of clearedSelectors) {
     updateSelectorSubscribers(selector, data);
   }
-  for (const atom3 of atoms) {
-    updateStateSubscribers(atom3, data);
+  for (const atom2 of atoms) {
+    updateStateSubscribers(atom2, data);
   }
 };
 
 // src/lib/setAtom.ts
 import equal3 from "fast-deep-equal";
-var setAtom = (atom3, newValue, data) => {
-  const currentValue = getState2(atom3, data);
+var setAtom = (atom2, newValue, data) => {
+  const currentValue = getState(atom2, data);
   if (typeof newValue === "function") {
     newValue = newValue(currentValue);
     if (isPromiseLike(newValue) || isPromiseLike(currentValue))
@@ -276,16 +277,16 @@ var setAtom = (atom3, newValue, data) => {
   }
   if (equal3(currentValue, newValue))
     return;
-  data.values.set(atom3, newValue);
+  data.values.set(atom2, newValue);
   if (currentValue?.__isEmptyAtomPromise__) {
     currentValue.__resolveEmptyAtomPromise__(newValue);
   }
-  propagateUpdatedAtoms([atom3], data);
+  propagateUpdatedAtoms([atom2], data);
 };
 
 // src/lib/initAtom.ts
-var getAtomInitValue = (atom3, data) => {
-  if (atom3.defaultValue === undefined) {
+var getAtomInitValue = (atom2, data) => {
+  if (atom2.defaultValue === undefined) {
     let promiseResolve;
     const promise = new Promise((resolve) => {
       promiseResolve = resolve;
@@ -293,34 +294,38 @@ var getAtomInitValue = (atom3, data) => {
     promise.__isEmptyAtomPromise__ = true;
     promise.__resolveEmptyAtomPromise__ = promiseResolve;
     return promise;
-  } else if (typeof atom3.defaultValue === "function") {
-    const value = atom3.defaultValue();
+  } else if (typeof atom2.defaultValue === "function") {
+    const value = atom2.defaultValue();
     if (isPromiseLike(value)) {
       value.then((resolvedValue) => {
-        data.values.set(atom3, resolvedValue);
-        propagateUpdatedAtoms([atom3], data);
+        data.values.set(atom2, resolvedValue);
+        propagateUpdatedAtoms([atom2], data);
       });
     }
     return value;
   } else {
-    return atom3.defaultValue;
+    return atom2.defaultValue;
   }
 };
-var initAtom = (atom3, data) => {
-  const value = getAtomInitValue(atom3, data);
-  data.values.set(atom3, value);
-  if (atom3.onInit)
-    atom3.onInit((newVal) => {
-      setAtom(atom3, newVal, data);
+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;
 };
 
+// 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
-var getState2 = (state, data) => {
+function getState(state, data) {
   if (data.values.has(state))
     return data.values.get(state);
   if (isAtom(state))
@@ -328,20 +333,20 @@ var getState2 = (state, data) => {
   if (isSelector(state))
     return initSelector(state, data);
   if (isFamily(state)) {
-    const res = [];
-    for (const atom3 of state._map.values()) {
-      res.push([atom3.familyKey, getState2(atom3, data)]);
-    }
-    return res;
+    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/lib/resetAtom.ts
-var resetAtom = (atom3, data) => {
-  const res = initAtom(atom3, data);
+var resetAtom = (atom2, data) => {
+  const res = initAtom(atom2, data);
   if (!isPromiseLike(res)) {
-    propagateUpdatedAtoms([atom3], data);
+    propagateUpdatedAtoms([atom2], data);
   }
   return res;
 };
@@ -365,8 +370,8 @@ var unsubscribe = (state, subscription, data, mount) => {
     }
     if (mount) {
       if (subscribers.size === mount.mountSubscriptions.size) {
-        if (state.onUnmount) {
-          state.onUnmount(mount.onMountRes);
+        if (typeof mount.onUnmount === "function") {
+          mount.onUnmount();
         }
       }
     }
@@ -400,7 +405,7 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
   subscribers.add(subscription);
   let mount;
   if (subscribers.size === 1 && state.onMount) {
-    const store = storeFromStoreData2(data);
+    const store = storeFromStoreData(data);
     const mountSubscriptions = new Set;
     const originalSub = store.sub;
     store.sub = (state2, callback2) => {
@@ -408,7 +413,7 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
       return originalSub(state2, callback2);
     };
     mount = {
-      onMountRes: state.onMount(store, state),
+      onUnmount: state.onMount(store, state),
       mountSubscriptions
     };
   }
@@ -419,14 +424,14 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
 };
 
 // src/lib/setAtoms.ts
-import equal4 from "fast-deep-equal";
+import equal5 from "fast-deep-equal";
 var setAtoms = (pairs, data) => {
   const updatedAtoms = [];
-  for (let [atom3, value] of pairs) {
-    const currentValue = getState2(atom3, data);
-    if (!equal4(currentValue, value)) {
-      updatedAtoms.push(atom3);
-      data.values.set(atom3, value);
+  for (let [atom2, value] of pairs) {
+    const currentValue = getState(atom2, data);
+    if (!equal5(currentValue, value)) {
+      updatedAtoms.push(atom2);
+      data.values.set(atom2, value);
     }
   }
   propagateUpdatedAtoms(updatedAtoms, data);
@@ -460,7 +465,7 @@ var transaction = (callback, data) => {
   let dirtySelectors = new Set;
   const txnGet = (state) => {
     if (isAtom(state)) {
-      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState2(state, data);
+      return txnAtomMap.has(state) ? txnAtomMap.get(state) : getState(state, data);
     } else if (isSelector(state)) {
       if (txnSelectorCache.has(state)) {
         return txnSelectorCache.get(state);
@@ -482,25 +487,25 @@ var transaction = (callback, data) => {
       throw new Error("Unsupported state");
     }
   };
-  const txnSet = (atom3, value) => {
-    if (!isAtom(atom3))
+  const txnSet = (atom2, value) => {
+    if (!isAtom(atom2))
       throw new Error("Not an atom");
     if (typeof value === "function") {
-      const currentValue = txnGet(atom3);
+      const currentValue = txnGet(atom2);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom3, data)) {
+    for (const selector of findDependencies(atom2, data)) {
       dirtySelectors.add(selector);
       txnSelectorCache.delete(selector);
     }
-    if (txnSubscribers.get(atom3)?.size) {
-      recursivlyResetTxnSelectorCache(atom3, txnSubscribers, txnSelectorCache);
+    if (txnSubscribers.get(atom2)?.size) {
+      recursivlyResetTxnSelectorCache(atom2, txnSubscribers, txnSelectorCache);
     }
-    txnAtomMap.set(atom3, value);
+    txnAtomMap.set(atom2, value);
   };
-  const txnReset = (atom3) => {
-    const value = getAtomInitValue(atom3, data);
-    txnAtomMap.set(atom3, value);
+  const txnReset = (atom2) => {
+    const value = getAtomInitValue(atom2, data);
+    txnAtomMap.set(atom2, value);
     return value;
   };
   const commit = () => {
@@ -513,24 +518,14 @@ var transaction = (callback, data) => {
 };
 
 // src/lib/storeFromStoreData.ts
-var storeFromStoreData2 = (data) => {
-  const get = (state) => getState2(state, data);
+var storeFromStoreData = (data) => {
+  const get = (state) => getState(state, data);
   const set = (state, value) => {
-    if (isAtom(state)) {
-      return setAtom(state, value, data);
-    } else {
-      if (isSelector(state)) {
-        if (state.set) {
-          txn((set2, get2) => state.set({ get: get2, set: set2 }, value));
-          return;
-        } else {
-          throw new Error("set on selector is not supported");
-        }
-      }
-      throw new Error("Invalid state object passed to set");
-    }
+    if (!isAtom(state))
+      throw new Error("Invalid state object");
+    return setAtom(state, value, data);
   };
-  const reset = (atom3) => resetAtom(atom3, data);
+  const reset = (atom2) => resetAtom(atom2, data);
   const sub = (state, callback, deepEqualCheckBeforeCallback = true) => subscribe(state, callback, deepEqualCheckBeforeCallback, data);
   const txn = (callback) => transaction(callback, data);
   return {
@@ -546,7 +541,24 @@ var storeFromStoreData2 = (data) => {
 // src/createStore.ts
 var createStore = (id) => {
   const data = createStoreData(id);
-  return storeFromStoreData2(data);
+  return storeFromStoreData(data);
+};
+// src/createStoreWithSelectorSet.ts
+var setSelector = (selector, values, store) => {
+  return selector.set(store.set, store.get, store.reset, ...values);
+};
+var createStoreWithSelectorSet = (id) => {
+  const data = createStoreData(id);
+  const store = storeFromStoreData(data);
+  store.set = (state, value, ...rest) => {
+    if (isAtom(state))
+      return setAtom(state, value, data);
+    if (isSelector(state))
+      return setSelector(state, [value, ...rest], store);
+    throw new Error("Invalid state object");
+  };
+  store.kind = "storeWithSelectorSet";
+  return store;
 };
 // src/getDefaultStore.ts
 if (!globalThis._valdresStore) {
@@ -590,6 +602,7 @@ export {
   isFamily,
   isAtom,
   getDefaultStore,
+  createStoreWithSelectorSet,
   createStore,
   atomFamily,
   atom

package/package.json

@@ -1,10 +1,15 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.5",
+    "version": "0.2.0-alpha.7",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
     },
+    "homepage": "https://valdres.dev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/eigilsagafos/valdres.git"
+    },
     "type": "module",
     "exports": {
         "types": "./dist/index.d.ts",
@@ -28,11 +33,11 @@
         "react": ">=18",
         "react-dom": ">=18",
         "recoil": "0.7.7",
-        "typescript": "5.5.4"
+        "typescript": "5.6.2"
     },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "75721256957ea160c2a82ac4ebb5a12e4c447f1f"
+    "gitHead": "3ef9fcf34827ece4d4e32b81b28b4b21aaa1b887"
 }

package/dist/index.d.ts

@@ -1,19 +0,0 @@
-export { atom } from "./src/atom";
-export { atomFamily } from "./src/atomFamily";
-export { createStore } from "./src/createStore";
-export { getDefaultStore, resetDefaultStore } from "./src/getDefaultStore";
-export { selector } from "./src/selector";
-export { selectorFamily } from "./src/selectorFamily";
-export { isAtom } from "./src/utils/isAtom";
-export { isSelector } from "./src/utils/isSelector";
-export { isFamily } from "./src/utils/isFamily";
-export { isPromiseLike } from "./src/utils/isPromiseLike";
-export type { Atom } from "./src/types/Atom";
-export type { AtomFamily } from "./src/types/AtomFamily";
-export type { GetValue } from "./src/types/GetValue";
-export type { Selector } from "./src/types/Selector";
-export type { SelectorFamily } from "./src/types/SelectorFamily";
-export type { SetAtom } from "./src/types/SetAtom";
-export type { State } from "./src/types/State";
-export type { Store } from "./src/types/Store";
-export type { StoreData } from "./src/types/StoreData";

package/dist/src/atom.d.ts

@@ -1,9 +0,0 @@
-import type { Atom } from "./types/Atom";
-type AtomOptions<MountRes = undefined> = {
-    label?: string;
-    onInit?: () => void;
-    onMount?: () => MountRes;
-    onUnmount?: (mountRes?: MountRes) => void;
-};
-export declare const atom: <Value, FamilyKey = undefined, MountReturnValue = undefined>(defaultValue?: Value | (() => Value | Promise<Value>), options?: AtomOptions<MountReturnValue>) => Atom<Value, FamilyKey>;
-export {};

package/dist/src/atomFamily.d.ts

@@ -1,4 +0,0 @@
-import type { AtomFamily } from "./types/AtomFamily";
-type DefaultValueCallback<Key, Value> = (arg: Key) => Value | Promise<Value>;
-export declare const atomFamily: <Value, Key>(defaultValue?: Value | DefaultValueCallback<Key, Value>, debugLabel?: string) => AtomFamily<Value, Key>;
-export {};

package/dist/src/createStore.d.ts

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

package/dist/src/getDefaultStore.d.ts

@@ -1,2 +0,0 @@
-export declare const getDefaultStore: () => any;
-export declare const resetDefaultStore: () => import("..").Store;

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

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

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

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

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

@@ -1,4 +0,0 @@
-import type { Atom } from "../types/Atom";
-import type { StoreData } from "../types/StoreData";
-export declare const getAtomInitValue: <V>(atom: Atom<V>, data: StoreData) => any;
-export declare const initAtom: <V>(atom: Atom<V>, data: StoreData) => any;

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

@@ -1,4 +0,0 @@
-import type { StoreData } from "../types/StoreData";
-import type { Selector } from "../types/Selector";
-export declare const reEvaluateSelector: <V>(selector: Selector<V>, data: StoreData) => void;
-export declare const initSelector: <V>(selector: Selector<V>, data: StoreData) => V | Promise<V>;

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

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

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

@@ -1,3 +0,0 @@
-import type { Atom } from "../types/Atom";
-import type { StoreData } from "../types/StoreData";
-export declare const resetAtom: <V>(atom: Atom<V>, data: StoreData) => V | Promise<V>;

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

@@ -1,3 +0,0 @@
-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;

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

@@ -1,3 +0,0 @@
-import type { Atom } from "../types/Atom";
-import type { StoreData } from "../types/StoreData";
-export declare const setAtoms: (pairs: Map<Atom<any>, any>, data: StoreData) => void;

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

@@ -1 +0,0 @@
-export declare const stableStringify: (x: any) => string | number | boolean;

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

@@ -1,3 +0,0 @@
-import type { Store } from "../types/Store";
-import type { StoreData } from "../types/StoreData";
-export declare const storeFromStoreData: (data: StoreData) => Store;

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

@@ -1,4 +0,0 @@
-import type { Family } from "../types/Family";
-import type { State } from "../types/State";
-import type { StoreData } from "../types/StoreData";
-export declare const subscribe: <V>(state: State<V> | Family<V>, callback: any, requireDeepEqualCheckBeforeCallback: boolean, data: StoreData) => () => void;

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

@@ -1,8 +0,0 @@
-import type { State } from "../types/State";
-import type { StoreData } from "../types/StoreData";
-type GetValdresValue = <V>(state: State<V>) => V;
-type SetValdresValue = <V>(state: State<V>, value: V) => void;
-type ResetValdresValue = <V>(state: State<V>) => V;
-type TransactionInterface = (set: SetValdresValue, get: GetValdresValue, reset: ResetValdresValue, commit: () => void) => void;
-export declare const transaction: (callback: TransactionInterface, data: StoreData) => void;
-export {};

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

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

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

@@ -1,3 +0,0 @@
-import type { Selector } from "../types/Selector";
-import type { StoreData } from "../types/StoreData";
-export declare const updateSelectorSubscribers: (selector: Selector, data: StoreData) => void;

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

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

package/dist/src/selector.d.ts

@@ -1,3 +0,0 @@
-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>;

package/dist/src/selectorFamily.d.ts

@@ -1,2 +0,0 @@
-import type { SelectorFamily } from "./types/SelectorFamily";
-export declare const selectorFamily: <Value, Key>(get: any, debugLabel?: string) => SelectorFamily<Value, Key>;

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

@@ -1,10 +0,0 @@
-import type { AtomFamily } from "./AtomFamily";
-export type Atom<Value = unknown, FamilyKey = undefined, MountRes = undefined> = {
-    defaultValue?: Value | (() => Value | Promise<Value>);
-    label?: string;
-    family?: AtomFamily<Value, FamilyKey>;
-    familyKey?: FamilyKey;
-    onInit?: () => void;
-    onMount?: () => MountRes;
-    onUnmount?: (mountRes?: MountRes) => void;
-};

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

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

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

@@ -1,3 +0,0 @@
-import type { SelectorFamily } from "./SelectorFamily";
-import type { AtomFamily } from "./AtomFamily";
-export type Family<V, K = any> = AtomFamily<V, K> | SelectorFamily<V, K>;

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

@@ -1,2 +0,0 @@
-import type { State } from "./State";
-export type GetValue = <V>(state: State<V>) => V | Promise<V>;

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

@@ -1,2 +0,0 @@
-import type { Atom } from "./Atom";
-export type ResetAtom = <V>(state: Atom<V>) => V | Promise<V>;

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

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

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

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

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

@@ -1,2 +0,0 @@
-import type { Atom } from "./Atom";
-export type SetAtom = <V>(atom: Atom<V>, value: V | ((current: V) => V)) => void;

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

@@ -1,3 +0,0 @@
-import type { Atom } from "./Atom";
-import type { Selector } from "./Selector";
-export type State<V = any> = Atom<V> | Selector<V>;

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

@@ -1,14 +0,0 @@
-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";
-export type Store = {
-    data: StoreData;
-    get: GetValue;
-    set: SetAtom;
-    sub: SubscribeFn;
-    reset: ResetAtom;
-    txn: (callback: TransactionFn) => void;
-};

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

@@ -1,9 +0,0 @@
-export type StoreData = {
-    id: string;
-    values: WeakMap<WeakKey, any>;
-    expiredValues: WeakMap<WeakKey, any>;
-    subscriptions: WeakMap<WeakKey, Set<any>>;
-    subscriptionsRequireEqualCheck: WeakMap<WeakKey, boolean>;
-    stateConsumers: WeakMap<WeakKey, any>;
-    stateDependencies: WeakMap<WeakKey, any>;
-};

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

@@ -1,2 +0,0 @@
-import type { State } from "./State";
-export type SubscribeFn = <V>(state: State<V>, callback: () => void, requireDeepEqualCheckBeforeCallback?: boolean) => () => void;

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

@@ -1,4 +0,0 @@
-import type { GetValue } from "./GetValue";
-import type { ResetAtom } from "./ResetAtom";
-import type { SetAtom } from "./SetAtom";
-export type TransactionFn = (set: SetAtom, get: GetValue, reset: ResetAtom, commit: () => void) => void;

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

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

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

@@ -1 +0,0 @@
-export declare const isFamily: (state: any) => boolean;

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

@@ -1 +0,0 @@
-export declare const isPromiseLike: <T>(object: any) => object is Promise<T>;

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

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