valdres 0.1.0-alpha.9 → 0.2.0-alpha.0

package/dist/index.js

@@ -1 +1,565 @@
-var J=(o,p)=>{if(!p)return{defaultValue:o};return{defaultValue:o,...p}};var S=(o)=>o&&o.then&&typeof o.then==="function";var _=(o,p)=>{if(typeof o==="string"&&!o.includes('"')&&!o.includes("\\"))return`"${o}"`;switch(typeof o){case"undefined":return"";case"boolean":return o?"true":"false";case"number":case"symbol":return String(o);case"string":return JSON.stringify(o);case"function":return`__FUNCTION(${o.toString()})__`}if(o===null)return"null";if(typeof o!=="object")return JSON.stringify(o)??"";if(S(o))return"__PROMISE__";if(Array.isArray(o))return`[${o.map((m,f)=>_(m,f.toString()))}]`;if(typeof o.toJSON==="function")return _(o.toJSON(p),p);if(o instanceof Map){const m={};for(let[f,n]of o)m[typeof f==="string"?f:stringify(f,opt)]=n;return _(m,p)}if(o instanceof Set)return _(Array.from(o).sort((m,f)=>_(m).localeCompare(_(f))),p);if(Symbol!==void 0&&o[Symbol.iterator]!=null&&typeof o[Symbol.iterator]==="function")return _(Array.from(o),p);return`{${Object.keys(o).filter((m)=>o[m]!==void 0).sort().map((m)=>`${_(m)}:${_(o[m],m)}`).join(",")}}`},N=(o)=>{if(typeof o==="string"||typeof o==="boolean"||typeof o==="number")return o;return _(o)};var F=(o,p,m)=>{if(p)return typeof p==="function"?()=>typeof o==="function"?p(o(m)):p(o):p;else return typeof o==="function"?()=>o(m):o},W=(o,p)=>{const m=new Map,f=(n,i)=>{const t=N(n);if(m.has(t)){if(i)throw new Error("defaultOverride is only allowed first time an atom is initiaizlied");return m.get(t)}const r=p&&p+"_"+t,y=J(F(o,i,n),{label:r});return y.family=f,y.familyKey=Object.freeze(n),m.set(t,y),y};return f._map=m,f};var j=(o,p)=>{const m=p.subscriptions.get(o);if(m?.size)for(let f of m)f.callback();if(o.family){const f=p.subscriptions.get(o.family);if(f?.size)for(let n of f)n.callback(o.familyKey)}};import c from"fast-deep-equal";import no from"fast-deep-equal";class w extends Error{promise;constructor(o){super();this.promise=o}}var Y=(o,p)=>{const m=p.stateConsumers.get(o);if(m)return m;const f=new Set;return p.stateConsumers.set(o,f),f},g=(o,p)=>{const m=p.stateDependencies.get(o)??new Set,f=new Set;let n;try{n=o.get((r)=>{const y=A(r,p);if(f.add(r),S(y))throw new w(y);return y})}catch(r){if(r instanceof w)n=r;else throw r}const i=f?.difference(m),t=m?.difference(f);for(let r of i)Y(r,p).add(o);for(let r of t)Y(r,p).delete(o);return p.stateDependencies.set(o,f),n};var z=(o,p)=>{const m=g(o,p);if(m instanceof w)return m.promise.then(()=>z(o,p)),p.values.set(o,m.promise),m.promise;else if(S(m))return m.then((f)=>{p.values.set(o,f),j(o,p),console.log("TODO: Should we check if other selectors are using this?")}),p.values.set(o,m),m;else return p.values.set(o,m),m};var Z=(o,p,m)=>{const f=p.subscriptions.get(o),n=o.family&&p.subscriptions.get(o.family);if(!f?.size&&!n?.size)return;const i=z(o,p);if(c(i,m))return;if(f?.size)for(let t of f)t.callback();if(n?.size)for(let t of n)t.callback(state.familyKey)};var P=(o,p,m,f)=>{for(let n of o)if(!m.has(n)){m.add(n),f.set(n,p.values.get(n)),p.values.delete(n);const i=p.stateConsumers.get(n);if(i?.size)P(i,p,m,f)}},M=(o,p)=>{const m=new Set,f=new Map;for(let n of o){const i=p.stateConsumers.get(n);if(i&&i.size)P(i,p,m,f);if(n.family){const t=p.stateConsumers.get(n.family);if(t?.size)P(t,p,m,f)}}for(let n of m)Z(n,p,f.get(n));for(let n of o)j(n,p)};import L from"fast-deep-equal";var U=(o,p,m)=>{const f=A(o,m);if(typeof p==="function"){if(p=p(f),S(p)||S(f))throw new Error("Todo, how should we handle this?")}if(L(f,p))return;if(m.values.set(o,p),f?.__isEmptyAtomPromise__)f.__resolveEmptyAtomPromise__(p);M([o],m)};var Q=(o,p)=>{if(o.defaultValue===void 0){let m;const f=new Promise((n)=>{m=n});return f.__isEmptyAtomPromise__=!0,f.__resolveEmptyAtomPromise__=m,f}else if(typeof o.defaultValue==="function"){const m=o.defaultValue();if(S(m))m.then((f)=>{p.values.set(o,f),M([o],p)});return m}else return o.defaultValue},B=(o,p)=>{const m=Q(o,p);if(p.values.set(o,m),o.onInit)o.onInit((f)=>{U(o,f,p)});return m};var G=(o)=>Object.hasOwn(o,"defaultValue");var K=(o)=>Object.hasOwn(o,"get");var I=(o)=>Object.hasOwn(o,"_map");var A=(o,p)=>{if(p.values.has(o))return p.values.get(o);if(G(o))return B(o,p);if(K(o))return z(o,p);if(I(o)){const m=[];for(let f of o._map.values())m.push([f.familyKey,A(f,p)]);return m}throw console.log("nsadf",I(o),o,o._map),new Error("Invalid object passed to get")};var $=(o,p,m,f)=>{const n=m.subscriptions.get(o);if(n){if(n.delete(p),n.size===0){if(o.onUnmount)o.onUnmount(f)}}};var R=(o,p)=>{const m=new Set;return p.subscriptions.set(o,m),m},C=(o,p,m)=>{const f=m.subscriptions.get(o)||R(o,m);if(K(o)&&!m.values.has(o))z(o,m);let n;if(I(o))n={callback:p,state:o};else n={callback:p};let i;if(f.size===0&&o.onMount)i=o.onMount((t)=>{U(o,t,m)});return f.add(n),()=>$(o,n,m,i)};import b from"fast-deep-equal";var O=(o,p)=>{const m=[];for(let[f,n]of o){const i=A(f,p);if(!b(i,n))m.push(f),p.values.set(f,n)}M(m,p)};var T=(o,p,m=new Set)=>{const f=p.stateConsumers.get(o);if(f?.size){for(let n of f)if(!m.has(n))m.add(n),T(n,p,m)}return m},q=(o,p)=>{let m=new Map,f=new Set;const n=(D)=>{const V=m.get(D);if(V)return V;else if(f.has(D)){const h=D.get(n);return m.set(D,h),h}else return A(D,p)},i=(D,V)=>{if(!G(D))throw new Error("Not an atom");if(typeof V==="function"){const h=n(D);V=V(h)}for(let h of T(D,p))f.add(h),m.delete(h);m.set(D,V)},t=(D)=>{const V=Q(D,p);return m.set(D,V),V},r=()=>{O(m,p),f.clear()},y=o(i,n,t,r);return r(),y};var E=(o,p)=>{const m=B(o,p);if(!S(m))M([o],p);return m};var s=()=>(Math.random()+1).toString(36).substring(7),H=(o)=>{const p={id:o??s(),values:new WeakMap,subscriptions:new WeakMap,stateConsumers:new WeakMap,stateDependencies:new WeakMap},m=(r)=>A(r,p),f=(r,y)=>{if(G(r))return U(r,y,p);else{if(K(r))if(r.set){t((D,V)=>r.set({get:V,set:D},y));return}else throw new Error("set on selector is not supported");throw new Error("Invalid state object passed to set")}},n=(r)=>E(r,p),i=(r,y)=>C(r,y,p),t=(r)=>q(r,p);return{get:m,set:f,sub:i,txn:t,reset:n,data:p}};if(!globalThis._valdresStore)globalThis._valdresStore=H("default");var x=()=>globalThis._valdresStore,k=()=>globalThis._valdresStore=H();var X=(o,p)=>({get:o,debugLabel:p});var v=(o,p)=>{const m=new Map,f=(n)=>{let i;try{i=N(n)}catch(y){throw console.log("errro",{key:n,debugLabel:p,e:y}),y}if(m.has(i))return m.get(i);const t=p?p+"_"+i:void 0,r=X((y)=>o(n)(y),t);return r.family=f,m.set(i,r),r};return f._map=m,f};export{v as selectorFamily,X as selector,k as resetDefaultStore,K as isSelector,S as isPromiseLike,I as isFamily,G as isAtom,x as getDefaultStore,H as createStore,W as atomFamily,J as atom};
+// src/atom.ts
+var atom = (defaultValue, options) => {
+  if (!options)
+    return { defaultValue };
+  return {
+    defaultValue,
+    ...options
+  };
+};
+// src/utils/isPromiseLike.ts
+var isPromiseLike = (object) => 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 handleDefaultValue = (defaultValue, override, key) => {
+  if (override) {
+    return typeof override === "function" ? () => typeof defaultValue === "function" ? override(defaultValue(key)) : override(defaultValue) : override;
+  } else {
+    return typeof defaultValue === "function" ? () => defaultValue(key) : defaultValue;
+  }
+};
+var atomFamily = (defaultValue, debugLabel) => {
+  const map = new Map;
+  const atomFamily2 = (key, defaultOverride) => {
+    const keyStringified = stableStringify(key);
+    if (map.has(keyStringified)) {
+      if (defaultOverride)
+        throw new Error("defaultOverride is only allowed first time an atom is initiaizlied");
+      return map.get(keyStringified);
+    }
+    const atomDebugLabel = debugLabel && debugLabel + "_" + keyStringified;
+    const newAtom = atom(handleDefaultValue(defaultValue, defaultOverride, key), {
+      label: atomDebugLabel
+    });
+    newAtom.family = atomFamily2;
+    newAtom.familyKey = Object.freeze(key);
+    map.set(keyStringified, newAtom);
+    return newAtom;
+  };
+  atomFamily2._map = map;
+  return atomFamily2;
+};
+// src/lib/updateStateSubscribers.ts
+var updateStateSubscribers = (state2, data) => {
+  const subscribtions = data.subscriptions.get(state2);
+  if (subscribtions?.size) {
+    for (const subscribtion of subscribtions) {
+      subscribtion.callback();
+    }
+  }
+  if (state2.family) {
+    const familySubscriptions = data.subscriptions.get(state2.family);
+    if (familySubscriptions?.size) {
+      for (const subscribtion of familySubscriptions) {
+        subscribtion.callback(state2.familyKey);
+      }
+    }
+  }
+};
+
+// src/lib/updateSelectorSubscribers.ts
+import equal2 from "fast-deep-equal";
+
+// src/lib/initSelector.ts
+import equal from "fast-deep-equal";
+class SuspendAndWaitForResolveError extends Error {
+  promise;
+  constructor(promise) {
+    super();
+    this.promise = promise;
+  }
+}
+var getOrInitConsumersSet = (state2, data) => {
+  const set = data.stateConsumers.get(state2);
+  if (set)
+    return set;
+  const newSet = new Set;
+  data.stateConsumers.set(state2, newSet);
+  return newSet;
+};
+var evaluateSelector = (selector, data) => {
+  const currentDependencies = data.stateDependencies.get(selector) ?? new Set;
+  const updatedDependencies = new Set;
+  let result;
+  try {
+    result = selector.get((state2) => {
+      const value = getState2(state2, data);
+      updatedDependencies.add(state2);
+      if (isPromiseLike(value))
+        throw new SuspendAndWaitForResolveError(value);
+      return value;
+    });
+  } catch (error) {
+    if (error instanceof SuspendAndWaitForResolveError) {
+      result = error;
+    } else {
+      throw error;
+    }
+  }
+  const added = updatedDependencies?.difference(currentDependencies);
+  const removed = currentDependencies?.difference(updatedDependencies);
+  for (const state2 of added) {
+    const set = getOrInitConsumersSet(state2, data);
+    set.add(selector);
+  }
+  for (const state2 of removed) {
+    const set = getOrInitConsumersSet(state2, data);
+    set.delete(selector);
+  }
+  data.stateDependencies.set(selector, updatedDependencies);
+  return result;
+};
+var handleSelectorResult = (value, selector, data) => {
+  if (value instanceof SuspendAndWaitForResolveError) {
+    value.promise.then(() => initSelector(selector, data));
+    return value.promise;
+  } else if (isPromiseLike(value)) {
+    value.then((resolved) => {
+      data.values.set(selector, resolved);
+      updateStateSubscribers(selector, data);
+      console.log(`TODO: Should we check if other selectors are using this?`);
+    });
+    return value;
+  } else {
+    return value;
+  }
+};
+var initSelector = (selector, data) => {
+  const tmpValue = evaluateSelector(selector, data);
+  const value = handleSelectorResult(tmpValue, selector, data);
+  if (data.expiredValues.has(selector)) {
+    const expiredValue = data.expiredValues.get(selector);
+    if (equal(expiredValue, value)) {
+      data.values.set(selector, expiredValue);
+      return expiredValue;
+    }
+  }
+  data.values.set(selector, value);
+  return value;
+};
+
+// src/lib/updateSelectorSubscribers.ts
+var updateSelectorSubscribers = (selector, data) => {
+  const subscribtions = data.subscriptions.get(selector);
+  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)) {
+    try {
+      const oldValue = data.expiredValues.get(selector);
+      const newValue = initSelector(selector, data);
+      if (equal2(newValue, oldValue))
+        return;
+    } catch (e) {
+    }
+  }
+  if (subscribtions?.size) {
+    for (const subscribtion of subscribtions) {
+      subscribtion.callback();
+    }
+  }
+  if (familySubscriptions?.size) {
+    for (const subscribtion of familySubscriptions) {
+      subscribtion.callback(state.familyKey);
+    }
+  }
+};
+
+// src/lib/propagateUpdatedAtoms.ts
+var recursivlyResetSelectorTree = (selectors, data, clearedSelectors) => {
+  for (const selector of selectors) {
+    if (!clearedSelectors.has(selector)) {
+      clearedSelectors.add(selector);
+      data.expiredValues.set(selector, data.values.get(selector));
+      data.values.delete(selector);
+      const consumers = data.stateConsumers.get(selector);
+      if (consumers?.size) {
+        recursivlyResetSelectorTree(consumers, data, clearedSelectors);
+      }
+    }
+  }
+};
+var propagateUpdatedAtoms = (atoms, data) => {
+  const clearedSelectors = new Set;
+  for (const atom3 of atoms) {
+    const consumers = data.stateConsumers.get(atom3);
+    if (consumers && consumers.size) {
+      recursivlyResetSelectorTree(consumers, data, clearedSelectors);
+    }
+    if (atom3.family) {
+      const consumersFamily = data.stateConsumers.get(atom3.family);
+      if (consumersFamily?.size) {
+        recursivlyResetSelectorTree(consumersFamily, data, clearedSelectors);
+      }
+    }
+  }
+  for (const selector of clearedSelectors) {
+    updateSelectorSubscribers(selector, data);
+  }
+  for (const atom3 of atoms) {
+    updateStateSubscribers(atom3, data);
+  }
+};
+
+// src/lib/setAtom.ts
+import equal3 from "fast-deep-equal";
+var setAtom = (atom3, newValue, data) => {
+  const currentValue = getState2(atom3, 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))
+    return;
+  data.values.set(atom3, newValue);
+  if (currentValue?.__isEmptyAtomPromise__) {
+    currentValue.__resolveEmptyAtomPromise__(newValue);
+  }
+  propagateUpdatedAtoms([atom3], data);
+};
+
+// src/lib/initAtom.ts
+var getAtomInitValue = (atom3, data) => {
+  if (atom3.defaultValue === undefined) {
+    let promiseResolve;
+    const promise = new Promise((resolve) => {
+      promiseResolve = resolve;
+    });
+    promise.__isEmptyAtomPromise__ = true;
+    promise.__resolveEmptyAtomPromise__ = promiseResolve;
+    return promise;
+  } else if (typeof atom3.defaultValue === "function") {
+    const value = atom3.defaultValue();
+    if (isPromiseLike(value)) {
+      value.then((resolvedValue) => {
+        data.values.set(atom3, resolvedValue);
+        propagateUpdatedAtoms([atom3], data);
+      });
+    }
+    return value;
+  } else {
+    return atom3.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);
+    });
+  return value;
+};
+
+// src/utils/isAtom.ts
+var isAtom = (state2) => Object.hasOwn(state2, "defaultValue");
+
+// src/utils/isSelector.ts
+var isSelector = (state2) => Object.hasOwn(state2, "get");
+
+// src/utils/isFamily.ts
+var isFamily = (state2) => Object.hasOwn(state2, "_map");
+
+// src/lib/getState.ts
+var getState2 = (state2, data) => {
+  if (data.values.has(state2))
+    return data.values.get(state2);
+  if (isAtom(state2))
+    return initAtom(state2, data);
+  if (isSelector(state2))
+    return initSelector(state2, data);
+  if (isFamily(state2)) {
+    const res = [];
+    for (const atom3 of state2._map.values()) {
+      res.push([atom3.familyKey, getState2(atom3, data)]);
+    }
+    return res;
+  }
+  throw new Error("Invalid object passed to get");
+};
+
+// src/lib/unsubscribe.ts
+var unsubscribe = (state2, subscription, data, mountRes) => {
+  const subscribers = data.subscriptions.get(state2);
+  if (subscribers) {
+    subscribers.delete(subscription);
+    if (data.subscriptionsRequireEqualCheck.get(state2)) {
+      let remove = true;
+      for (const subscriber of subscribers) {
+        if (subscriber.requireDeepEqualCheckBeforeCallback) {
+          remove = false;
+          break;
+        }
+      }
+      if (remove) {
+        data.subscriptionsRequireEqualCheck.delete(state2);
+      }
+    }
+    if (subscribers.size === 0) {
+      if (state2.onUnmount) {
+        state2.onUnmount(mountRes);
+      }
+    }
+  }
+};
+
+// src/lib/subscribe.ts
+var initSubscribers = (state2, data) => {
+  const set = new Set;
+  data.subscriptions.set(state2, set);
+  return set;
+};
+var subscribe = (state2, callback, requireDeepEqualCheckBeforeCallback, data) => {
+  const subscribers = data.subscriptions.get(state2) || initSubscribers(state2, data);
+  if (isSelector(state2) && !data.values.has(state2)) {
+    initSelector(state2, data);
+  }
+  let subscription;
+  if (isFamily(state2)) {
+    subscription = {
+      callback,
+      state: state2,
+      requireDeepEqualCheckBeforeCallback
+    };
+  } else {
+    subscription = {
+      callback,
+      requireDeepEqualCheckBeforeCallback
+    };
+  }
+  let mountRes;
+  if (subscribers.size === 0 && state2.onMount) {
+    mountRes = state2.onMount((value) => {
+      setAtom(state2, value, data);
+    });
+  }
+  subscribers.add(subscription);
+  if (requireDeepEqualCheckBeforeCallback && data.subscriptionsRequireEqualCheck.get(state2) !== true) {
+    data.subscriptionsRequireEqualCheck.set(state2, true);
+  }
+  return () => unsubscribe(state2, subscription, data, mountRes);
+};
+
+// src/lib/setAtoms.ts
+import equal4 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);
+    }
+  }
+  propagateUpdatedAtoms(updatedAtoms, data);
+};
+
+// src/lib/transaction.ts
+var findDependencies = (state2, data, result = new Set) => {
+  const consumers = data.stateConsumers.get(state2);
+  if (consumers?.size) {
+    for (const consumer of consumers) {
+      if (!result.has(consumer)) {
+        result.add(consumer);
+        findDependencies(consumer, data, result);
+      }
+    }
+  }
+  return result;
+};
+var transaction = (callback, data) => {
+  let txnAtomMap = new Map;
+  let txnSelectorCache = new Map;
+  let dirtySelectors = new Set;
+  const txnGet = (state2) => {
+    if (isAtom(state2)) {
+      return txnAtomMap.has(state2) ? txnAtomMap.get(state2) : getState2(state2, data);
+    } else {
+      if (txnSelectorCache.has(state2)) {
+        return txnSelectorCache.get(state2);
+      } else if (dirtySelectors.has(state2)) {
+        const res = state2.get(txnGet);
+        txnSelectorCache.set(state2, res);
+        return res;
+      } else {
+        return getState2(state2, data);
+      }
+    }
+  };
+  const txnSet = (atom3, value) => {
+    if (!isAtom(atom3))
+      throw new Error("Not an atom");
+    if (typeof value === "function") {
+      const currentValue = txnGet(atom3);
+      value = value(currentValue);
+    }
+    for (const selector of findDependencies(atom3, data)) {
+      dirtySelectors.add(selector);
+      txnSelectorCache.delete(selector);
+    }
+    txnAtomMap.set(atom3, value);
+  };
+  const txnReset = (atom3) => {
+    const value = getAtomInitValue(atom3, data);
+    txnAtomMap.set(atom3, value);
+    return value;
+  };
+  const commit = () => {
+    setAtoms(txnAtomMap, data);
+    dirtySelectors.clear();
+  };
+  const result = callback(txnSet, txnGet, txnReset, commit);
+  commit();
+  return result;
+};
+
+// src/lib/resetAtom.ts
+var resetAtom = (atom3, data) => {
+  const res = initAtom(atom3, data);
+  if (!isPromiseLike(res)) {
+    propagateUpdatedAtoms([atom3], data);
+  }
+  return res;
+};
+
+// src/createStore.ts
+var generateId = () => (Math.random() + 1).toString(36).substring(7);
+var createStore = (id) => {
+  const data = {
+    id: id ?? generateId(),
+    values: new WeakMap,
+    expiredValues: new WeakMap,
+    subscriptions: new WeakMap,
+    subscriptionsRequireEqualCheck: new WeakMap,
+    stateConsumers: new WeakMap,
+    stateDependencies: new WeakMap
+  };
+  const get = (state2) => getState2(state2, data);
+  const set = (state2, value) => {
+    if (isAtom(state2)) {
+      return setAtom(state2, value, data);
+    } else {
+      if (isSelector(state2)) {
+        if (state2.set) {
+          txn((set2, get2) => state2.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");
+    }
+  };
+  const reset = (atom3) => resetAtom(atom3, data);
+  const sub = (state2, callback, deepEqualCheckBeforeCallback = true) => subscribe(state2, callback, deepEqualCheckBeforeCallback, data);
+  const txn = (callback) => transaction(callback, data);
+  return {
+    get,
+    set,
+    sub,
+    txn,
+    reset,
+    data
+  };
+};
+// src/getDefaultStore.ts
+if (!globalThis._valdresStore) {
+  globalThis._valdresStore = createStore("default");
+}
+var getDefaultStore = () => globalThis._valdresStore;
+var resetDefaultStore = () => globalThis._valdresStore = createStore();
+// src/selector.ts
+var selector = (get, debugLabel) => ({
+  get,
+  debugLabel
+});
+// src/selectorFamily.ts
+var selectorFamily = (get, debugLabel) => {
+  const map = new Map;
+  const selectorFamily2 = (key) => {
+    let keyStringified;
+    try {
+      keyStringified = stableStringify(key);
+    } catch (e) {
+      console.log(`errro`, { key, debugLabel, e });
+      throw e;
+    }
+    if (map.has(keyStringified))
+      return map.get(keyStringified);
+    const selectorDebugLabel = debugLabel ? debugLabel + "_" + keyStringified : undefined;
+    const newSelector = selector((selectorArgs) => get(key)(selectorArgs), selectorDebugLabel);
+    newSelector.family = selectorFamily2;
+    map.set(keyStringified, newSelector);
+    return newSelector;
+  };
+  selectorFamily2._map = map;
+  return selectorFamily2;
+};
+export {
+  selectorFamily,
+  selector,
+  resetDefaultStore,
+  isSelector,
+  isPromiseLike,
+  isFamily,
+  isAtom,
+  getDefaultStore,
+  createStore,
+  atomFamily,
+  atom
+};

package/package.json

@@ -1,14 +1,20 @@
 {
     "name": "valdres",
-    "version": "0.1.0-alpha.9",
-    "module": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "version": "0.2.0-alpha.0",
+    "license": "MIT",
+    "author": {
+        "name": "Eigil Sagafos"
+    },
+    "type": "module",
+    "exports": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+    },
     "files": [
         "dist"
     ],
-    "type": "module",
     "scripts": {
-        "build": "bun scripts/build.ts",
+        "build": "NODE_ENV=production bun scripts/build.ts",
         "build:types": "tsc index.ts --declaration --emitDeclarationOnly --outDir dist",
         "test": "bun test"
     },
@@ -17,6 +23,7 @@
     },
     "devDependencies": {
         "@testing-library/react-hooks": "8.0.1",
+        "mitata": "0.1.14",
         "react": ">=18",
         "react-dom": ">=18",
         "recoil": "0.7.7",
@@ -26,5 +33,5 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "1324ed703443d3b6bea79193a6e398da5cad0ca0"
+    "gitHead": "ec1d460976eb7aa8b97c5def2c39bc406670d74c"
 }