valdres 0.2.0-alpha.20 → 0.2.0-alpha.21

package/dist/index.js

@@ -1,14 +1,26 @@
 // src/lib/setAtom.ts
-import equal4 from "fast-deep-equal";
+import equal4 from "fast-deep-equal/es6";
 
 // 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/isAtom.ts
 var isAtom = (state) => Object.hasOwn(state, "defaultValue");
 
+// 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");
 
@@ -34,85 +46,10 @@ var updateStateSubscribers = (state, data) => {
 };
 
 // src/lib/updateSelectorSubscribers.ts
-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/utils/isSelector.ts
-var isSelector = (state) => state && Object.hasOwn(state, "get");
-
-// 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 if (isSelector(atom.defaultValue)) {
-    return getState(atom.defaultValue, data);
-  } 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/isAtomFamily.ts
-var isAtomFamily = (state) => state && Object.hasOwn(state, "__valdresAtomFamilyMap");
-
-// src/utils/isSelectorFamily.ts
-var isSelectorFamily = (state) => state && Object.hasOwn(state, "__valdresSelectorFamilyMap");
-
-// 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 (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;
-    return array;
-  }
-  throw new Error("Invalid object passed to get");
-}
+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) {
@@ -180,7 +117,7 @@ var initSelector = (selector, data) => {
   const value = handleSelectorResult(tmpValue, selector, data);
   if (data.expiredValues.has(selector)) {
     const expiredValue = data.expiredValues.get(selector);
-    if (equal2(expiredValue, value)) {
+    if (equal(expiredValue, value)) {
       data.values.set(selector, expiredValue);
       return expiredValue;
     }
@@ -199,7 +136,7 @@ var updateSelectorSubscribers = (selector, data) => {
     try {
       const oldValue = data.expiredValues.get(selector);
       const newValue = initSelector(selector, data);
-      if (equal3(newValue, oldValue))
+      if (equal2(newValue, oldValue))
         return;
     } catch (e) {
     }
@@ -252,6 +189,85 @@ var propagateUpdatedAtoms = (atoms, data) => {
   }
 };
 
+// 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 if (isSelector(atom.defaultValue)) {
+    return getState(atom.defaultValue, data);
+  } else {
+    return atom.defaultValue;
+  }
+};
+var initAtom = (atom, data) => {
+  let value = getAtomInitValue(atom, data);
+  data.values.set(atom, value);
+  if (isFamilyAtom(atom)) {
+    const currentKeySet = getState(atom.family.__keysAtom, data);
+    if (!currentKeySet.has(atom.familyKey)) {
+      const newSet = new Set(currentKeySet);
+      newSet.add(atom.familyKey);
+      setAtom(atom.family.__keysAtom, newSet, data);
+    }
+  }
+  if (atom.onInit)
+    atom.onInit((newVal) => {
+      value = newVal;
+      setAtom(atom, newVal, data, true);
+    }, 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);
@@ -330,6 +346,20 @@ function atom(defaultValue, options) {
     ...options
   };
 }
+// src/lib/atomFamilyAtom.ts
+function atomFamilyAtom(defaultValue, options) {
+  if (options.global) {
+    return {
+      ...options,
+      defaultValue
+    };
+  }
+  return {
+    ...options,
+    defaultValue
+  };
+}
+
 // src/lib/stableStringify.ts
 var stableStringifyRecurse = (x, key) => {
   if (typeof x === "string" && !x.includes('"') && !x.includes("\\")) {
@@ -384,21 +414,33 @@ var stableStringify = (x) => {
   return stableStringifyRecurse(x);
 };
 
-// src/lib/atomFamilyAtom.ts
-function atomFamilyAtom(defaultValue, options) {
-  if (options.global) {
+// src/selector.ts
+var selector = (get, options) => {
+  if (!options)
+    return { get };
+  return { ...options, get };
+};
+
+// src/atomFamily.ts
+var createOptions = (options = {}, family, familyKey, keyStringified) => {
+  if (options.label) {
     return {
       ...options,
-      defaultValue
+      label: options?.label + "_" + keyStringified,
+      family,
+      familyKey
     };
+  } else {
+    return { ...options, family, familyKey };
   }
-  return {
-    ...options,
-    defaultValue
-  };
-}
-
-// src/atomFamily.ts
+};
+var handleDefaultValue = (defaultValue, key) => {
+  if (isSelectorFamily(defaultValue))
+    return defaultValue(key);
+  if (typeof defaultValue === "function")
+    return () => defaultValue(key);
+  return defaultValue;
+};
 function atomFamily(defaultValue, options) {
   const map = new Map;
   const atomFamily2 = (key) => {
@@ -412,40 +454,38 @@ function atomFamily(defaultValue, options) {
   };
   atomFamily2.__valdresAtomFamilyMap = map;
   atomFamily2.release = (key) => map.delete(key);
+  const keysAtom = atom(new Set);
+  atomFamily2.__keysAtom = keysAtom;
+  atomFamily2.__keysSelector = selector((get) => Array.from(get(keysAtom)));
   if (options?.label)
     atomFamily2.label = options.label;
   return atomFamily2;
 }
-var createOptions = (options = {}, family, familyKey, keyStringified) => {
-  if (options.label) {
+// src/lib/createStoreData.ts
+var generateId = () => (Math.random() + 1).toString(36).substring(7);
+var generateStoreData = (id = generateId()) => {
+  return {
+    id,
+    values: new WeakMap,
+    expiredValues: new WeakMap,
+    subscriptions: new WeakMap,
+    subscriptionsRequireEqualCheck: new WeakMap,
+    stateConsumers: new WeakMap,
+    stateDependencies: new WeakMap,
+    scopes: {}
+  };
+};
+function createStoreData(id, parent) {
+  if (parent) {
     return {
-      ...options,
-      label: options?.label + "_" + keyStringified,
-      family,
-      familyKey
+      ...generateStoreData(id),
+      parent,
+      scopeConsumers: parent ? new Set : undefined
     };
   } else {
-    return { ...options, family, familyKey };
+    return generateStoreData(id);
   }
-};
-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);
-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) => {
@@ -480,6 +520,7 @@ var unsubscribe = (state, subscription, data, mount, maxAgeCleanup) => {
     if (subscribers.size === 0) {
       if (maxAgeCleanup)
         maxAgeCleanup();
+      data.subscriptions.delete(state);
     }
     if (mount) {
       if (subscribers.size === mount.mountSubscriptions.size) {
@@ -498,6 +539,14 @@ var initSubscribers = (state, data) => {
   return set;
 };
 var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) => {
+  if ("parent" in data && !data.values.has(state) && isAtom(state)) {
+    const parentUnsubscribe = subscribe(state, callback, requireDeepEqualCheckBeforeCallback, data.parent);
+    let originalCallback = callback;
+    callback = () => {
+      parentUnsubscribe();
+      originalCallback();
+    };
+  }
   const subscribers = data.subscriptions.get(state) || initSubscribers(state, data);
   if (isSelector(state) && !data.values.has(state)) {
     initSelector(state, data);
@@ -564,7 +613,7 @@ var subscribe = (state, callback, requireDeepEqualCheckBeforeCallback, data) =>
 };
 
 // src/lib/setAtoms.ts
-import equal5 from "fast-deep-equal";
+import equal5 from "fast-deep-equal/es6";
 var setAtoms = (pairs, data) => {
   const updatedAtoms = [];
   for (let [atom2, value] of pairs) {
@@ -636,9 +685,9 @@ var transaction = (callback, data) => {
       const currentValue = txnGet(atom2);
       value = value(currentValue);
     }
-    for (const selector of findDependencies(atom2, data)) {
-      dirtySelectors.add(selector);
-      txnSelectorCache.delete(selector);
+    for (const selector2 of findDependencies(atom2, data)) {
+      dirtySelectors.add(selector2);
+      txnSelectorCache.delete(selector2);
     }
     if (txnSubscribers.get(atom2)?.size) {
       recursivlyResetTxnSelectorCache(atom2, txnSubscribers, txnSelectorCache);
@@ -667,7 +716,7 @@ Only \`atom\` cam be set.
 var InvalidStateSetError = `Invalid state object passed to set().
 Only \`atom\` can be set.
 `;
-var storeFromStoreData = (data) => {
+function storeFromStoreData(data, detach) {
   const get = (state) => getState(state, data);
   const set = (state, value) => {
     if (isAtom(state))
@@ -679,24 +728,51 @@ var storeFromStoreData = (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 {
-    get,
-    set,
-    sub,
-    txn,
-    reset,
-    data
+  const scope = (scopeId) => {
+    let scopedStoreData;
+    if (scopeId in data.scopes) {
+      scopedStoreData = data.scopes[scopeId];
+    } else {
+      scopedStoreData = createStoreData(scopeId, data);
+      data.scopes[scopeId] = scopedStoreData;
+    }
+    const detach2 = () => {
+      scopedStoreData.scopeConsumers.delete(detach2);
+      if (scopedStoreData.scopeConsumers.size === 0) {
+        delete data.scopes[scopeId];
+      }
+    };
+    scopedStoreData.scopeConsumers.add(detach2);
+    const newStore = storeFromStoreData(data.scopes[scopeId], detach2);
+    return newStore;
   };
-};
+  if (detach) {
+    return {
+      get,
+      set,
+      sub,
+      txn,
+      reset,
+      data,
+      scope,
+      detach
+    };
+  } else {
+    return {
+      get,
+      set,
+      sub,
+      txn,
+      reset,
+      data,
+      scope
+    };
+  }
+}
 
-// src/createStore.ts
-var createStore = (id) => {
-  const data = createStoreData(id);
-  return storeFromStoreData(data);
-};
 // src/createStoreWithSelectorSet.ts
-var setSelector = (selector, values, store) => {
-  return selector.set(store.set, store.get, store.reset, ...values);
+var setSelector = (selector2, values, store) => {
+  return selector2.set(store.set, store.get, store.reset, ...values);
 };
 var createStoreWithSelectorSet = (id) => {
   const data = createStoreData(id);
@@ -711,12 +787,6 @@ var createStoreWithSelectorSet = (id) => {
   store.kind = "storeWithSelectorSet";
   return store;
 };
-// src/selector.ts
-var selector = (get, options) => {
-  if (!options)
-    return { get };
-  return { ...options, get };
-};
 // src/selectorFamily.ts
 var createOptions2 = (options, key) => {
   if (options.label) {
@@ -744,15 +814,27 @@ var selectorFamily = (get, options) => {
     selectorFamily2.label = options.label;
   return selectorFamily2;
 };
+// src/store.ts
+var store = (id) => {
+  const data = createStoreData(id);
+  return storeFromStoreData(data);
+};
+// src/utils/isFamilySelector.ts
+var isFamilySelector = (state) => isFamilyState(state) && isSelector(state);
 export {
+  store,
   selectorFamily,
   selector,
+  isSelectorFamily,
   isSelector,
   isPromiseLike,
+  isFamilyState,
+  isFamilySelector,
+  isFamilyAtom,
   isFamily,
+  isAtomFamily,
   isAtom,
   createStoreWithSelectorSet,
-  createStore,
   atomFamily,
   atom
 };

package/dist/{index.d.ts → types/index.d.ts}

@@ -1,16 +1,22 @@
 export { atom } from "./src/atom";
 export { atomFamily } from "./src/atomFamily";
-export { createStore } from "./src/createStore";
 export { createStoreWithSelectorSet } from "./src/createStoreWithSelectorSet";
 export { selector } from "./src/selector";
 export { selectorFamily } from "./src/selectorFamily";
+export { store } from "./src/store";
 export { isAtom } from "./src/utils/isAtom";
-export { isSelector } from "./src/utils/isSelector";
+export { isAtomFamily } from "./src/utils/isAtomFamily";
 export { isFamily } from "./src/utils/isFamily";
+export { isFamilyAtom } from "./src/utils/isFamilyAtom";
+export { isFamilySelector } from "./src/utils/isFamilySelector";
+export { isFamilyState } from "./src/utils/isFamilyState";
 export { isPromiseLike } from "./src/utils/isPromiseLike";
+export { isSelector } from "./src/utils/isSelector";
+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 { ResetAtom } from "./src/types/ResetAtom";
 export type { Selector } from "./src/types/Selector";
 export type { SelectorFamily } from "./src/types/SelectorFamily";
 export type { SetAtom } from "./src/types/SetAtom";

package/dist/{src → types/src}/atom.d.ts

@@ -13,4 +13,4 @@ import type { GlobalAtom } from "./types/GlobalAtom";
 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>;
+export declare function atom<V>(defaultValue?: AtomDefaultValue<V>, options?: AtomOptions<V>): Atom<V>;

package/dist/types/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<Key, Value>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value> & {
+    global: true;
+}): AtomFamilyGlobalAtom<Key, Value>;
+export declare function atomFamilyAtom<Key, Value>(defaultValue: AtomDefaultValue<Value>, options: AtomOptions<Value>): AtomFamilyAtom<Key, Value>;

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

@@ -0,0 +1,3 @@
+import type { ScopedStoreData, StoreData } from "../types/StoreData";
+export declare function createStoreData(id?: string, parent?: undefined): StoreData;
+export declare function createStoreData(id: string, parent: StoreData): ScopedStoreData;

package/dist/{src → types/src}/lib/initAtom.d.ts

@@ -1,4 +1,5 @@
 import type { Atom } from "../types/Atom";
+import type { AtomFamilyAtom } from "../types/AtomFamilyAtom";
 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;
+export declare const initAtom: <V, K>(atom: Atom<V> | AtomFamilyAtom<K, V>, data: StoreData) => any;

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

@@ -0,0 +1,4 @@
+import type { ScopedStore, Store } from "../types/Store";
+import type { ScopedStoreData, StoreData } from "../types/StoreData";
+export declare function storeFromStoreData(data: ScopedStoreData, detach: () => void): ScopedStore;
+export declare function storeFromStoreData(data: StoreData): Store;

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

@@ -0,0 +1 @@
+export declare const store: (id?: string) => import("..").Store;

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

@@ -0,0 +1,12 @@
+import type { Atom } from "./Atom";
+import type { AtomFamilyAtom } from "./AtomFamilyAtom";
+import type { FamilyKey } from "./FamilyKey";
+import type { Selector } from "./Selector";
+export type AtomFamily<Key = FamilyKey, Value = unknown> = {
+    (key: Key): AtomFamilyAtom<Key, Value>;
+    release: (key: Key) => void;
+    label?: string;
+    __valdresAtomFamilyMap: Map<Key, AtomFamilyAtom<Key, Value>>;
+    __keysAtom: Atom<Set<Key>>;
+    __keysSelector: Selector<Key[]>;
+};

package/dist/{src → types/src}/types/AtomFamilyAtom.d.ts

@@ -1,6 +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>;
+export type AtomFamilyAtom<Key = unknown, Value = unknown> = Atom<Value> & {
+    family: AtomFamily<Key, Value>;
     familyKey: Key;
 };

package/dist/{src → types/src}/types/AtomFamilyGlobalAtom.d.ts

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

package/dist/{src → types/src}/types/Family.d.ts

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

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

@@ -0,0 +1,8 @@
+import type { Atom } from "./Atom";
+import type { AtomFamily } from "./AtomFamily";
+import type { Selector } from "./Selector";
+export type GetValue = {
+    <V>(atom: Atom<V>, scopeId?: string): V;
+    <V>(selector: Selector<V>, scopeId?: string): V;
+    <V, K>(family: AtomFamily<K, V>, scopeId?: string): K[];
+};

package/dist/{src → types/src}/types/SetAtom.d.ts

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

package/dist/{src → types/src}/types/Store.d.ts

@@ -2,19 +2,23 @@ import type { Atom } from "./Atom";
 import type { AtomFamilyAtom } from "./AtomFamilyAtom";
 import type { GetValue } from "./GetValue";
 import type { ResetAtom } from "./ResetAtom";
-import type { StoreData } from "./StoreData";
+import type { ScopedStoreData, 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, K>(atom: AtomFamilyAtom<K, V>, value: V): void;
     <V>(atom: Atom<V>, value: V): void;
 };
-export type Store = {
-    data: StoreData;
+export type Store<T = StoreData> = {
+    data: T;
     get: GetValue;
     set: SetAtom;
     sub: SubscribeFn;
     reset: ResetAtom;
     txn: (callback: TransactionFn) => void;
+    scope: (scopeId: string) => ScopedStore;
+};
+export type ScopedStore = Store<ScopedStoreData> & {
+    detach: () => void;
 };
 export {};

package/dist/{src → types/src}/types/StoreData.d.ts

@@ -1,4 +1,4 @@
-export type StoreData = {
+export type RootStoreData = {
     id: string;
     values: WeakMap<WeakKey, any>;
     expiredValues: WeakMap<WeakKey, any>;
@@ -6,4 +6,12 @@ export type StoreData = {
     subscriptionsRequireEqualCheck: WeakMap<WeakKey, boolean>;
     stateConsumers: WeakMap<WeakKey, any>;
     stateDependencies: WeakMap<WeakKey, any>;
+    scopes: {
+        [scopeId: string]: ScopedStoreData;
+    };
 };
+export type ScopedStoreData = RootStoreData & {
+    parent: StoreData;
+    scopeConsumers: Set<() => void>;
+};
+export type StoreData = RootStoreData | ScopedStoreData;

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

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

package/dist/types/src/utils/isFamilySelector.d.ts

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "valdres",
-    "version": "0.2.0-alpha.20",
+    "version": "0.2.0-alpha.21",
     "license": "MIT",
     "author": {
         "name": "Eigil Sagafos"
@@ -12,15 +12,15 @@
     },
     "type": "module",
     "exports": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "default": "./dist/index.js",
+        "types": "./dist/types/index.d.ts"
     },
     "files": [
         "dist"
     ],
     "scripts": {
-        "build": "rm -rf dist && NODE_ENV=production bun scripts/build.ts",
-        "build:types": "tsc",
+        "build": "NODE_ENV=production bun build index.ts --outdir ./dist --packages external",
+        "build:types": "rm -rf dist/types && tsc",
         "test": "bun test"
     },
     "dependencies": {
@@ -39,5 +39,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "de1b98e5a5dfe28014234a5813c9c046f10b551c"
+    "gitHead": "6d564893ff8e43a913e9d7afa531e83d3d4e69b1"
 }

package/dist/src/createStore.d.ts

@@ -1 +0,0 @@
-export declare const createStore: (id?: string) => import("..").Store;

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

@@ -1,8 +0,0 @@
-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/createStoreData.d.ts

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

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/types/AtomFamily.d.ts

@@ -1,8 +0,0 @@
-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, AtomFamilyAtom<Value, Key>>;
-};

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

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

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

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

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

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

package/dist/{src → types/src}/lib/getState.d.ts

@@ -1,7 +1,7 @@
-import type { StoreData } from "../types/StoreData";
 import type { Atom } from "../types/Atom";
 import type { AtomFamily } from "../types/AtomFamily";
 import type { Selector } from "../types/Selector";
+import type { StoreData } from "../types/StoreData";
 export declare function getState<V, K>(atom: Atom<V>, data: StoreData): V;
 export declare function getState<V, K>(selector: Selector<V>, data: StoreData): V;
 export declare function getState<V, K>(family: AtomFamily<V, K>, data: StoreData): K[];