react-pinia
Version:
šBuilding a Minimal State Management for React
316 lines (315 loc) ā¢ 9 kB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
import require$$0, { useRef, useState, useCallback, useEffect, createContext, useContext } from "react";
const typeOf = (value) => {
const map = /* @__PURE__ */ new Map([
["[object Function]", "function"],
["[object Undefined]", "undefined"],
["[object Boolean]", "boolean"],
["[object Number]", "number"],
["[object String]", "string"],
["[object Array]", "array"],
["[object Date]", "date"],
["[object RegExp]", "regExp"],
["[object Null]", "null"],
["[object Object]", "object"],
["[object Symbol]", "symbol"],
["[object Promise]", "promise"]
]);
return map.get(Object.prototype.toString.call(value));
};
const depsAreSame = (oldDeps, deps) => {
if (oldDeps === deps)
return true;
for (let i = 0; i < oldDeps.length; i++) {
if (!Object.is(oldDeps[i], deps[i]))
return false;
}
return true;
};
const proxyMap = /* @__PURE__ */ new WeakMap();
const rawMap = /* @__PURE__ */ new WeakMap();
function observer(storeKey, initialVal, cb, deep = true) {
const existingProxy = proxyMap.get(initialVal);
if (existingProxy) {
return existingProxy;
}
if (rawMap.has(initialVal)) {
return initialVal;
}
const proxy = new Proxy(initialVal, {
get(target, key, receiver) {
if (!deep) {
return Reflect.get(target, key);
}
const res = Reflect.get(target, key, receiver);
return typeOf(res) === "object" || typeOf(res) === "array" ? observer(storeKey, res, cb, deep) : Reflect.get(target, key);
},
set(target, key, val) {
if (target[key] === val) {
return Reflect.set(target, key, val);
} else {
const ret = Reflect.set(target, key, val);
cb(key, storeKey);
return ret;
}
},
deleteProperty(target, key) {
const ret = Reflect.deleteProperty(target, key);
cb(key, storeKey);
return ret;
}
});
proxyMap.set(initialVal, proxy);
rawMap.set(proxy, initialVal);
return proxy;
}
function useUpdate() {
const [, setState] = useState({});
return useCallback(() => setState({}), []);
}
function useCreation(factory, deps) {
const { current } = useRef({
deps,
obj: void 0,
initialized: false
});
if (current.initialized === false || !depsAreSame(current.deps, deps)) {
current.deps = deps;
current.obj = factory();
current.initialized = true;
}
return current.obj;
}
class Dep {
constructor() {
__publicField(this, "listeners", /* @__PURE__ */ new Map());
}
on(type, handler) {
if (!this.listeners.has(type)) {
this.listeners.set(type, []);
}
this.listeners.get(type).push(handler);
}
emit(type, evt) {
const handlers = this.listeners.get(type);
if (handlers) {
handlers.forEach((handler) => handler(evt));
}
}
off(type, handler) {
const handlers = this.listeners.get(type);
if (handlers) {
if (handler) {
const index = handlers.indexOf(handler);
if (index !== -1) {
handlers.splice(index, 1);
}
} else {
this.listeners.set(type, []);
}
}
}
}
function getStorage(persist) {
let storage = localStorage;
if ("storage" in persist && persist.storage === "sessionStorage") {
storage = sessionStorage;
}
try {
const state = storage.getItem(persist.key);
if (state) {
return JSON.parse(state);
}
} catch (_) {
}
return null;
}
function setStorage(persist, val) {
let storage = localStorage;
if ("storage" in persist && persist.storage === "sessionStorage") {
storage = sessionStorage;
}
storage.setItem(persist.key, JSON.stringify(val));
}
function defineStore(options) {
const uid = Symbol();
const bus = new Dep();
const persist = options.persist;
const initState = Object.assign({}, options.state(), persist && getStorage(persist));
const callback = (key) => {
bus.emit(uid, key);
};
const proxyState = observer(null, initState, callback, true);
const _store = Object.create(proxyState);
if (options.actions) {
Object.keys(options.actions).forEach((key) => {
_store[key] = options.actions[key].bind(proxyState);
});
}
function updateGetters(store) {
if (options.getters) {
Object.keys(options.getters).map((key) => {
_store[key] = options.getters && options.getters[key](store);
});
}
}
updateGetters(initState);
function useHooks() {
const update = useUpdate();
useEffect(() => {
bus.on(uid, () => {
persist && setStorage(persist, proxyState);
updateGetters(_store);
update();
});
return () => {
bus.off(uid);
};
}, []);
return _store;
}
useHooks.get = function() {
return proxyState;
};
return useHooks;
}
var jsxRuntime = { exports: {} };
var reactJsxRuntime_production_min = {};
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === void 0) {
throw new TypeError("Object.assign cannot be called with null or undefined");
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
var test1 = new String("abc");
test1[5] = "de";
if (Object.getOwnPropertyNames(test1)[0] === "5") {
return false;
}
var test2 = {};
for (var i = 0; i < 10; i++) {
test2["_" + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function(n2) {
return test2[n2];
});
if (order2.join("") !== "0123456789") {
return false;
}
var test3 = {};
"abcdefghijklmnopqrst".split("").forEach(function(letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
return false;
}
return true;
} catch (err) {
return false;
}
}
shouldUseNative() ? Object.assign : function(target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
/** @license React v17.0.2
* react-jsx-runtime.production.min.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var f = require$$0, g = 60103;
reactJsxRuntime_production_min.Fragment = 60107;
if ("function" === typeof Symbol && Symbol.for) {
var h = Symbol.for;
g = h("react.element");
reactJsxRuntime_production_min.Fragment = h("react.fragment");
}
var m = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, n = Object.prototype.hasOwnProperty, p = { key: true, ref: true, __self: true, __source: true };
function q(c, a, k) {
var b, d = {}, e = null, l = null;
void 0 !== k && (e = "" + k);
void 0 !== a.key && (e = "" + a.key);
void 0 !== a.ref && (l = a.ref);
for (b in a)
n.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
if (c && c.defaultProps)
for (b in a = c.defaultProps, a)
void 0 === d[b] && (d[b] = a[b]);
return { $$typeof: g, type: c, key: e, ref: l, props: d, _owner: m.current };
}
reactJsxRuntime_production_min.jsx = q;
reactJsxRuntime_production_min.jsxs = q;
{
jsxRuntime.exports = reactJsxRuntime_production_min;
}
const jsx = jsxRuntime.exports.jsx;
const Context = createContext({});
const Provider = ({
store,
children
}) => {
const stateRef = useRef(store);
const state = useCreation(() => {
return stateRef.current;
}, []);
return /* @__PURE__ */ jsx(Context.Provider, {
value: state,
children
});
};
const createStore = (options) => {
const store = /* @__PURE__ */ Object.create(null);
Object.keys(options).forEach((key) => {
if (!(key in store)) {
store[key] = defineStore(options[key]);
}
});
return store;
};
const useStore = (globalKey) => {
const store = useContext(Context);
if (globalKey in store)
return store[globalKey]();
return null;
};
const version = "2.7.3";
export { Provider, createStore, defineStore, useStore, version };