289 lines
8.5 KiB
JavaScript
289 lines
8.5 KiB
JavaScript
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/clean-stores/index.js
|
|
let clean = Symbol("clean");
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/atom/index.js
|
|
var listenerQueue = [];
|
|
var lqIndex = 0;
|
|
var QUEUE_ITEMS_PER_LISTENER = 4;
|
|
let epoch = 0;
|
|
let atom = (initialValue) => {
|
|
let listeners = [];
|
|
let $atom = {
|
|
get() {
|
|
if (!$atom.lc) $atom.listen(() => {})();
|
|
return $atom.value;
|
|
},
|
|
lc: 0,
|
|
listen(listener) {
|
|
$atom.lc = listeners.push(listener);
|
|
return () => {
|
|
for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
|
|
else i += QUEUE_ITEMS_PER_LISTENER;
|
|
let index = listeners.indexOf(listener);
|
|
if (~index) {
|
|
listeners.splice(index, 1);
|
|
if (!--$atom.lc) $atom.off();
|
|
}
|
|
};
|
|
},
|
|
notify(oldValue, changedKey) {
|
|
epoch++;
|
|
let runListenerQueue = !listenerQueue.length;
|
|
for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
|
|
if (runListenerQueue) {
|
|
for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
|
|
listenerQueue.length = 0;
|
|
}
|
|
},
|
|
off() {},
|
|
set(newValue) {
|
|
let oldValue = $atom.value;
|
|
if (oldValue !== newValue) {
|
|
$atom.value = newValue;
|
|
$atom.notify(oldValue);
|
|
}
|
|
},
|
|
subscribe(listener) {
|
|
let unbind = $atom.listen(listener);
|
|
listener($atom.value);
|
|
return unbind;
|
|
},
|
|
value: initialValue
|
|
};
|
|
$atom[clean] = () => {
|
|
listeners = [];
|
|
$atom.lc = 0;
|
|
$atom.off();
|
|
};
|
|
return $atom;
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/lifecycle/index.js
|
|
var MOUNT = 5;
|
|
var UNMOUNT = 6;
|
|
var REVERT_MUTATION = 10;
|
|
let on = (object, listener, eventKey, mutateStore) => {
|
|
object.events = object.events || {};
|
|
if (!object.events[eventKey + REVERT_MUTATION]) object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
|
|
object.events[eventKey].reduceRight((event, l) => (l(event), event), {
|
|
shared: {},
|
|
...eventProps
|
|
});
|
|
});
|
|
object.events[eventKey] = object.events[eventKey] || [];
|
|
object.events[eventKey].push(listener);
|
|
return () => {
|
|
let currentListeners = object.events[eventKey];
|
|
let index = currentListeners.indexOf(listener);
|
|
currentListeners.splice(index, 1);
|
|
if (!currentListeners.length) {
|
|
delete object.events[eventKey];
|
|
object.events[eventKey + REVERT_MUTATION]();
|
|
delete object.events[eventKey + REVERT_MUTATION];
|
|
}
|
|
};
|
|
};
|
|
let STORE_UNMOUNT_DELAY = 1e3;
|
|
let onMount = ($store, initialize) => {
|
|
let listener = (payload) => {
|
|
let destroy = initialize(payload);
|
|
if (destroy) $store.events[UNMOUNT].push(destroy);
|
|
};
|
|
return on($store, listener, MOUNT, (runListeners) => {
|
|
let originListen = $store.listen;
|
|
$store.listen = (...args) => {
|
|
if (!$store.lc && !$store.active) {
|
|
$store.active = true;
|
|
runListeners();
|
|
}
|
|
return originListen(...args);
|
|
};
|
|
let originOff = $store.off;
|
|
$store.events[UNMOUNT] = [];
|
|
$store.off = () => {
|
|
originOff();
|
|
setTimeout(() => {
|
|
if ($store.active && !$store.lc) {
|
|
$store.active = false;
|
|
for (let destroy of $store.events[UNMOUNT]) destroy();
|
|
$store.events[UNMOUNT] = [];
|
|
}
|
|
}, STORE_UNMOUNT_DELAY);
|
|
};
|
|
{
|
|
let originClean = $store[clean];
|
|
$store[clean] = () => {
|
|
for (let destroy of $store.events[UNMOUNT]) destroy();
|
|
$store.events[UNMOUNT] = [];
|
|
$store.active = false;
|
|
originClean();
|
|
};
|
|
}
|
|
return () => {
|
|
$store.listen = originListen;
|
|
$store.off = originOff;
|
|
};
|
|
});
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/map/index.js
|
|
let map = (initial = {}) => {
|
|
let $map = atom(initial);
|
|
$map.setKey = function(key, value) {
|
|
let oldMap = $map.value;
|
|
if (typeof value === "undefined" && key in $map.value) {
|
|
$map.value = { ...$map.value };
|
|
delete $map.value[key];
|
|
$map.notify(oldMap, key);
|
|
} else if ($map.value[key] !== value) {
|
|
$map.value = {
|
|
...$map.value,
|
|
[key]: value
|
|
};
|
|
$map.notify(oldMap, key);
|
|
}
|
|
};
|
|
return $map;
|
|
};
|
|
|
|
//#endregion
|
|
//#region node_modules/.pnpm/@nanostores+persistent@1.1.0_nanostores@1.0.1/node_modules/@nanostores/persistent/index.js
|
|
var identity = (a) => a;
|
|
var storageEngine = {};
|
|
var eventsEngine = {
|
|
addEventListener() {},
|
|
removeEventListener() {}
|
|
};
|
|
function testSupport() {
|
|
try {
|
|
return typeof localStorage !== "undefined";
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
if (testSupport()) storageEngine = localStorage;
|
|
let windowPersistentEvents = {
|
|
addEventListener(key, listener, restore) {
|
|
window.addEventListener("storage", listener);
|
|
window.addEventListener("pageshow", restore);
|
|
},
|
|
removeEventListener(key, listener, restore) {
|
|
window.removeEventListener("storage", listener);
|
|
window.removeEventListener("pageshow", restore);
|
|
}
|
|
};
|
|
if (typeof window !== "undefined") eventsEngine = windowPersistentEvents;
|
|
function setPersistentEngine(storage, events) {
|
|
storageEngine = storage;
|
|
eventsEngine = events;
|
|
}
|
|
function persistentAtom(name, initial = void 0, opts = {}) {
|
|
let encode = opts.encode || identity;
|
|
let decode = opts.decode || identity;
|
|
let store = atom(initial);
|
|
let set = store.set;
|
|
store.set = (newValue) => {
|
|
let converted = encode(newValue);
|
|
if (typeof converted === "undefined") delete storageEngine[name];
|
|
else storageEngine[name] = converted;
|
|
set(newValue);
|
|
};
|
|
function listener(e) {
|
|
if (e.key === name) if (e.newValue === null) set(initial);
|
|
else set(decode(e.newValue));
|
|
else if (!storageEngine[name]) set(initial);
|
|
}
|
|
function restore() {
|
|
store.set(storageEngine[name] ? decode(storageEngine[name]) : initial);
|
|
}
|
|
onMount(store, () => {
|
|
restore();
|
|
if (opts.listen !== false) {
|
|
eventsEngine.addEventListener(name, listener, restore);
|
|
return () => {
|
|
eventsEngine.removeEventListener(name, listener, restore);
|
|
};
|
|
}
|
|
});
|
|
return store;
|
|
}
|
|
function persistentMap(prefix, initial = {}, opts = {}) {
|
|
let encode = opts.encode || identity;
|
|
let decode = opts.decode || identity;
|
|
let store = map();
|
|
let setKey = store.setKey;
|
|
let storeKey = (key, newValue) => {
|
|
if (typeof newValue === "undefined") {
|
|
if (opts.listen !== false && eventsEngine.perKey) eventsEngine.removeEventListener(prefix + key, listener, restore);
|
|
delete storageEngine[prefix + key];
|
|
} else {
|
|
if (opts.listen !== false && eventsEngine.perKey && !(key in store.value)) eventsEngine.addEventListener(prefix + key, listener, restore);
|
|
storageEngine[prefix + key] = encode(newValue);
|
|
}
|
|
};
|
|
store.setKey = (key, newValue) => {
|
|
storeKey(key, newValue);
|
|
setKey(key, newValue);
|
|
};
|
|
let set = store.set;
|
|
store.set = function(newObject) {
|
|
for (let key in newObject) storeKey(key, newObject[key]);
|
|
for (let key in store.value) if (!(key in newObject)) storeKey(key, void 0);
|
|
set(newObject);
|
|
};
|
|
function listener(e) {
|
|
if (!e.key) set({});
|
|
else if (e.key.startsWith(prefix)) if (e.newValue === null) setKey(e.key.slice(prefix.length), void 0);
|
|
else setKey(e.key.slice(prefix.length), decode(e.newValue));
|
|
}
|
|
function restore() {
|
|
let data = { ...initial };
|
|
for (let key in storageEngine) if (key.startsWith(prefix)) data[key.slice(prefix.length)] = decode(storageEngine[key]);
|
|
for (let key in data) store.setKey(key, data[key]);
|
|
}
|
|
onMount(store, () => {
|
|
restore();
|
|
if (opts.listen !== false) {
|
|
eventsEngine.addEventListener(prefix, listener, restore);
|
|
return () => {
|
|
eventsEngine.removeEventListener(prefix, listener, restore);
|
|
for (let key in store.value) eventsEngine.removeEventListener(prefix + key, listener, restore);
|
|
};
|
|
}
|
|
});
|
|
return store;
|
|
}
|
|
var testStorage = {};
|
|
var testListeners = [];
|
|
function useTestStorageEngine() {
|
|
setPersistentEngine(testStorage, {
|
|
addEventListener(key, cb) {
|
|
testListeners.push(cb);
|
|
},
|
|
removeEventListener(key, cb) {
|
|
testListeners = testListeners.filter((i) => i !== cb);
|
|
}
|
|
});
|
|
}
|
|
function setTestStorageKey(key, newValue) {
|
|
if (typeof newValue === "undefined") delete testStorage[key];
|
|
else testStorage[key] = newValue;
|
|
let event = {
|
|
key,
|
|
newValue
|
|
};
|
|
for (let listener of testListeners) listener(event);
|
|
}
|
|
function getTestStorage() {
|
|
return testStorage;
|
|
}
|
|
function cleanTestStorage() {
|
|
for (let i in testStorage) setTestStorageKey(i, void 0);
|
|
}
|
|
|
|
//#endregion
|
|
export { cleanTestStorage, getTestStorage, persistentAtom, persistentMap, setPersistentEngine, setTestStorageKey, useTestStorageEngine, windowPersistentEvents };
|
|
//# sourceMappingURL=@nanostores_persistent.js.map
|