@domeadev/react-store-context
Version:
A simple and lightweight store context for React.
1,182 lines (1,158 loc) • 43.8 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js
var require_use_sync_external_store_shim_production = __commonJS({
"node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js"(exports) {
"use strict";
var React = __require("react");
function is(x, y) {
return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
}
var objectIs = "function" === typeof Object.is ? Object.is : is;
var useState2 = React.useState;
var useEffect = React.useEffect;
var useLayoutEffect = React.useLayoutEffect;
var useDebugValue3 = React.useDebugValue;
function useSyncExternalStore$2(subscribe, getSnapshot) {
var value = getSnapshot(), _useState = useState2({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
useLayoutEffect(
function() {
inst.value = value;
inst.getSnapshot = getSnapshot;
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
},
[subscribe, value, getSnapshot]
);
useEffect(
function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
return subscribe(function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
});
},
[subscribe]
);
useDebugValue3(value);
return value;
}
function checkIfSnapshotChanged(inst) {
var latestGetSnapshot = inst.getSnapshot;
inst = inst.value;
try {
var nextValue = latestGetSnapshot();
return !objectIs(inst, nextValue);
} catch (error) {
return true;
}
}
function useSyncExternalStore$1(subscribe, getSnapshot) {
return getSnapshot();
}
var shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
}
});
// node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
var require_use_sync_external_store_shim_development = __commonJS({
"node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
"use strict";
"production" !== process.env.NODE_ENV && function() {
function is(x, y) {
return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
}
function useSyncExternalStore$2(subscribe, getSnapshot) {
didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = true, console.error(
"You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
));
var value = getSnapshot();
if (!didWarnUncachedGetSnapshot) {
var cachedValue = getSnapshot();
objectIs(value, cachedValue) || (console.error(
"The result of getSnapshot should be cached to avoid an infinite loop"
), didWarnUncachedGetSnapshot = true);
}
cachedValue = useState2({
inst: { value, getSnapshot }
});
var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
useLayoutEffect(
function() {
inst.value = value;
inst.getSnapshot = getSnapshot;
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
},
[subscribe, value, getSnapshot]
);
useEffect(
function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
return subscribe(function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
});
},
[subscribe]
);
useDebugValue3(value);
return value;
}
function checkIfSnapshotChanged(inst) {
var latestGetSnapshot = inst.getSnapshot;
inst = inst.value;
try {
var nextValue = latestGetSnapshot();
return !objectIs(inst, nextValue);
} catch (error) {
return true;
}
}
function useSyncExternalStore$1(subscribe, getSnapshot) {
return getSnapshot();
}
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
var React = __require("react"), objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue3 = React.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
}();
}
});
// node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/shim/index.js
var require_shim = __commonJS({
"node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/shim/index.js"(exports, module) {
"use strict";
if (process.env.NODE_ENV === "production") {
module.exports = require_use_sync_external_store_shim_production();
} else {
module.exports = require_use_sync_external_store_shim_development();
}
}
});
// node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js
var require_with_selector_production = __commonJS({
"node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js"(exports) {
"use strict";
var React = __require("react");
var shim = require_shim();
function is(x, y) {
return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
}
var objectIs = "function" === typeof Object.is ? Object.is : is;
var useSyncExternalStore = shim.useSyncExternalStore;
var useRef = React.useRef;
var useEffect = React.useEffect;
var useMemo2 = React.useMemo;
var useDebugValue3 = React.useDebugValue;
exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
var instRef = useRef(null);
if (null === instRef.current) {
var inst = { hasValue: false, value: null };
instRef.current = inst;
} else inst = instRef.current;
instRef = useMemo2(
function() {
function memoizedSelector(nextSnapshot) {
if (!hasMemo) {
hasMemo = true;
memoizedSnapshot = nextSnapshot;
nextSnapshot = selector(nextSnapshot);
if (void 0 !== isEqual && inst.hasValue) {
var currentSelection = inst.value;
if (isEqual(currentSelection, nextSnapshot))
return memoizedSelection = currentSelection;
}
return memoizedSelection = nextSnapshot;
}
currentSelection = memoizedSelection;
if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
var nextSelection = selector(nextSnapshot);
if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
return memoizedSnapshot = nextSnapshot, currentSelection;
memoizedSnapshot = nextSnapshot;
return memoizedSelection = nextSelection;
}
var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
return [
function() {
return memoizedSelector(getSnapshot());
},
null === maybeGetServerSnapshot ? void 0 : function() {
return memoizedSelector(maybeGetServerSnapshot());
}
];
},
[getSnapshot, getServerSnapshot, selector, isEqual]
);
var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
useEffect(
function() {
inst.hasValue = true;
inst.value = value;
},
[value]
);
useDebugValue3(value);
return value;
};
}
});
// node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
var require_with_selector_development = __commonJS({
"node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) {
"use strict";
"production" !== process.env.NODE_ENV && function() {
function is(x, y) {
return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
}
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
var React = __require("react"), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo2 = React.useMemo, useDebugValue3 = React.useDebugValue;
exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
var instRef = useRef(null);
if (null === instRef.current) {
var inst = { hasValue: false, value: null };
instRef.current = inst;
} else inst = instRef.current;
instRef = useMemo2(
function() {
function memoizedSelector(nextSnapshot) {
if (!hasMemo) {
hasMemo = true;
memoizedSnapshot = nextSnapshot;
nextSnapshot = selector(nextSnapshot);
if (void 0 !== isEqual && inst.hasValue) {
var currentSelection = inst.value;
if (isEqual(currentSelection, nextSnapshot))
return memoizedSelection = currentSelection;
}
return memoizedSelection = nextSnapshot;
}
currentSelection = memoizedSelection;
if (objectIs(memoizedSnapshot, nextSnapshot))
return currentSelection;
var nextSelection = selector(nextSnapshot);
if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
return memoizedSnapshot = nextSnapshot, currentSelection;
memoizedSnapshot = nextSnapshot;
return memoizedSelection = nextSelection;
}
var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
return [
function() {
return memoizedSelector(getSnapshot());
},
null === maybeGetServerSnapshot ? void 0 : function() {
return memoizedSelector(maybeGetServerSnapshot());
}
];
},
[getSnapshot, getServerSnapshot, selector, isEqual]
);
var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
useEffect(
function() {
inst.hasValue = true;
inst.value = value;
},
[value]
);
useDebugValue3(value);
return value;
};
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
}();
}
});
// node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/shim/with-selector.js
var require_with_selector = __commonJS({
"node_modules/.pnpm/use-sync-external-store@1.5.0_react@19.1.0/node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) {
"use strict";
if (process.env.NODE_ENV === "production") {
module.exports = require_with_selector_production();
} else {
module.exports = require_with_selector_development();
}
}
});
// node_modules/.pnpm/zustand@4.5.7_@types+react@19.1.7_react@19.1.0/node_modules/zustand/esm/vanilla.mjs
var import_meta = {};
var createStoreImpl = (createState) => {
let state;
const listeners = /* @__PURE__ */ new Set();
const setState = (partial, replace) => {
const nextState = typeof partial === "function" ? partial(state) : partial;
if (!Object.is(nextState, state)) {
const previousState = state;
state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
listeners.forEach((listener) => listener(state, previousState));
}
};
const getState = () => state;
const getInitialState = () => initialState;
const subscribe = (listener) => {
listeners.add(listener);
return () => listeners.delete(listener);
};
const destroy = () => {
if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production") {
console.warn(
"[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
);
}
listeners.clear();
};
const api = { setState, getState, getInitialState, subscribe, destroy };
const initialState = state = createState(setState, getState, api);
return api;
};
var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
// node_modules/.pnpm/zustand@4.5.7_@types+react@19.1.7_react@19.1.0/node_modules/zustand/esm/index.mjs
var import_with_selector = __toESM(require_with_selector(), 1);
import ReactExports from "react";
var import_meta2 = {};
var { useDebugValue } = ReactExports;
var { useSyncExternalStoreWithSelector } = import_with_selector.default;
var didWarnAboutEqualityFn = false;
var identity = (arg) => arg;
function useStore(api, selector = identity, equalityFn) {
if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && equalityFn && !didWarnAboutEqualityFn) {
console.warn(
"[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"
);
didWarnAboutEqualityFn = true;
}
const slice = useSyncExternalStoreWithSelector(
api.subscribe,
api.getState,
api.getServerState || api.getInitialState,
selector,
equalityFn
);
useDebugValue(slice);
return slice;
}
var createImpl = (createState) => {
if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production" && typeof createState !== "function") {
console.warn(
"[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`."
);
}
const api = typeof createState === "function" ? createStore(createState) : createState;
const useBoundStore = (selector, equalityFn) => useStore(api, selector, equalityFn);
Object.assign(useBoundStore, api);
return useBoundStore;
};
var create = (createState) => createState ? createImpl(createState) : createImpl;
// node_modules/.pnpm/zustand@4.5.7_@types+react@19.1.7_react@19.1.0/node_modules/zustand/esm/shallow.mjs
function shallow$1(objA, objB) {
if (Object.is(objA, objB)) {
return true;
}
if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
return false;
}
if (objA instanceof Map && objB instanceof Map) {
if (objA.size !== objB.size) return false;
for (const [key, value] of objA) {
if (!Object.is(value, objB.get(key))) {
return false;
}
}
return true;
}
if (objA instanceof Set && objB instanceof Set) {
if (objA.size !== objB.size) return false;
for (const value of objA) {
if (!objB.has(value)) {
return false;
}
}
return true;
}
const keysA = Object.keys(objA);
if (keysA.length !== Object.keys(objB).length) {
return false;
}
for (const keyA of keysA) {
if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) {
return false;
}
}
return true;
}
// node_modules/.pnpm/zustand@4.5.7_@types+react@19.1.7_react@19.1.0/node_modules/zustand/esm/middleware.mjs
var combine = (initialState, create2) => (...a) => Object.assign({}, initialState, create2(...a));
// node_modules/.pnpm/zustand@4.5.7_@types+react@19.1.7_react@19.1.0/node_modules/zustand/esm/traditional.mjs
var import_with_selector2 = __toESM(require_with_selector(), 1);
import ReactExports2 from "react";
var { useDebugValue: useDebugValue2 } = ReactExports2;
var { useSyncExternalStoreWithSelector: useSyncExternalStoreWithSelector2 } = import_with_selector2.default;
var identity2 = (arg) => arg;
function useStoreWithEqualityFn(api, selector = identity2, equalityFn) {
const slice = useSyncExternalStoreWithSelector2(
api.subscribe,
api.getState,
api.getServerState || api.getInitialState,
selector,
equalityFn
);
useDebugValue2(slice);
return slice;
}
var createWithEqualityFnImpl = (createState, defaultEqualityFn) => {
const api = createStore(createState);
const useBoundStoreWithEqualityFn = (selector, equalityFn = defaultEqualityFn) => useStoreWithEqualityFn(api, selector, equalityFn);
Object.assign(useBoundStoreWithEqualityFn, api);
return useBoundStoreWithEqualityFn;
};
var createWithEqualityFn = (createState, defaultEqualityFn) => createState ? createWithEqualityFnImpl(createState, defaultEqualityFn) : createWithEqualityFnImpl;
// src/createDefaultStore.tsx
function createDefaultStore(initialState, actionsCreator) {
return createStore(combine(initialState, actionsCreator));
}
// node_modules/.pnpm/entity-state-adapter@0.1.4_patch_hash=euvyco4dpvneijt7vd3bnb6h2q/node_modules/entity-state-adapter/dist/index.es.js
var __assign = function() {
__assign = Object.assign || function __assign2(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function getInitialEntityState() {
return {
ids: [],
entities: {}
};
}
function createInitialStateFactory() {
function getInitialState(additionalState) {
if (additionalState === void 0) {
additionalState = {};
}
return Object.assign(getInitialEntityState(), additionalState);
}
return { getInitialState };
}
function isEqualCheck(a, b) {
return a === b;
}
function isArgumentsChanged(args, lastArguments, comparator) {
for (var i = 0; i < args.length; i++) {
if (!comparator(args[i], lastArguments[i])) {
return true;
}
}
return false;
}
function defaultMemoize(projectionFn, isArgumentsEqual, isResultEqual) {
if (isArgumentsEqual === void 0) {
isArgumentsEqual = isEqualCheck;
}
if (isResultEqual === void 0) {
isResultEqual = isEqualCheck;
}
var lastArguments = null;
var lastResult = null;
var overrideResult;
function reset() {
lastArguments = null;
lastResult = null;
}
function setResult(result) {
if (result === void 0) {
result = void 0;
}
overrideResult = result;
}
function memoized() {
if (overrideResult !== void 0) {
return overrideResult;
}
if (!lastArguments) {
lastResult = projectionFn.apply(null, arguments);
lastArguments = arguments;
return lastResult;
}
if (!isArgumentsChanged(arguments, lastArguments, isArgumentsEqual)) {
return lastResult;
}
lastArguments = arguments;
var newResult = projectionFn.apply(null, arguments);
if (isResultEqual(lastResult, newResult)) {
return lastResult;
}
lastResult = newResult;
return newResult;
}
return { memoized, reset, setResult };
}
function createSelector() {
var input = [];
for (var _i = 0; _i < arguments.length; _i++) {
input[_i] = arguments[_i];
}
return createSelectorFactory(defaultMemoize).apply(void 0, input);
}
function defaultStateFn(state, selectors, props, memoizedProjector) {
if (props === void 0) {
var args_1 = selectors.map(function(fn) {
return fn(state);
});
return memoizedProjector.memoized.apply(null, args_1);
}
var args = selectors.map(function(fn) {
return fn(state, props);
});
return memoizedProjector.memoized.apply(null, args.concat([props]));
}
function createSelectorFactory(memoize, options) {
if (options === void 0) {
options = {
stateFn: defaultStateFn
};
}
return function() {
var input = [];
for (var _i = 0; _i < arguments.length; _i++) {
input[_i] = arguments[_i];
}
var args = input;
if (Array.isArray(args[0])) {
var head = args[0], tail = args.slice(1);
args = head.concat(tail);
}
var selectors = args.slice(0, args.length - 1);
var projector = args[args.length - 1];
var memoizedSelectors = selectors.filter(function(selector) {
return selector.release && typeof selector.release === "function";
});
var memoizedProjector = memoize(function() {
var selectors2 = [];
for (var _i2 = 0; _i2 < arguments.length; _i2++) {
selectors2[_i2] = arguments[_i2];
}
return projector.apply(null, selectors2);
});
var memoizedState = defaultMemoize(function(state, props) {
return options.stateFn.apply(null, [
state,
selectors,
props,
memoizedProjector
]);
});
function release() {
memoizedState.reset();
memoizedProjector.reset();
memoizedSelectors.forEach(function(selector) {
return selector.release();
});
}
return Object.assign(memoizedState.memoized, {
release,
projector: memoizedProjector.memoized,
setResult: memoizedState.setResult
});
};
}
function createSelectorsFactory() {
function getSelectors(selectState) {
var selectIds = function(state) {
return state.ids;
};
var selectEntities = function(state) {
return state.entities;
};
var selectAll = createSelector(selectIds, selectEntities, function(ids, entities) {
return ids.map(function(id) {
return entities[id];
});
});
var selectTotal = createSelector(selectIds, function(ids) {
return ids.length;
});
if (!selectState) {
return {
selectIds,
selectEntities,
selectAll,
selectTotal
};
}
return {
selectIds: createSelector(selectState, selectIds),
selectEntities: createSelector(selectState, selectEntities),
selectAll: createSelector(selectState, selectAll),
selectTotal: createSelector(selectState, selectTotal)
};
}
return { getSelectors };
}
var DidMutate;
(function(DidMutate2) {
DidMutate2[DidMutate2["EntitiesOnly"] = 0] = "EntitiesOnly";
DidMutate2[DidMutate2["Both"] = 1] = "Both";
DidMutate2[DidMutate2["None"] = 2] = "None";
})(DidMutate || (DidMutate = {}));
function createStateOperator(mutator) {
return function operation(arg, state) {
var clonedEntityState = {
ids: state.ids.slice(),
entities: __assign({}, state.entities)
};
var didMutate = mutator(arg, clonedEntityState);
if (didMutate === DidMutate.Both) {
return Object.assign({}, state, clonedEntityState);
}
if (didMutate === DidMutate.EntitiesOnly) {
return __assign({}, state, { entities: clonedEntityState.entities });
}
return state;
};
}
function selectIdValue(entity, selectId) {
var key = selectId(entity);
if (key === void 0) {
console.warn("Entity-state-adapter: The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString());
}
return key;
}
function createUnsortedStateAdapter(selectId) {
function addOneMutably(entity, state) {
var key = selectIdValue(entity, selectId);
if (key in state.entities) {
return DidMutate.None;
}
state.ids.push(key);
state.entities[key] = entity;
return DidMutate.Both;
}
function addManyMutably(entities, state) {
var didMutate = false;
for (var _i = 0, entities_1 = entities; _i < entities_1.length; _i++) {
var entity = entities_1[_i];
didMutate = addOneMutably(entity, state) !== DidMutate.None || didMutate;
}
return didMutate ? DidMutate.Both : DidMutate.None;
}
function addAllMutably(entities, state) {
state.ids = [];
state.entities = {};
addManyMutably(entities, state);
return DidMutate.Both;
}
function removeOneMutably(key, state) {
return removeManyMutably([key], state);
}
function removeManyMutably(keysOrPredicate, state) {
var keys = keysOrPredicate instanceof Array ? keysOrPredicate : state.ids.filter(function(key) {
return keysOrPredicate(state.entities[key]);
});
var didMutate = keys.filter(function(key) {
return key in state.entities;
}).map(function(key) {
return delete state.entities[key];
}).length > 0;
if (didMutate) {
state.ids = state.ids.filter(function(id) {
return id in state.entities;
});
}
return didMutate ? DidMutate.Both : DidMutate.None;
}
function removeAll(state) {
return Object.assign({}, state, {
ids: [],
entities: {}
});
}
function takeNewKey(keys, update, state) {
var original = state.entities[update.id];
var updated = Object.assign({}, original, update.changes);
var newKey = selectIdValue(updated, selectId);
var hasNewKey = newKey !== update.id;
if (hasNewKey) {
keys[update.id] = newKey;
delete state.entities[update.id];
}
state.entities[newKey] = updated;
return hasNewKey;
}
function updateOneMutably(update, state) {
return updateManyMutably([update], state);
}
function updateManyMutably(updates, state) {
var newKeys = {};
updates = updates.filter(function(update) {
return update.id in state.entities;
});
var didMutateEntities = updates.length > 0;
if (didMutateEntities) {
var didMutateIds = updates.filter(function(update) {
return takeNewKey(newKeys, update, state);
}).length > 0;
if (didMutateIds) {
state.ids = state.ids.map(function(id) {
return newKeys[id] || id;
});
return DidMutate.Both;
} else {
return DidMutate.EntitiesOnly;
}
}
return DidMutate.None;
}
function mapMutably(map, state) {
var changes = state.ids.reduce(function(changes2, id) {
var change = map(state.entities[id]);
if (change !== state.entities[id]) {
changes2.push({ id, changes: change });
}
return changes2;
}, []);
var updates = changes.filter(function(_a) {
var id = _a.id;
return id in state.entities;
});
return updateManyMutably(updates, state);
}
function upsertOneMutably(entity, state) {
return upsertManyMutably([entity], state);
}
function upsertManyMutably(entities, state) {
var added = [];
var updated = [];
for (var _i = 0, entities_2 = entities; _i < entities_2.length; _i++) {
var entity = entities_2[_i];
var id = selectIdValue(entity, selectId);
if (id in state.entities) {
updated.push({ id, changes: entity });
} else {
added.push(entity);
}
}
var didMutateByUpdated = updateManyMutably(updated, state);
var didMutateByAdded = addManyMutably(added, state);
switch (true) {
case (didMutateByAdded === DidMutate.None && didMutateByUpdated === DidMutate.None):
return DidMutate.None;
case (didMutateByAdded === DidMutate.Both || didMutateByUpdated === DidMutate.Both):
return DidMutate.Both;
default:
return DidMutate.EntitiesOnly;
}
}
return {
removeAll,
addOne: createStateOperator(addOneMutably),
addMany: createStateOperator(addManyMutably),
addAll: createStateOperator(addAllMutably),
updateOne: createStateOperator(updateOneMutably),
updateMany: createStateOperator(updateManyMutably),
upsertOne: createStateOperator(upsertOneMutably),
upsertMany: createStateOperator(upsertManyMutably),
removeOne: createStateOperator(removeOneMutably),
removeMany: createStateOperator(removeManyMutably),
map: createStateOperator(mapMutably)
};
}
function createSortedStateAdapter(selectId, sort) {
var _a = createUnsortedStateAdapter(selectId), removeOne = _a.removeOne, removeMany = _a.removeMany, removeAll = _a.removeAll;
function addOneMutably(entity, state) {
return addManyMutably([entity], state);
}
function addManyMutably(newModels, state) {
var models = newModels.filter(function(model) {
return !(selectIdValue(model, selectId) in state.entities);
});
if (models.length === 0) {
return DidMutate.None;
} else {
merge(models, state);
return DidMutate.Both;
}
}
function addAllMutably(models, state) {
state.entities = {};
state.ids = [];
addManyMutably(models, state);
return DidMutate.Both;
}
function updateOneMutably(update, state) {
return updateManyMutably([update], state);
}
function takeUpdatedModel(models, update, state) {
if (!(update.id in state.entities)) {
return false;
}
var original = state.entities[update.id];
var updated = Object.assign({}, original, update.changes);
var newKey = selectIdValue(updated, selectId);
delete state.entities[update.id];
models.push(updated);
return newKey !== update.id;
}
function updateManyMutably(updates, state) {
var models = [];
var didMutateIds = updates.filter(function(update) {
return takeUpdatedModel(models, update, state);
}).length > 0;
if (models.length === 0) {
return DidMutate.None;
} else {
var originalIds_1 = state.ids;
var updatedIndexes_1 = [];
state.ids = state.ids.filter(function(id, index) {
if (id in state.entities) {
return true;
} else {
updatedIndexes_1.push(index);
return false;
}
});
merge(models, state);
if (!didMutateIds && updatedIndexes_1.every(function(i) {
return state.ids[i] === originalIds_1[i];
})) {
return DidMutate.EntitiesOnly;
} else {
return DidMutate.Both;
}
}
}
function mapMutably(updatesOrMap, state) {
var updates = state.ids.reduce(function(changes, id) {
var change = updatesOrMap(state.entities[id]);
if (change !== state.entities[id]) {
changes.push({ id, changes: change });
}
return changes;
}, []);
return updateManyMutably(updates, state);
}
function upsertOneMutably(entity, state) {
return upsertManyMutably([entity], state);
}
function upsertManyMutably(entities, state) {
var added = [];
var updated = [];
for (var _i = 0, entities_1 = entities; _i < entities_1.length; _i++) {
var entity = entities_1[_i];
var id = selectIdValue(entity, selectId);
if (id in state.entities) {
updated.push({ id, changes: entity });
} else {
added.push(entity);
}
}
var didMutateByUpdated = updateManyMutably(updated, state);
var didMutateByAdded = addManyMutably(added, state);
switch (true) {
case (didMutateByAdded === DidMutate.None && didMutateByUpdated === DidMutate.None):
return DidMutate.None;
case (didMutateByAdded === DidMutate.Both || didMutateByUpdated === DidMutate.Both):
return DidMutate.Both;
default:
return DidMutate.EntitiesOnly;
}
}
function merge(models, state) {
models.sort(sort);
var ids = [];
var i = 0;
var j = 0;
while (i < models.length && j < state.ids.length) {
var model = models[i];
var modelId = selectIdValue(model, selectId);
var entityId = state.ids[j];
var entity = state.entities[entityId];
if (sort(model, entity) <= 0) {
ids.push(modelId);
i++;
} else {
ids.push(entityId);
j++;
}
}
if (i < models.length) {
state.ids = ids.concat(models.slice(i).map(selectId));
} else {
state.ids = ids.concat(state.ids.slice(j));
}
models.forEach(function(model2, i2) {
state.entities[selectId(model2)] = model2;
});
}
return {
removeOne,
removeMany,
removeAll,
addOne: createStateOperator(addOneMutably),
updateOne: createStateOperator(updateOneMutably),
upsertOne: createStateOperator(upsertOneMutably),
addAll: createStateOperator(addAllMutably),
addMany: createStateOperator(addManyMutably),
updateMany: createStateOperator(updateManyMutably),
upsertMany: createStateOperator(upsertManyMutably),
map: createStateOperator(mapMutably)
};
}
function createEntityAdapter(options) {
if (options === void 0) {
options = {};
}
var _a = __assign({ sortComparer: false, selectId: function(instance) {
return instance.id;
} }, options), selectId = _a.selectId, sortComparer = _a.sortComparer;
var stateFactory = createInitialStateFactory();
var selectorsFactory = createSelectorsFactory();
var stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);
return __assign({
selectId,
sortComparer
}, stateFactory, selectorsFactory, stateAdapter);
}
// src/createEntityStateStore.tsx
function createEntityStateStore(options) {
var _a;
const adapter = createEntityAdapter(options);
let initialState = adapter.getInitialState();
if ((_a = options == null ? void 0 : options.entities) == null ? void 0 : _a.length) {
initialState = adapter.addAll(options.entities, initialState);
}
return createDefaultStore(initialState, (set, get) => {
function removeOne(key) {
set(adapter.removeOne(key, get()));
}
function removeMany(keysOrPredicate) {
set(adapter.removeMany(keysOrPredicate, get()));
}
const { selectAll, selectEntities, selectIds, selectTotal } = adapter.getSelectors();
return {
addOne: (entity) => {
set(adapter.addOne(entity, get()));
},
addMany: (entities) => {
set(adapter.addMany(entities, get()));
},
addAll: (entities) => {
set(adapter.addAll(entities, get()));
},
removeOne,
removeMany,
removeAll: () => {
set(adapter.removeAll(get()));
},
updateOne: (update) => {
set(adapter.updateOne(update, get()));
},
updateMany: (updates) => {
set(adapter.updateMany(updates, get()));
},
upsertOne: (entity) => {
set(adapter.upsertOne(entity, get()));
},
upsertMany: (entities) => {
set(adapter.upsertMany(entities, get()));
},
map: (mapFn) => {
set(adapter.map(mapFn, get()));
},
// selectors
selectIds: () => selectIds(get()),
selectEntities: () => selectEntities(get()),
selectAll: () => selectAll(get()),
selectTotal: () => selectTotal(get()),
selectOne: (id) => selectEntities(get())[id]
};
});
}
// src/createStoreContext.tsx
import {
createContext,
useContext,
useMemo,
useState
} from "react";
import { Fragment, jsx } from "react/jsx-runtime";
function createStoreContext(storeCreator) {
const StoreContext = createContext(null);
function StoreProvider(props) {
return /* @__PURE__ */ jsx(
StoreContext.Provider,
{
value: useMemo(() => {
var _a;
return (_a = props.store) != null ? _a : storeCreator(props);
}, [props.store]),
children: props.children
}
);
}
function useCreateStore(props) {
const [store] = useState(
() => storeCreator(typeof props === "function" ? props() : props)
);
return store;
}
function useStoreContext() {
return useContext(StoreContext);
}
function useStore2(selector, store) {
const storeContext = useStoreContext();
const storeToUse = store || storeContext;
if (!storeToUse) {
throw new Error(
"You must provide a store or use `useStore` within a StoreProvider"
);
}
return useStore(storeToUse, selector);
}
function createStoreSelector(selector) {
return selector;
}
function Subscribe({
selector,
children,
store
}) {
const value = useStore2(selector, store);
return /* @__PURE__ */ jsx(Fragment, { children: children(value) });
}
return {
StoreContext,
StoreProvider,
useCreateStore,
useStore: useStore2,
createStoreSelector,
Subscribe
};
}
// src/extend.ts
function extend(store, extension) {
var _a;
store.setState(__spreadValues(__spreadValues({}, extension.state), (_a = extension.actions) == null ? void 0 : _a.call(extension, store.setState, store.getState, store)));
return __spreadProps(__spreadValues({}, store), {
getInitialState: () => __spreadValues(__spreadValues({}, store.getInitialState()), extension.state)
});
}
// src/select.ts
function select(store, selector) {
return selector(store.getState());
}
export {
combine,
create,
createDefaultStore,
createEntityStateStore,
createStore,
createStoreContext,
createWithEqualityFn,
extend,
select,
shallow$1 as shallow,
useStore,
useStoreWithEqualityFn
};
/*! Bundled license information:
use-sync-external-store/cjs/use-sync-external-store-shim.production.js:
(**
* @license React
* use-sync-external-store-shim.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
(**
* @license React
* use-sync-external-store-shim.development.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js:
(**
* @license React
* use-sync-external-store-shim/with-selector.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js:
(**
* @license React
* use-sync-external-store-shim/with-selector.development.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
entity-state-adapter/dist/index.es.js:
(*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** *)
*/
//# sourceMappingURL=index.mjs.map