mirror of
https://github.com/Funkoala14/knowledgebase_law.git
synced 2025-06-08 22:08:16 +08:00
1103 lines
38 KiB
JavaScript
1103 lines
38 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __defProps = Object.defineProperties;
|
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
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 __objRest = (source, exclude) => {
|
|
var target = {};
|
|
for (var prop in source)
|
|
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
|
|
target[prop] = source[prop];
|
|
if (source != null && __getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(source)) {
|
|
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
|
|
target[prop] = source[prop];
|
|
}
|
|
return target;
|
|
};
|
|
|
|
// src/utils/react.ts
|
|
import * as React from "react";
|
|
|
|
// src/utils/react-is.ts
|
|
var IS_REACT_19 = /* @__PURE__ */ React.version.startsWith("19");
|
|
var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for(
|
|
IS_REACT_19 ? "react.transitional.element" : "react.element"
|
|
);
|
|
var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
|
|
var REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
|
|
var REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode");
|
|
var REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler");
|
|
var REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer");
|
|
var REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context");
|
|
var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
|
|
var REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense");
|
|
var REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for(
|
|
"react.suspense_list"
|
|
);
|
|
var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
|
|
var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
|
|
var REACT_OFFSCREEN_TYPE = /* @__PURE__ */ Symbol.for("react.offscreen");
|
|
var REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for(
|
|
"react.client.reference"
|
|
);
|
|
var ForwardRef = REACT_FORWARD_REF_TYPE;
|
|
var Memo = REACT_MEMO_TYPE;
|
|
function isValidElementType(type) {
|
|
return typeof type === "string" || typeof type === "function" || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || type.getModuleId !== void 0) ? true : false;
|
|
}
|
|
function typeOf(object) {
|
|
if (typeof object === "object" && object !== null) {
|
|
const { $$typeof } = object;
|
|
switch ($$typeof) {
|
|
case REACT_ELEMENT_TYPE:
|
|
switch (object = object.type, object) {
|
|
case REACT_FRAGMENT_TYPE:
|
|
case REACT_PROFILER_TYPE:
|
|
case REACT_STRICT_MODE_TYPE:
|
|
case REACT_SUSPENSE_TYPE:
|
|
case REACT_SUSPENSE_LIST_TYPE:
|
|
return object;
|
|
default:
|
|
switch (object = object && object.$$typeof, object) {
|
|
case REACT_CONTEXT_TYPE:
|
|
case REACT_FORWARD_REF_TYPE:
|
|
case REACT_LAZY_TYPE:
|
|
case REACT_MEMO_TYPE:
|
|
return object;
|
|
case REACT_CONSUMER_TYPE:
|
|
return object;
|
|
default:
|
|
return $$typeof;
|
|
}
|
|
}
|
|
case REACT_PORTAL_TYPE:
|
|
return $$typeof;
|
|
}
|
|
}
|
|
}
|
|
function isContextConsumer(object) {
|
|
return IS_REACT_19 ? typeOf(object) === REACT_CONSUMER_TYPE : typeOf(object) === REACT_CONTEXT_TYPE;
|
|
}
|
|
function isMemo(object) {
|
|
return typeOf(object) === REACT_MEMO_TYPE;
|
|
}
|
|
|
|
// src/utils/warning.ts
|
|
function warning(message) {
|
|
if (typeof console !== "undefined" && typeof console.error === "function") {
|
|
console.error(message);
|
|
}
|
|
try {
|
|
throw new Error(message);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
|
|
// src/connect/verifySubselectors.ts
|
|
function verify(selector, methodName) {
|
|
if (!selector) {
|
|
throw new Error(`Unexpected value for ${methodName} in connect.`);
|
|
} else if (methodName === "mapStateToProps" || methodName === "mapDispatchToProps") {
|
|
if (!Object.prototype.hasOwnProperty.call(selector, "dependsOnOwnProps")) {
|
|
warning(
|
|
`The selector for ${methodName} of connect did not specify a value for dependsOnOwnProps.`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps) {
|
|
verify(mapStateToProps, "mapStateToProps");
|
|
verify(mapDispatchToProps, "mapDispatchToProps");
|
|
verify(mergeProps, "mergeProps");
|
|
}
|
|
|
|
// src/connect/selectorFactory.ts
|
|
function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, {
|
|
areStatesEqual,
|
|
areOwnPropsEqual,
|
|
areStatePropsEqual
|
|
}) {
|
|
let hasRunAtLeastOnce = false;
|
|
let state;
|
|
let ownProps;
|
|
let stateProps;
|
|
let dispatchProps;
|
|
let mergedProps;
|
|
function handleFirstCall(firstState, firstOwnProps) {
|
|
state = firstState;
|
|
ownProps = firstOwnProps;
|
|
stateProps = mapStateToProps(state, ownProps);
|
|
dispatchProps = mapDispatchToProps(dispatch, ownProps);
|
|
mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
|
|
hasRunAtLeastOnce = true;
|
|
return mergedProps;
|
|
}
|
|
function handleNewPropsAndNewState() {
|
|
stateProps = mapStateToProps(state, ownProps);
|
|
if (mapDispatchToProps.dependsOnOwnProps)
|
|
dispatchProps = mapDispatchToProps(dispatch, ownProps);
|
|
mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
|
|
return mergedProps;
|
|
}
|
|
function handleNewProps() {
|
|
if (mapStateToProps.dependsOnOwnProps)
|
|
stateProps = mapStateToProps(state, ownProps);
|
|
if (mapDispatchToProps.dependsOnOwnProps)
|
|
dispatchProps = mapDispatchToProps(dispatch, ownProps);
|
|
mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
|
|
return mergedProps;
|
|
}
|
|
function handleNewState() {
|
|
const nextStateProps = mapStateToProps(state, ownProps);
|
|
const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);
|
|
stateProps = nextStateProps;
|
|
if (statePropsChanged)
|
|
mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
|
|
return mergedProps;
|
|
}
|
|
function handleSubsequentCalls(nextState, nextOwnProps) {
|
|
const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);
|
|
const stateChanged = !areStatesEqual(
|
|
nextState,
|
|
state,
|
|
nextOwnProps,
|
|
ownProps
|
|
);
|
|
state = nextState;
|
|
ownProps = nextOwnProps;
|
|
if (propsChanged && stateChanged) return handleNewPropsAndNewState();
|
|
if (propsChanged) return handleNewProps();
|
|
if (stateChanged) return handleNewState();
|
|
return mergedProps;
|
|
}
|
|
return function pureFinalPropsSelector(nextState, nextOwnProps) {
|
|
return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps);
|
|
};
|
|
}
|
|
function finalPropsSelectorFactory(dispatch, _a) {
|
|
var _b = _a, {
|
|
initMapStateToProps,
|
|
initMapDispatchToProps,
|
|
initMergeProps
|
|
} = _b, options = __objRest(_b, [
|
|
"initMapStateToProps",
|
|
"initMapDispatchToProps",
|
|
"initMergeProps"
|
|
]);
|
|
const mapStateToProps = initMapStateToProps(dispatch, options);
|
|
const mapDispatchToProps = initMapDispatchToProps(dispatch, options);
|
|
const mergeProps = initMergeProps(dispatch, options);
|
|
if (process.env.NODE_ENV !== "production") {
|
|
verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps);
|
|
}
|
|
return pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);
|
|
}
|
|
|
|
// src/utils/bindActionCreators.ts
|
|
function bindActionCreators(actionCreators, dispatch) {
|
|
const boundActionCreators = {};
|
|
for (const key in actionCreators) {
|
|
const actionCreator = actionCreators[key];
|
|
if (typeof actionCreator === "function") {
|
|
boundActionCreators[key] = (...args) => dispatch(actionCreator(...args));
|
|
}
|
|
}
|
|
return boundActionCreators;
|
|
}
|
|
|
|
// src/utils/isPlainObject.ts
|
|
function isPlainObject(obj) {
|
|
if (typeof obj !== "object" || obj === null) return false;
|
|
const proto = Object.getPrototypeOf(obj);
|
|
if (proto === null) return true;
|
|
let baseProto = proto;
|
|
while (Object.getPrototypeOf(baseProto) !== null) {
|
|
baseProto = Object.getPrototypeOf(baseProto);
|
|
}
|
|
return proto === baseProto;
|
|
}
|
|
|
|
// src/utils/verifyPlainObject.ts
|
|
function verifyPlainObject(value, displayName, methodName) {
|
|
if (!isPlainObject(value)) {
|
|
warning(
|
|
`${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/connect/wrapMapToProps.ts
|
|
function wrapMapToPropsConstant(getConstant) {
|
|
return function initConstantSelector(dispatch) {
|
|
const constant = getConstant(dispatch);
|
|
function constantSelector() {
|
|
return constant;
|
|
}
|
|
constantSelector.dependsOnOwnProps = false;
|
|
return constantSelector;
|
|
};
|
|
}
|
|
function getDependsOnOwnProps(mapToProps) {
|
|
return mapToProps.dependsOnOwnProps ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;
|
|
}
|
|
function wrapMapToPropsFunc(mapToProps, methodName) {
|
|
return function initProxySelector(dispatch, { displayName }) {
|
|
const proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {
|
|
return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch, void 0);
|
|
};
|
|
proxy.dependsOnOwnProps = true;
|
|
proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {
|
|
proxy.mapToProps = mapToProps;
|
|
proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);
|
|
let props = proxy(stateOrDispatch, ownProps);
|
|
if (typeof props === "function") {
|
|
proxy.mapToProps = props;
|
|
proxy.dependsOnOwnProps = getDependsOnOwnProps(props);
|
|
props = proxy(stateOrDispatch, ownProps);
|
|
}
|
|
if (process.env.NODE_ENV !== "production")
|
|
verifyPlainObject(props, displayName, methodName);
|
|
return props;
|
|
};
|
|
return proxy;
|
|
};
|
|
}
|
|
|
|
// src/connect/invalidArgFactory.ts
|
|
function createInvalidArgFactory(arg, name) {
|
|
return (dispatch, options) => {
|
|
throw new Error(
|
|
`Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`
|
|
);
|
|
};
|
|
}
|
|
|
|
// src/connect/mapDispatchToProps.ts
|
|
function mapDispatchToPropsFactory(mapDispatchToProps) {
|
|
return mapDispatchToProps && typeof mapDispatchToProps === "object" ? wrapMapToPropsConstant(
|
|
(dispatch) => (
|
|
// @ts-ignore
|
|
bindActionCreators(mapDispatchToProps, dispatch)
|
|
)
|
|
) : !mapDispatchToProps ? wrapMapToPropsConstant((dispatch) => ({
|
|
dispatch
|
|
})) : typeof mapDispatchToProps === "function" ? (
|
|
// @ts-ignore
|
|
wrapMapToPropsFunc(mapDispatchToProps, "mapDispatchToProps")
|
|
) : createInvalidArgFactory(mapDispatchToProps, "mapDispatchToProps");
|
|
}
|
|
|
|
// src/connect/mapStateToProps.ts
|
|
function mapStateToPropsFactory(mapStateToProps) {
|
|
return !mapStateToProps ? wrapMapToPropsConstant(() => ({})) : typeof mapStateToProps === "function" ? (
|
|
// @ts-ignore
|
|
wrapMapToPropsFunc(mapStateToProps, "mapStateToProps")
|
|
) : createInvalidArgFactory(mapStateToProps, "mapStateToProps");
|
|
}
|
|
|
|
// src/connect/mergeProps.ts
|
|
function defaultMergeProps(stateProps, dispatchProps, ownProps) {
|
|
return __spreadValues(__spreadValues(__spreadValues({}, ownProps), stateProps), dispatchProps);
|
|
}
|
|
function wrapMergePropsFunc(mergeProps) {
|
|
return function initMergePropsProxy(dispatch, { displayName, areMergedPropsEqual }) {
|
|
let hasRunOnce = false;
|
|
let mergedProps;
|
|
return function mergePropsProxy(stateProps, dispatchProps, ownProps) {
|
|
const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);
|
|
if (hasRunOnce) {
|
|
if (!areMergedPropsEqual(nextMergedProps, mergedProps))
|
|
mergedProps = nextMergedProps;
|
|
} else {
|
|
hasRunOnce = true;
|
|
mergedProps = nextMergedProps;
|
|
if (process.env.NODE_ENV !== "production")
|
|
verifyPlainObject(mergedProps, displayName, "mergeProps");
|
|
}
|
|
return mergedProps;
|
|
};
|
|
};
|
|
}
|
|
function mergePropsFactory(mergeProps) {
|
|
return !mergeProps ? () => defaultMergeProps : typeof mergeProps === "function" ? wrapMergePropsFunc(mergeProps) : createInvalidArgFactory(mergeProps, "mergeProps");
|
|
}
|
|
|
|
// src/utils/batch.ts
|
|
function defaultNoopBatch(callback) {
|
|
callback();
|
|
}
|
|
|
|
// src/utils/Subscription.ts
|
|
function createListenerCollection() {
|
|
let first = null;
|
|
let last = null;
|
|
return {
|
|
clear() {
|
|
first = null;
|
|
last = null;
|
|
},
|
|
notify() {
|
|
defaultNoopBatch(() => {
|
|
let listener = first;
|
|
while (listener) {
|
|
listener.callback();
|
|
listener = listener.next;
|
|
}
|
|
});
|
|
},
|
|
get() {
|
|
const listeners = [];
|
|
let listener = first;
|
|
while (listener) {
|
|
listeners.push(listener);
|
|
listener = listener.next;
|
|
}
|
|
return listeners;
|
|
},
|
|
subscribe(callback) {
|
|
let isSubscribed = true;
|
|
const listener = last = {
|
|
callback,
|
|
next: null,
|
|
prev: last
|
|
};
|
|
if (listener.prev) {
|
|
listener.prev.next = listener;
|
|
} else {
|
|
first = listener;
|
|
}
|
|
return function unsubscribe() {
|
|
if (!isSubscribed || first === null) return;
|
|
isSubscribed = false;
|
|
if (listener.next) {
|
|
listener.next.prev = listener.prev;
|
|
} else {
|
|
last = listener.prev;
|
|
}
|
|
if (listener.prev) {
|
|
listener.prev.next = listener.next;
|
|
} else {
|
|
first = listener.next;
|
|
}
|
|
};
|
|
}
|
|
};
|
|
}
|
|
var nullListeners = {
|
|
notify() {
|
|
},
|
|
get: () => []
|
|
};
|
|
function createSubscription(store, parentSub) {
|
|
let unsubscribe;
|
|
let listeners = nullListeners;
|
|
let subscriptionsAmount = 0;
|
|
let selfSubscribed = false;
|
|
function addNestedSub(listener) {
|
|
trySubscribe();
|
|
const cleanupListener = listeners.subscribe(listener);
|
|
let removed = false;
|
|
return () => {
|
|
if (!removed) {
|
|
removed = true;
|
|
cleanupListener();
|
|
tryUnsubscribe();
|
|
}
|
|
};
|
|
}
|
|
function notifyNestedSubs() {
|
|
listeners.notify();
|
|
}
|
|
function handleChangeWrapper() {
|
|
if (subscription.onStateChange) {
|
|
subscription.onStateChange();
|
|
}
|
|
}
|
|
function isSubscribed() {
|
|
return selfSubscribed;
|
|
}
|
|
function trySubscribe() {
|
|
subscriptionsAmount++;
|
|
if (!unsubscribe) {
|
|
unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) : store.subscribe(handleChangeWrapper);
|
|
listeners = createListenerCollection();
|
|
}
|
|
}
|
|
function tryUnsubscribe() {
|
|
subscriptionsAmount--;
|
|
if (unsubscribe && subscriptionsAmount === 0) {
|
|
unsubscribe();
|
|
unsubscribe = void 0;
|
|
listeners.clear();
|
|
listeners = nullListeners;
|
|
}
|
|
}
|
|
function trySubscribeSelf() {
|
|
if (!selfSubscribed) {
|
|
selfSubscribed = true;
|
|
trySubscribe();
|
|
}
|
|
}
|
|
function tryUnsubscribeSelf() {
|
|
if (selfSubscribed) {
|
|
selfSubscribed = false;
|
|
tryUnsubscribe();
|
|
}
|
|
}
|
|
const subscription = {
|
|
addNestedSub,
|
|
notifyNestedSubs,
|
|
handleChangeWrapper,
|
|
isSubscribed,
|
|
trySubscribe: trySubscribeSelf,
|
|
tryUnsubscribe: tryUnsubscribeSelf,
|
|
getListeners: () => listeners
|
|
};
|
|
return subscription;
|
|
}
|
|
|
|
// src/utils/useIsomorphicLayoutEffect.ts
|
|
var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
|
|
var isDOM = /* @__PURE__ */ canUseDOM();
|
|
var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
|
|
var isReactNative = /* @__PURE__ */ isRunningInReactNative();
|
|
var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? React.useLayoutEffect : React.useEffect;
|
|
var useIsomorphicLayoutEffect = /* @__PURE__ */ getUseIsomorphicLayoutEffect();
|
|
|
|
// src/utils/shallowEqual.ts
|
|
function is(x, y) {
|
|
if (x === y) {
|
|
return x !== 0 || y !== 0 || 1 / x === 1 / y;
|
|
} else {
|
|
return x !== x && y !== y;
|
|
}
|
|
}
|
|
function shallowEqual(objA, objB) {
|
|
if (is(objA, objB)) return true;
|
|
if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
|
|
return false;
|
|
}
|
|
const keysA = Object.keys(objA);
|
|
const keysB = Object.keys(objB);
|
|
if (keysA.length !== keysB.length) return false;
|
|
for (let i = 0; i < keysA.length; i++) {
|
|
if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// src/utils/hoistStatics.ts
|
|
var REACT_STATICS = {
|
|
childContextTypes: true,
|
|
contextType: true,
|
|
contextTypes: true,
|
|
defaultProps: true,
|
|
displayName: true,
|
|
getDefaultProps: true,
|
|
getDerivedStateFromError: true,
|
|
getDerivedStateFromProps: true,
|
|
mixins: true,
|
|
propTypes: true,
|
|
type: true
|
|
};
|
|
var KNOWN_STATICS = {
|
|
name: true,
|
|
length: true,
|
|
prototype: true,
|
|
caller: true,
|
|
callee: true,
|
|
arguments: true,
|
|
arity: true
|
|
};
|
|
var FORWARD_REF_STATICS = {
|
|
$$typeof: true,
|
|
render: true,
|
|
defaultProps: true,
|
|
displayName: true,
|
|
propTypes: true
|
|
};
|
|
var MEMO_STATICS = {
|
|
$$typeof: true,
|
|
compare: true,
|
|
defaultProps: true,
|
|
displayName: true,
|
|
propTypes: true,
|
|
type: true
|
|
};
|
|
var TYPE_STATICS = {
|
|
[ForwardRef]: FORWARD_REF_STATICS,
|
|
[Memo]: MEMO_STATICS
|
|
};
|
|
function getStatics(component) {
|
|
if (isMemo(component)) {
|
|
return MEMO_STATICS;
|
|
}
|
|
return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
|
|
}
|
|
var defineProperty = Object.defineProperty;
|
|
var getOwnPropertyNames = Object.getOwnPropertyNames;
|
|
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var getPrototypeOf = Object.getPrototypeOf;
|
|
var objectPrototype = Object.prototype;
|
|
function hoistNonReactStatics(targetComponent, sourceComponent) {
|
|
if (typeof sourceComponent !== "string") {
|
|
if (objectPrototype) {
|
|
const inheritedComponent = getPrototypeOf(sourceComponent);
|
|
if (inheritedComponent && inheritedComponent !== objectPrototype) {
|
|
hoistNonReactStatics(targetComponent, inheritedComponent);
|
|
}
|
|
}
|
|
let keys = getOwnPropertyNames(sourceComponent);
|
|
if (getOwnPropertySymbols) {
|
|
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
|
|
}
|
|
const targetStatics = getStatics(targetComponent);
|
|
const sourceStatics = getStatics(sourceComponent);
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
const key = keys[i];
|
|
if (!KNOWN_STATICS[key] && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
|
|
const descriptor = getOwnPropertyDescriptor(sourceComponent, key);
|
|
try {
|
|
defineProperty(targetComponent, key, descriptor);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return targetComponent;
|
|
}
|
|
|
|
// src/components/Context.ts
|
|
var ContextKey = /* @__PURE__ */ Symbol.for(`react-redux-context`);
|
|
var gT = typeof globalThis !== "undefined" ? globalThis : (
|
|
/* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
|
|
{}
|
|
);
|
|
function getContext() {
|
|
var _a;
|
|
if (!React.createContext) return {};
|
|
const contextMap = (_a = gT[ContextKey]) != null ? _a : gT[ContextKey] = /* @__PURE__ */ new Map();
|
|
let realContext = contextMap.get(React.createContext);
|
|
if (!realContext) {
|
|
realContext = React.createContext(
|
|
null
|
|
);
|
|
if (process.env.NODE_ENV !== "production") {
|
|
realContext.displayName = "ReactRedux";
|
|
}
|
|
contextMap.set(React.createContext, realContext);
|
|
}
|
|
return realContext;
|
|
}
|
|
var ReactReduxContext = /* @__PURE__ */ getContext();
|
|
|
|
// src/components/connect.tsx
|
|
var NO_SUBSCRIPTION_ARRAY = [null, null];
|
|
var stringifyComponent = (Comp) => {
|
|
try {
|
|
return JSON.stringify(Comp);
|
|
} catch (err) {
|
|
return String(Comp);
|
|
}
|
|
};
|
|
function useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) {
|
|
useIsomorphicLayoutEffect(() => effectFunc(...effectArgs), dependencies);
|
|
}
|
|
function captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate, notifyNestedSubs) {
|
|
lastWrapperProps.current = wrapperProps;
|
|
renderIsScheduled.current = false;
|
|
if (childPropsFromStoreUpdate.current) {
|
|
childPropsFromStoreUpdate.current = null;
|
|
notifyNestedSubs();
|
|
}
|
|
}
|
|
function subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, additionalSubscribeListener) {
|
|
if (!shouldHandleStateChanges) return () => {
|
|
};
|
|
let didUnsubscribe = false;
|
|
let lastThrownError = null;
|
|
const checkForUpdates = () => {
|
|
if (didUnsubscribe || !isMounted.current) {
|
|
return;
|
|
}
|
|
const latestStoreState = store.getState();
|
|
let newChildProps, error;
|
|
try {
|
|
newChildProps = childPropsSelector(
|
|
latestStoreState,
|
|
lastWrapperProps.current
|
|
);
|
|
} catch (e) {
|
|
error = e;
|
|
lastThrownError = e;
|
|
}
|
|
if (!error) {
|
|
lastThrownError = null;
|
|
}
|
|
if (newChildProps === lastChildProps.current) {
|
|
if (!renderIsScheduled.current) {
|
|
notifyNestedSubs();
|
|
}
|
|
} else {
|
|
lastChildProps.current = newChildProps;
|
|
childPropsFromStoreUpdate.current = newChildProps;
|
|
renderIsScheduled.current = true;
|
|
additionalSubscribeListener();
|
|
}
|
|
};
|
|
subscription.onStateChange = checkForUpdates;
|
|
subscription.trySubscribe();
|
|
checkForUpdates();
|
|
const unsubscribeWrapper = () => {
|
|
didUnsubscribe = true;
|
|
subscription.tryUnsubscribe();
|
|
subscription.onStateChange = null;
|
|
if (lastThrownError) {
|
|
throw lastThrownError;
|
|
}
|
|
};
|
|
return unsubscribeWrapper;
|
|
}
|
|
function strictEqual(a, b) {
|
|
return a === b;
|
|
}
|
|
var hasWarnedAboutDeprecatedPureOption = false;
|
|
function connect(mapStateToProps, mapDispatchToProps, mergeProps, {
|
|
// The `pure` option has been removed, so TS doesn't like us destructuring this to check its existence.
|
|
// @ts-ignore
|
|
pure,
|
|
areStatesEqual = strictEqual,
|
|
areOwnPropsEqual = shallowEqual,
|
|
areStatePropsEqual = shallowEqual,
|
|
areMergedPropsEqual = shallowEqual,
|
|
// use React's forwardRef to expose a ref of the wrapped component
|
|
forwardRef = false,
|
|
// the context consumer to use
|
|
context = ReactReduxContext
|
|
} = {}) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (pure !== void 0 && !hasWarnedAboutDeprecatedPureOption) {
|
|
hasWarnedAboutDeprecatedPureOption = true;
|
|
warning(
|
|
'The `pure` option has been removed. `connect` is now always a "pure/memoized" component'
|
|
);
|
|
}
|
|
}
|
|
const Context = context;
|
|
const initMapStateToProps = mapStateToPropsFactory(mapStateToProps);
|
|
const initMapDispatchToProps = mapDispatchToPropsFactory(mapDispatchToProps);
|
|
const initMergeProps = mergePropsFactory(mergeProps);
|
|
const shouldHandleStateChanges = Boolean(mapStateToProps);
|
|
const wrapWithConnect = (WrappedComponent) => {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
const isValid = /* @__PURE__ */ isValidElementType(WrappedComponent);
|
|
if (!isValid)
|
|
throw new Error(
|
|
`You must pass a component to the function returned by connect. Instead received ${stringifyComponent(
|
|
WrappedComponent
|
|
)}`
|
|
);
|
|
}
|
|
const wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || "Component";
|
|
const displayName = `Connect(${wrappedComponentName})`;
|
|
const selectorFactoryOptions = {
|
|
shouldHandleStateChanges,
|
|
displayName,
|
|
wrappedComponentName,
|
|
WrappedComponent,
|
|
// @ts-ignore
|
|
initMapStateToProps,
|
|
initMapDispatchToProps,
|
|
initMergeProps,
|
|
areStatesEqual,
|
|
areStatePropsEqual,
|
|
areOwnPropsEqual,
|
|
areMergedPropsEqual
|
|
};
|
|
function ConnectFunction(props) {
|
|
const [propsContext, reactReduxForwardedRef, wrapperProps] = React.useMemo(() => {
|
|
const _a = props, { reactReduxForwardedRef: reactReduxForwardedRef2 } = _a, wrapperProps2 = __objRest(_a, ["reactReduxForwardedRef"]);
|
|
return [props.context, reactReduxForwardedRef2, wrapperProps2];
|
|
}, [props]);
|
|
const ContextToUse = React.useMemo(() => {
|
|
let ResultContext = Context;
|
|
if (propsContext == null ? void 0 : propsContext.Consumer) {
|
|
if (process.env.NODE_ENV !== "production") {
|
|
const isValid = /* @__PURE__ */ isContextConsumer(
|
|
// @ts-ignore
|
|
/* @__PURE__ */ React.createElement(propsContext.Consumer, null)
|
|
);
|
|
if (!isValid) {
|
|
throw new Error(
|
|
"You must pass a valid React context consumer as `props.context`"
|
|
);
|
|
}
|
|
ResultContext = propsContext;
|
|
}
|
|
}
|
|
return ResultContext;
|
|
}, [propsContext, Context]);
|
|
const contextValue = React.useContext(ContextToUse);
|
|
const didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch);
|
|
const didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store);
|
|
if (process.env.NODE_ENV !== "production" && !didStoreComeFromProps && !didStoreComeFromContext) {
|
|
throw new Error(
|
|
`Could not find "store" in the context of "${displayName}". Either wrap the root component in a <Provider>, or pass a custom React context provider to <Provider> and the corresponding React context consumer to ${displayName} in connect options.`
|
|
);
|
|
}
|
|
const store = didStoreComeFromProps ? props.store : contextValue.store;
|
|
const getServerState = didStoreComeFromContext ? contextValue.getServerState : store.getState;
|
|
const childPropsSelector = React.useMemo(() => {
|
|
return finalPropsSelectorFactory(store.dispatch, selectorFactoryOptions);
|
|
}, [store]);
|
|
const [subscription, notifyNestedSubs] = React.useMemo(() => {
|
|
if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY;
|
|
const subscription2 = createSubscription(
|
|
store,
|
|
didStoreComeFromProps ? void 0 : contextValue.subscription
|
|
);
|
|
const notifyNestedSubs2 = subscription2.notifyNestedSubs.bind(subscription2);
|
|
return [subscription2, notifyNestedSubs2];
|
|
}, [store, didStoreComeFromProps, contextValue]);
|
|
const overriddenContextValue = React.useMemo(() => {
|
|
if (didStoreComeFromProps) {
|
|
return contextValue;
|
|
}
|
|
return __spreadProps(__spreadValues({}, contextValue), {
|
|
subscription
|
|
});
|
|
}, [didStoreComeFromProps, contextValue, subscription]);
|
|
const lastChildProps = React.useRef(void 0);
|
|
const lastWrapperProps = React.useRef(wrapperProps);
|
|
const childPropsFromStoreUpdate = React.useRef(void 0);
|
|
const renderIsScheduled = React.useRef(false);
|
|
const isMounted = React.useRef(false);
|
|
const latestSubscriptionCallbackError = React.useRef(
|
|
void 0
|
|
);
|
|
useIsomorphicLayoutEffect(() => {
|
|
isMounted.current = true;
|
|
return () => {
|
|
isMounted.current = false;
|
|
};
|
|
}, []);
|
|
const actualChildPropsSelector = React.useMemo(() => {
|
|
const selector = () => {
|
|
if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) {
|
|
return childPropsFromStoreUpdate.current;
|
|
}
|
|
return childPropsSelector(store.getState(), wrapperProps);
|
|
};
|
|
return selector;
|
|
}, [store, wrapperProps]);
|
|
const subscribeForReact = React.useMemo(() => {
|
|
const subscribe = (reactListener) => {
|
|
if (!subscription) {
|
|
return () => {
|
|
};
|
|
}
|
|
return subscribeUpdates(
|
|
shouldHandleStateChanges,
|
|
store,
|
|
subscription,
|
|
// @ts-ignore
|
|
childPropsSelector,
|
|
lastWrapperProps,
|
|
lastChildProps,
|
|
renderIsScheduled,
|
|
isMounted,
|
|
childPropsFromStoreUpdate,
|
|
notifyNestedSubs,
|
|
reactListener
|
|
);
|
|
};
|
|
return subscribe;
|
|
}, [subscription]);
|
|
useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [
|
|
lastWrapperProps,
|
|
lastChildProps,
|
|
renderIsScheduled,
|
|
wrapperProps,
|
|
childPropsFromStoreUpdate,
|
|
notifyNestedSubs
|
|
]);
|
|
let actualChildProps;
|
|
try {
|
|
actualChildProps = React.useSyncExternalStore(
|
|
// TODO We're passing through a big wrapper that does a bunch of extra side effects besides subscribing
|
|
subscribeForReact,
|
|
// TODO This is incredibly hacky. We've already processed the store update and calculated new child props,
|
|
// TODO and we're just passing that through so it triggers a re-render for us rather than relying on `uSES`.
|
|
actualChildPropsSelector,
|
|
getServerState ? () => childPropsSelector(getServerState(), wrapperProps) : actualChildPropsSelector
|
|
);
|
|
} catch (err) {
|
|
if (latestSubscriptionCallbackError.current) {
|
|
;
|
|
err.message += `
|
|
The error may be correlated with this previous error:
|
|
${latestSubscriptionCallbackError.current.stack}
|
|
|
|
`;
|
|
}
|
|
throw err;
|
|
}
|
|
useIsomorphicLayoutEffect(() => {
|
|
latestSubscriptionCallbackError.current = void 0;
|
|
childPropsFromStoreUpdate.current = void 0;
|
|
lastChildProps.current = actualChildProps;
|
|
});
|
|
const renderedWrappedComponent = React.useMemo(() => {
|
|
return (
|
|
// @ts-ignore
|
|
/* @__PURE__ */ React.createElement(
|
|
WrappedComponent,
|
|
__spreadProps(__spreadValues({}, actualChildProps), {
|
|
ref: reactReduxForwardedRef
|
|
})
|
|
)
|
|
);
|
|
}, [reactReduxForwardedRef, WrappedComponent, actualChildProps]);
|
|
const renderedChild = React.useMemo(() => {
|
|
if (shouldHandleStateChanges) {
|
|
return /* @__PURE__ */ React.createElement(ContextToUse.Provider, { value: overriddenContextValue }, renderedWrappedComponent);
|
|
}
|
|
return renderedWrappedComponent;
|
|
}, [ContextToUse, renderedWrappedComponent, overriddenContextValue]);
|
|
return renderedChild;
|
|
}
|
|
const _Connect = React.memo(ConnectFunction);
|
|
const Connect = _Connect;
|
|
Connect.WrappedComponent = WrappedComponent;
|
|
Connect.displayName = ConnectFunction.displayName = displayName;
|
|
if (forwardRef) {
|
|
const _forwarded = React.forwardRef(
|
|
function forwardConnectRef(props, ref) {
|
|
return /* @__PURE__ */ React.createElement(Connect, __spreadProps(__spreadValues({}, props), { reactReduxForwardedRef: ref }));
|
|
}
|
|
);
|
|
const forwarded = _forwarded;
|
|
forwarded.displayName = displayName;
|
|
forwarded.WrappedComponent = WrappedComponent;
|
|
return /* @__PURE__ */ hoistNonReactStatics(forwarded, WrappedComponent);
|
|
}
|
|
return /* @__PURE__ */ hoistNonReactStatics(Connect, WrappedComponent);
|
|
};
|
|
return wrapWithConnect;
|
|
}
|
|
var connect_default = connect;
|
|
|
|
// src/components/Provider.tsx
|
|
function Provider(providerProps) {
|
|
const { children, context, serverState, store } = providerProps;
|
|
const contextValue = React.useMemo(() => {
|
|
const subscription = createSubscription(store);
|
|
const baseContextValue = {
|
|
store,
|
|
subscription,
|
|
getServerState: serverState ? () => serverState : void 0
|
|
};
|
|
if (process.env.NODE_ENV === "production") {
|
|
return baseContextValue;
|
|
} else {
|
|
const { identityFunctionCheck = "once", stabilityCheck = "once" } = providerProps;
|
|
return /* @__PURE__ */ Object.assign(baseContextValue, {
|
|
stabilityCheck,
|
|
identityFunctionCheck
|
|
});
|
|
}
|
|
}, [store, serverState]);
|
|
const previousState = React.useMemo(() => store.getState(), [store]);
|
|
useIsomorphicLayoutEffect(() => {
|
|
const { subscription } = contextValue;
|
|
subscription.onStateChange = subscription.notifyNestedSubs;
|
|
subscription.trySubscribe();
|
|
if (previousState !== store.getState()) {
|
|
subscription.notifyNestedSubs();
|
|
}
|
|
return () => {
|
|
subscription.tryUnsubscribe();
|
|
subscription.onStateChange = void 0;
|
|
};
|
|
}, [contextValue, previousState]);
|
|
const Context = context || ReactReduxContext;
|
|
return /* @__PURE__ */ React.createElement(Context.Provider, { value: contextValue }, children);
|
|
}
|
|
var Provider_default = Provider;
|
|
|
|
// src/hooks/useReduxContext.ts
|
|
function createReduxContextHook(context = ReactReduxContext) {
|
|
return function useReduxContext2() {
|
|
const contextValue = React.useContext(context);
|
|
if (process.env.NODE_ENV !== "production" && !contextValue) {
|
|
throw new Error(
|
|
"could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
|
|
);
|
|
}
|
|
return contextValue;
|
|
};
|
|
}
|
|
var useReduxContext = /* @__PURE__ */ createReduxContextHook();
|
|
|
|
// src/hooks/useStore.ts
|
|
function createStoreHook(context = ReactReduxContext) {
|
|
const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
|
|
// @ts-ignore
|
|
createReduxContextHook(context)
|
|
);
|
|
const useStore2 = () => {
|
|
const { store } = useReduxContext2();
|
|
return store;
|
|
};
|
|
Object.assign(useStore2, {
|
|
withTypes: () => useStore2
|
|
});
|
|
return useStore2;
|
|
}
|
|
var useStore = /* @__PURE__ */ createStoreHook();
|
|
|
|
// src/hooks/useDispatch.ts
|
|
function createDispatchHook(context = ReactReduxContext) {
|
|
const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
|
|
const useDispatch2 = () => {
|
|
const store = useStore2();
|
|
return store.dispatch;
|
|
};
|
|
Object.assign(useDispatch2, {
|
|
withTypes: () => useDispatch2
|
|
});
|
|
return useDispatch2;
|
|
}
|
|
var useDispatch = /* @__PURE__ */ createDispatchHook();
|
|
|
|
// src/hooks/useSelector.ts
|
|
import { useSyncExternalStoreWithSelector } from "use-sync-external-store/with-selector.js";
|
|
var refEquality = (a, b) => a === b;
|
|
function createSelectorHook(context = ReactReduxContext) {
|
|
const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
|
|
const useSelector2 = (selector, equalityFnOrOptions = {}) => {
|
|
const { equalityFn = refEquality } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
|
|
if (process.env.NODE_ENV !== "production") {
|
|
if (!selector) {
|
|
throw new Error(`You must pass a selector to useSelector`);
|
|
}
|
|
if (typeof selector !== "function") {
|
|
throw new Error(`You must pass a function as a selector to useSelector`);
|
|
}
|
|
if (typeof equalityFn !== "function") {
|
|
throw new Error(
|
|
`You must pass a function as an equality function to useSelector`
|
|
);
|
|
}
|
|
}
|
|
const reduxContext = useReduxContext2();
|
|
const { store, subscription, getServerState } = reduxContext;
|
|
const firstRun = React.useRef(true);
|
|
const wrappedSelector = React.useCallback(
|
|
{
|
|
[selector.name](state) {
|
|
const selected = selector(state);
|
|
if (process.env.NODE_ENV !== "production") {
|
|
const { devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? {} : equalityFnOrOptions;
|
|
const { identityFunctionCheck, stabilityCheck } = reduxContext;
|
|
const {
|
|
identityFunctionCheck: finalIdentityFunctionCheck,
|
|
stabilityCheck: finalStabilityCheck
|
|
} = __spreadValues({
|
|
stabilityCheck,
|
|
identityFunctionCheck
|
|
}, devModeChecks);
|
|
if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) {
|
|
const toCompare = selector(state);
|
|
if (!equalityFn(selected, toCompare)) {
|
|
let stack = void 0;
|
|
try {
|
|
throw new Error();
|
|
} catch (e) {
|
|
;
|
|
({ stack } = e);
|
|
}
|
|
console.warn(
|
|
"Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization",
|
|
{
|
|
state,
|
|
selected,
|
|
selected2: toCompare,
|
|
stack
|
|
}
|
|
);
|
|
}
|
|
}
|
|
if (finalIdentityFunctionCheck === "always" || finalIdentityFunctionCheck === "once" && firstRun.current) {
|
|
if (selected === state) {
|
|
let stack = void 0;
|
|
try {
|
|
throw new Error();
|
|
} catch (e) {
|
|
;
|
|
({ stack } = e);
|
|
}
|
|
console.warn(
|
|
"Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.",
|
|
{ stack }
|
|
);
|
|
}
|
|
}
|
|
if (firstRun.current) firstRun.current = false;
|
|
}
|
|
return selected;
|
|
}
|
|
}[selector.name],
|
|
[selector]
|
|
);
|
|
const selectedState = useSyncExternalStoreWithSelector(
|
|
subscription.addNestedSub,
|
|
store.getState,
|
|
getServerState || store.getState,
|
|
wrappedSelector,
|
|
equalityFn
|
|
);
|
|
React.useDebugValue(selectedState);
|
|
return selectedState;
|
|
};
|
|
Object.assign(useSelector2, {
|
|
withTypes: () => useSelector2
|
|
});
|
|
return useSelector2;
|
|
}
|
|
var useSelector = /* @__PURE__ */ createSelectorHook();
|
|
|
|
// src/exports.ts
|
|
var batch = defaultNoopBatch;
|
|
export {
|
|
Provider_default as Provider,
|
|
ReactReduxContext,
|
|
batch,
|
|
connect_default as connect,
|
|
createDispatchHook,
|
|
createSelectorHook,
|
|
createStoreHook,
|
|
shallowEqual,
|
|
useDispatch,
|
|
useSelector,
|
|
useStore
|
|
};
|
|
//# sourceMappingURL=react-redux.legacy-esm.js.map
|