alinea 2.0.0-preview.3 → 2.0.0-preview.4

package/dist/chunks/chunk-STAJCW4Z.js

@@ -1,322 +0,0 @@
-import {
-  atom
-} from "./chunk-Y7XOMJOC.js";
-
-// node_modules/jotai/esm/vanilla/utils.mjs
-var RESET = /* @__PURE__ */ Symbol(
-  (import.meta.env ? "production" : void 0) !== "production" ? "RESET" : ""
-);
-var didWarnDeprecation$1 = false;
-function atomFamily(initializeAtom, areEqual) {
-  if ((import.meta.env ? "production" : void 0) !== "production" && !didWarnDeprecation$1) {
-    console.warn(
-      "[DEPRECATED] atomFamily is deprecated and will be removed in v3. Please use the `jotai-family` package instead: https://github.com/jotaijs/jotai-family"
-    );
-    didWarnDeprecation$1 = true;
-  }
-  let shouldRemove = null;
-  const atoms = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  const createAtom = (param) => {
-    let item;
-    if (areEqual === void 0) {
-      item = atoms.get(param);
-    } else {
-      for (const [key, value] of atoms) {
-        if (areEqual(key, param)) {
-          item = value;
-          break;
-        }
-      }
-    }
-    if (item !== void 0) {
-      if (shouldRemove == null ? void 0 : shouldRemove(item[1], param)) {
-        createAtom.remove(param);
-      } else {
-        return item[0];
-      }
-    }
-    const newAtom = initializeAtom(param);
-    atoms.set(param, [newAtom, Date.now()]);
-    notifyListeners("CREATE", param, newAtom);
-    return newAtom;
-  };
-  const notifyListeners = (type, param, atom2) => {
-    for (const listener of listeners) {
-      listener({ type, param, atom: atom2 });
-    }
-  };
-  createAtom.unstable_listen = (callback) => {
-    listeners.add(callback);
-    return () => {
-      listeners.delete(callback);
-    };
-  };
-  createAtom.getParams = () => atoms.keys();
-  createAtom.remove = (param) => {
-    if (areEqual === void 0) {
-      if (!atoms.has(param)) return;
-      const [atom2] = atoms.get(param);
-      atoms.delete(param);
-      notifyListeners("REMOVE", param, atom2);
-    } else {
-      for (const [key, [atom2]] of atoms) {
-        if (areEqual(key, param)) {
-          atoms.delete(key);
-          notifyListeners("REMOVE", key, atom2);
-          break;
-        }
-      }
-    }
-  };
-  createAtom.setShouldRemove = (fn) => {
-    shouldRemove = fn;
-    if (!shouldRemove) return;
-    for (const [key, [atom2, createdAt]] of atoms) {
-      if (shouldRemove(createdAt, key)) {
-        atoms.delete(key);
-        notifyListeners("REMOVE", key, atom2);
-      }
-    }
-  };
-  return createAtom;
-}
-var getCached$2 = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
-var cache1$3 = /* @__PURE__ */ new WeakMap();
-var memo3 = (create, dep1, dep2, dep3) => {
-  const cache2 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache1$3, dep1);
-  const cache3 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache2, dep2);
-  return getCached$2(create, cache3, dep3);
-};
-function selectAtom(anAtom, selector, equalityFn = Object.is) {
-  return memo3(
-    () => {
-      const EMPTY = /* @__PURE__ */ Symbol();
-      const selectValue = ([value, prevSlice]) => {
-        if (prevSlice === EMPTY) {
-          return selector(value);
-        }
-        const slice = selector(value, prevSlice);
-        return equalityFn(prevSlice, slice) ? prevSlice : slice;
-      };
-      const derivedAtom = atom((get) => {
-        const prev = get(derivedAtom);
-        const value = get(anAtom);
-        return selectValue([value, prev]);
-      });
-      derivedAtom.init = EMPTY;
-      return derivedAtom;
-    },
-    anAtom,
-    selector,
-    equalityFn
-  );
-}
-var isPromiseLike$2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
-function createJSONStorage(getStringStorage = () => {
-  try {
-    return window.localStorage;
-  } catch (e) {
-    if ((import.meta.env ? "production" : void 0) !== "production") {
-      if (typeof window !== "undefined") {
-        console.warn(e);
-      }
-    }
-    return void 0;
-  }
-}, options) {
-  var _a;
-  let lastStr;
-  let lastValue;
-  const storage = {
-    getItem: (key, initialValue) => {
-      var _a2, _b;
-      const parse = (str2) => {
-        str2 = str2 || "";
-        if (lastStr !== str2) {
-          try {
-            lastValue = JSON.parse(str2, options == null ? void 0 : options.reviver);
-          } catch (e) {
-            return initialValue;
-          }
-          lastStr = str2;
-        }
-        return lastValue;
-      };
-      const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
-      if (isPromiseLike$2(str)) {
-        return str.then(parse);
-      }
-      return parse(str);
-    },
-    setItem: (key, newValue) => {
-      var _a2;
-      return (_a2 = getStringStorage()) == null ? void 0 : _a2.setItem(
-        key,
-        JSON.stringify(newValue, options == null ? void 0 : options.replacer)
-      );
-    },
-    removeItem: (key) => {
-      var _a2;
-      return (_a2 = getStringStorage()) == null ? void 0 : _a2.removeItem(key);
-    }
-  };
-  const createHandleSubscribe = (subscriber2) => (key, callback, initialValue) => subscriber2(key, (v) => {
-    let newValue;
-    try {
-      newValue = JSON.parse(v || "", options == null ? void 0 : options.reviver);
-    } catch (e) {
-      newValue = initialValue;
-    }
-    callback(newValue);
-  });
-  let subscriber;
-  try {
-    subscriber = (_a = getStringStorage()) == null ? void 0 : _a.subscribe;
-  } catch (e) {
-  }
-  if (!subscriber && typeof window !== "undefined" && typeof window.addEventListener === "function" && window.Storage) {
-    subscriber = (key, callback) => {
-      if (!(getStringStorage() instanceof window.Storage)) {
-        return () => {
-        };
-      }
-      const storageEventCallback = (e) => {
-        if (e.storageArea === getStringStorage() && e.key === key) {
-          callback(e.newValue);
-        }
-      };
-      window.addEventListener("storage", storageEventCallback);
-      return () => {
-        window.removeEventListener("storage", storageEventCallback);
-      };
-    };
-  }
-  if (subscriber) {
-    storage.subscribe = createHandleSubscribe(subscriber);
-  }
-  return storage;
-}
-var defaultStorage = createJSONStorage();
-function atomWithStorage(key, initialValue, storage = defaultStorage, options) {
-  const getOnInit = options == null ? void 0 : options.getOnInit;
-  const baseAtom = atom(
-    getOnInit ? storage.getItem(key, initialValue) : initialValue
-  );
-  if ((import.meta.env ? "production" : void 0) !== "production") {
-    baseAtom.debugPrivate = true;
-  }
-  baseAtom.onMount = (setAtom) => {
-    var _a;
-    setAtom(storage.getItem(key, initialValue));
-    return (_a = storage.subscribe) == null ? void 0 : _a.call(storage, key, setAtom, initialValue);
-  };
-  const anAtom = atom(
-    (get) => get(baseAtom),
-    (get, set, update) => {
-      const nextValue = typeof update === "function" ? update(get(baseAtom)) : update;
-      if (nextValue === RESET) {
-        set(baseAtom, initialValue);
-        return storage.removeItem(key);
-      }
-      if (isPromiseLike$2(nextValue)) {
-        return nextValue.then((resolvedValue) => {
-          set(baseAtom, resolvedValue);
-          return storage.setItem(key, resolvedValue);
-        });
-      }
-      set(baseAtom, nextValue);
-      return storage.setItem(key, nextValue);
-    }
-  );
-  return anAtom;
-}
-var getCached = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
-var cache1$1 = /* @__PURE__ */ new WeakMap();
-var memo2 = (create, dep1, dep2) => {
-  const cache2 = getCached(() => /* @__PURE__ */ new WeakMap(), cache1$1, dep1);
-  return getCached(create, cache2, dep2);
-};
-var isPromiseLike = (p) => typeof (p == null ? void 0 : p.then) === "function";
-var defaultFallback = () => void 0;
-function unwrap(anAtom, fallback = defaultFallback) {
-  return memo2(
-    () => {
-      const promiseErrorCache = /* @__PURE__ */ new WeakMap();
-      const promiseResultCache = /* @__PURE__ */ new WeakMap();
-      const refreshAtom = atom(0);
-      const triggerRefreshAtom = atom([]);
-      triggerRefreshAtom.INTERNAL_onInit = (store) => {
-        store.set(triggerRefreshAtom, [
-          () => store.set(refreshAtom, (c) => c + 1)
-        ]);
-      };
-      if ((import.meta.env ? "production" : void 0) !== "production") {
-        refreshAtom.debugPrivate = true;
-        triggerRefreshAtom.debugPrivate = true;
-      }
-      const promiseAndValueAtom = atom((get) => {
-        get(refreshAtom);
-        let prev;
-        try {
-          prev = get(promiseAndValueAtom);
-        } catch (e) {
-        }
-        const promise = get(anAtom);
-        if (!isPromiseLike(promise)) {
-          return { v: promise };
-        }
-        if (promise !== (prev == null ? void 0 : prev.p)) {
-          promise.then(
-            (v) => {
-              promiseResultCache.set(promise, v);
-              const [triggerRefresh] = get(triggerRefreshAtom);
-              triggerRefresh();
-            },
-            (e) => {
-              promiseErrorCache.set(promise, e);
-              const [triggerRefresh] = get(triggerRefreshAtom);
-              triggerRefresh();
-            }
-          );
-        }
-        if (promiseErrorCache.has(promise)) {
-          throw promiseErrorCache.get(promise);
-        }
-        if (promiseResultCache.has(promise)) {
-          return {
-            p: promise,
-            v: promiseResultCache.get(promise)
-          };
-        }
-        if (prev && "v" in prev) {
-          return { p: promise, f: fallback(prev.v), v: prev.v };
-        }
-        return { p: promise, f: fallback() };
-      });
-      promiseAndValueAtom.init = void 0;
-      if ((import.meta.env ? "production" : void 0) !== "production") {
-        promiseAndValueAtom.debugPrivate = true;
-      }
-      return atom(
-        (get) => {
-          const state = get(promiseAndValueAtom);
-          if ("f" in state) {
-            return state.f;
-          }
-          return state.v;
-        },
-        (_get, set, ...args) => set(anAtom, ...args)
-      );
-    },
-    anAtom,
-    fallback
-  );
-}
-
-export {
-  atomFamily,
-  selectAtom,
-  atomWithStorage,
-  unwrap
-};

package/dist/chunks/chunk-U4VOHNR2.js

@@ -1,210 +0,0 @@
-import {
-  createStore,
-  getBuildingBlocks,
-  getDefaultStore
-} from "./chunk-Y7XOMJOC.js";
-
-// node_modules/jotai/esm/react.mjs
-import React, { createContext, useContext, useRef, createElement, useReducer, useEffect, useDebugValue, useCallback } from "react";
-var StoreContext = createContext(
-  void 0
-);
-function useStore(options) {
-  const store = useContext(StoreContext);
-  return (options == null ? void 0 : options.store) || store || getDefaultStore();
-}
-function Provider({
-  children,
-  store
-}) {
-  const storeRef = useRef(null);
-  if (store) {
-    return createElement(StoreContext.Provider, { value: store }, children);
-  }
-  if (storeRef.current === null) {
-    storeRef.current = createStore();
-  }
-  return createElement(
-    StoreContext.Provider,
-    {
-      // TODO: If this is not a false positive, consider using useState instead of useRef like https://github.com/pmndrs/jotai/pull/2771
-      // eslint-disable-next-line react-hooks/refs
-      value: storeRef.current
-    },
-    children
-  );
-}
-var isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
-var attachPromiseStatus = (promise) => {
-  if (!promise.status) {
-    promise.status = "pending";
-    promise.then(
-      (v) => {
-        promise.status = "fulfilled";
-        promise.value = v;
-      },
-      (e) => {
-        promise.status = "rejected";
-        promise.reason = e;
-      }
-    );
-  }
-};
-var use = React.use || // A shim for older React versions
-((promise) => {
-  if (promise.status === "pending") {
-    throw promise;
-  } else if (promise.status === "fulfilled") {
-    return promise.value;
-  } else if (promise.status === "rejected") {
-    throw promise.reason;
-  } else {
-    attachPromiseStatus(promise);
-    throw promise;
-  }
-});
-var continuablePromiseMap = /* @__PURE__ */ new WeakMap();
-var createContinuablePromise = (store, promise, getValue) => {
-  const buildingBlocks = getBuildingBlocks(store);
-  const registerAbortHandler = buildingBlocks[26];
-  let continuablePromise = continuablePromiseMap.get(promise);
-  if (!continuablePromise) {
-    continuablePromise = new Promise((resolve, reject) => {
-      let curr = promise;
-      const onFulfilled = (me) => (v) => {
-        if (curr === me) {
-          resolve(v);
-        }
-      };
-      const onRejected = (me) => (e) => {
-        if (curr === me) {
-          reject(e);
-        }
-      };
-      const onAbort = () => {
-        try {
-          const nextValue = getValue();
-          if (isPromiseLike(nextValue)) {
-            continuablePromiseMap.set(nextValue, continuablePromise);
-            curr = nextValue;
-            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-            registerAbortHandler(buildingBlocks, store, nextValue, onAbort);
-          } else {
-            resolve(nextValue);
-          }
-        } catch (e) {
-          reject(e);
-        }
-      };
-      promise.then(onFulfilled(promise), onRejected(promise));
-      registerAbortHandler(buildingBlocks, store, promise, onAbort);
-    });
-    continuablePromiseMap.set(promise, continuablePromise);
-  }
-  return continuablePromise;
-};
-function useAtomValue(atom, options) {
-  const { delay, unstable_promiseStatus: promiseStatus = !React.use } = options || {};
-  const store = useStore(options);
-  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
-    (prev) => {
-      const nextValue = store.get(atom);
-      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
-        return prev;
-      }
-      return [nextValue, store, atom];
-    },
-    void 0,
-    () => [store.get(atom), store, atom]
-  );
-  let value = valueFromReducer;
-  if (storeFromReducer !== store || atomFromReducer !== atom) {
-    rerender();
-    value = store.get(atom);
-  }
-  useEffect(() => {
-    const unsub = store.sub(atom, () => {
-      if (promiseStatus) {
-        try {
-          const value2 = store.get(atom);
-          if (isPromiseLike(value2)) {
-            attachPromiseStatus(
-              createContinuablePromise(store, value2, () => store.get(atom))
-            );
-          }
-        } catch (e) {
-        }
-      }
-      if (typeof delay === "number") {
-        console.warn(`[DEPRECATED] delay option is deprecated and will be removed in v3.
-
-Migration guide:
-
-Create a custom hook like the following.
-
-function useAtomValueWithDelay<Value>(
-  atom: Atom<Value>,
-  options: { delay: number },
-): Value {
-  const { delay } = options
-  const store = useStore(options)
-  const [value, setValue] = useState(() => store.get(atom))
-  useEffect(() => {
-    const unsub = store.sub(atom, () => {
-      setTimeout(() => setValue(store.get(atom)), delay)
-    })
-    return unsub
-  }, [store, atom, delay])
-  return value
-}
-`);
-        setTimeout(rerender, delay);
-        return;
-      }
-      rerender();
-    });
-    rerender();
-    return unsub;
-  }, [store, atom, delay, promiseStatus]);
-  useDebugValue(value);
-  if (isPromiseLike(value)) {
-    const promise = createContinuablePromise(
-      store,
-      value,
-      () => store.get(atom)
-    );
-    if (promiseStatus) {
-      attachPromiseStatus(promise);
-    }
-    return use(promise);
-  }
-  return value;
-}
-function useSetAtom(atom, options) {
-  const store = useStore(options);
-  const setAtom = useCallback(
-    (...args) => {
-      if ((import.meta.env ? "production" : void 0) !== "production" && !("write" in atom)) {
-        throw new Error("not writable atom");
-      }
-      return store.set(atom, ...args);
-    },
-    [store, atom]
-  );
-  return setAtom;
-}
-function useAtom(atom, options) {
-  return [
-    useAtomValue(atom, options),
-    // We do wrong type assertion here, which results in throwing an error.
-    useSetAtom(atom, options)
-  ];
-}
-
-export {
-  useStore,
-  Provider,
-  useAtomValue,
-  useSetAtom,
-  useAtom
-};