alinea
Version:
Headless git-based CMS
342 lines (339 loc) • 10.3 kB
JavaScript
import {
atom
} from "./chunk-WJ67RR7S.js";
// node_modules/jotai/esm/vanilla/utils.mjs
var RESET = Symbol(
(import.meta.env ? "production" : void 0) !== "production" ? "RESET" : ""
);
function atomFamily(initializeAtom, areEqual) {
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;
};
function 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 isPromiseLike = (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(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 || "");
} 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) => {
setAtom(storage.getItem(key, initialValue));
let unsub;
if (storage.subscribe) {
unsub = storage.subscribe(key, setAtom, initialValue);
}
return unsub;
};
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 (nextValue instanceof Promise) {
return nextValue.then((resolvedValue) => {
set(baseAtom, resolvedValue);
return storage.setItem(key, resolvedValue);
});
}
set(baseAtom, nextValue);
return storage.setItem(key, nextValue);
}
);
return anAtom;
}
var cache1$1 = /* @__PURE__ */ new WeakMap();
var memo1 = (create, dep1) => (cache1$1.has(dep1) ? cache1$1 : cache1$1.set(dep1, create())).get(dep1);
var isPromise$1 = (x) => x instanceof Promise;
var LOADING = { state: "loading" };
function loadable(anAtom) {
return memo1(() => {
const loadableCache = /* @__PURE__ */ new WeakMap();
const refreshAtom = atom(0);
if ((import.meta.env ? "production" : void 0) !== "production") {
refreshAtom.debugPrivate = true;
}
const derivedAtom = atom(
(get, { setSelf }) => {
get(refreshAtom);
let value;
try {
value = get(anAtom);
} catch (error) {
return { state: "hasError", error };
}
if (!isPromise$1(value)) {
return { state: "hasData", data: value };
}
const promise = value;
const cached1 = loadableCache.get(promise);
if (cached1) {
return cached1;
}
if (promise.status === "fulfilled") {
loadableCache.set(promise, { state: "hasData", data: promise.value });
} else if (promise.status === "rejected") {
loadableCache.set(promise, {
state: "hasError",
error: promise.reason
});
} else {
promise.then(
(data) => {
loadableCache.set(promise, { state: "hasData", data });
},
(error) => {
loadableCache.set(promise, { state: "hasError", error });
}
).finally(setSelf);
}
const cached2 = loadableCache.get(promise);
if (cached2) {
return cached2;
}
loadableCache.set(promise, LOADING);
return LOADING;
},
(_get, set) => {
set(refreshAtom, (c) => c + 1);
}
);
if ((import.meta.env ? "production" : void 0) !== "production") {
derivedAtom.debugPrivate = true;
}
return atom((get) => get(derivedAtom));
}, anAtom);
}
var getCached = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
var cache1 = /* @__PURE__ */ new WeakMap();
var memo2 = (create, dep1, dep2) => {
const cache2 = getCached(() => /* @__PURE__ */ new WeakMap(), cache1, dep1);
return getCached(create, cache2, dep2);
};
var isPromise = (x) => x instanceof Promise;
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);
if ((import.meta.env ? "production" : void 0) !== "production") {
refreshAtom.debugPrivate = true;
}
const promiseAndValueAtom = atom(
(get, { setSelf }) => {
get(refreshAtom);
const prev = get(promiseAndValueAtom);
const promise = get(anAtom);
if (!isPromise(promise)) {
return { v: promise };
}
if (promise !== (prev == null ? void 0 : prev.p)) {
if (promise.status === "fulfilled") {
promiseResultCache.set(promise, promise.value);
} else if (promise.status === "rejected") {
promiseErrorCache.set(promise, promise.reason);
} else {
promise.then(
(v) => promiseResultCache.set(promise, v),
(e) => promiseErrorCache.set(promise, e)
).finally(setSelf);
}
}
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() };
},
(_get, set) => {
set(refreshAtom, (c) => c + 1);
}
);
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,
atomWithStorage,
loadable,
unwrap
};