node_modules ignore

server/node_modules/react-redux/es/connect/invalidArgFactory.d.ts

@@ -0,0 +1,4 @@
+import type { Action, Dispatch } from 'redux';
+export declare function createInvalidArgFactory(arg: unknown, name: string): (dispatch: Dispatch<Action<unknown>>, options: {
+    readonly wrappedComponentName: string;
+}) => never;

server/node_modules/react-redux/es/connect/invalidArgFactory.js

@@ -0,0 +1,5 @@
+export function createInvalidArgFactory(arg, name) {
+  return (dispatch, options) => {
+    throw new Error(`Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`);
+  };
+}

server/node_modules/react-redux/es/connect/mapDispatchToProps.d.ts

@@ -0,0 +1,29 @@
+import type { Action, Dispatch } from 'redux';
+import type { MapDispatchToPropsParam } from './selectorFactory';
+export declare function mapDispatchToPropsFactory<TDispatchProps, TOwnProps>(mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps> | undefined): ((dispatch: Dispatch<import("redux").AnyAction>) => {
+    (): import("redux").ActionCreatorsMapObject<any> | import("redux").ActionCreator<any> | {
+        dispatch?: Dispatch<import("redux").AnyAction> | undefined;
+        dependsOnOwnProps?: boolean | undefined;
+    };
+    dependsOnOwnProps: boolean;
+}) | ((dispatch: Dispatch<Action<unknown>>, options: {
+    readonly wrappedComponentName: string;
+}) => never) | ((dispatch: Dispatch<import("redux").AnyAction>, { displayName }: {
+    displayName: string;
+}) => {
+    (stateOrDispatch: {
+        [key: string]: any;
+    } | Dispatch<import("redux").AnyAction>, ownProps?: {
+        [key: string]: any;
+    } | undefined): import("./wrapMapToProps").MapToProps<{
+        [key: string]: any;
+    }>;
+    dependsOnOwnProps: boolean;
+    mapToProps(stateOrDispatch: {
+        [key: string]: any;
+    } | Dispatch<import("redux").AnyAction>, ownProps?: {
+        [key: string]: any;
+    } | undefined): import("./wrapMapToProps").MapToProps<{
+        [key: string]: any;
+    }>;
+});

server/node_modules/react-redux/es/connect/mapDispatchToProps.js

@@ -0,0 +1,10 @@
+import bindActionCreators from '../utils/bindActionCreators';
+import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps';
+import { createInvalidArgFactory } from './invalidArgFactory';
+export 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');
+}

server/node_modules/react-redux/es/connect/mapStateToProps.d.ts

@@ -0,0 +1,28 @@
+import type { MapStateToPropsParam } from './selectorFactory';
+export declare function mapStateToPropsFactory<TStateProps, TOwnProps, State>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>): ((dispatch: import("redux").Dispatch<import("redux").AnyAction>) => {
+    (): import("redux").ActionCreatorsMapObject<any> | import("redux").ActionCreator<any> | {
+        dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+        dependsOnOwnProps?: boolean | undefined;
+    };
+    dependsOnOwnProps: boolean;
+}) | ((dispatch: import("redux").Dispatch<import("redux").Action<unknown>>, options: {
+    readonly wrappedComponentName: string;
+}) => never) | ((dispatch: import("redux").Dispatch<import("redux").AnyAction>, { displayName }: {
+    displayName: string;
+}) => {
+    (stateOrDispatch: {
+        [key: string]: any;
+    } | import("redux").Dispatch<import("redux").AnyAction>, ownProps?: {
+        [key: string]: any;
+    } | undefined): import("./wrapMapToProps").MapToProps<{
+        [key: string]: any;
+    }>;
+    dependsOnOwnProps: boolean;
+    mapToProps(stateOrDispatch: {
+        [key: string]: any;
+    } | import("redux").Dispatch<import("redux").AnyAction>, ownProps?: {
+        [key: string]: any;
+    } | undefined): import("./wrapMapToProps").MapToProps<{
+        [key: string]: any;
+    }>;
+});

server/node_modules/react-redux/es/connect/mapStateToProps.js

@@ -0,0 +1,6 @@
+import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps';
+import { createInvalidArgFactory } from './invalidArgFactory';
+export function mapStateToPropsFactory(mapStateToProps) {
+  return !mapStateToProps ? wrapMapToPropsConstant(() => ({})) : typeof mapStateToProps === 'function' ? // @ts-ignore
+  wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps') : createInvalidArgFactory(mapStateToProps, 'mapStateToProps');
+}

server/node_modules/react-redux/es/connect/mergeProps.d.ts

@@ -0,0 +1,14 @@
+import type { Action, Dispatch } from 'redux';
+import type { MergeProps } from './selectorFactory';
+import type { EqualityFn } from '../types';
+export declare function defaultMergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>(stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps): TMergedProps;
+export declare function wrapMergePropsFunc<TStateProps, TDispatchProps, TOwnProps, TMergedProps>(mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>): (dispatch: Dispatch<Action<unknown>>, options: {
+    readonly displayName: string;
+    readonly areMergedPropsEqual: EqualityFn<TMergedProps>;
+}) => MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>;
+export declare function mergePropsFactory<TStateProps, TDispatchProps, TOwnProps, TMergedProps>(mergeProps?: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>): ((dispatch: Dispatch<Action<unknown>>, options: {
+    readonly wrappedComponentName: string;
+}) => never) | ((dispatch: Dispatch<Action<unknown>>, options: {
+    readonly displayName: string;
+    readonly areMergedPropsEqual: EqualityFn<TMergedProps>;
+}) => MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>);

server/node_modules/react-redux/es/connect/mergeProps.js

@@ -0,0 +1,32 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import verifyPlainObject from '../utils/verifyPlainObject';
+import { createInvalidArgFactory } from './invalidArgFactory';
+export function defaultMergeProps(stateProps, dispatchProps, ownProps) {
+  // @ts-ignore
+  return _extends({}, ownProps, stateProps, dispatchProps);
+}
+export 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;
+    };
+  };
+}
+export function mergePropsFactory(mergeProps) {
+  return !mergeProps ? () => defaultMergeProps : typeof mergeProps === 'function' ? wrapMergePropsFunc(mergeProps) : createInvalidArgFactory(mergeProps, 'mergeProps');
+}

server/node_modules/react-redux/es/connect/selectorFactory.d.ts

@@ -0,0 +1,42 @@
+import type { Dispatch, Action } from 'redux';
+import type { ComponentType } from 'react';
+import type { EqualityFn, ExtendedEqualityFn } from '../types';
+export declare type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (dispatch: Dispatch<Action<unknown>>, factoryOptions: TFactoryOptions) => Selector<S, TProps, TOwnProps>;
+export declare type Selector<S, TProps, TOwnProps = null> = TOwnProps extends null | undefined ? (state: S) => TProps : (state: S, ownProps: TOwnProps) => TProps;
+export declare type MapStateToProps<TStateProps, TOwnProps, State> = (state: State, ownProps: TOwnProps) => TStateProps;
+export declare type MapStateToPropsFactory<TStateProps, TOwnProps, State> = (initialState: State, ownProps: TOwnProps) => MapStateToProps<TStateProps, TOwnProps, State>;
+export declare type MapStateToPropsParam<TStateProps, TOwnProps, State> = MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
+export declare type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action<unknown>>, ownProps: TOwnProps) => TDispatchProps;
+export declare type MapDispatchToProps<TDispatchProps, TOwnProps> = MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | TDispatchProps;
+export declare type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action<unknown>>, ownProps: TOwnProps) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+export declare type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
+export declare type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+export declare type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps) => TMergedProps;
+interface PureSelectorFactoryComparisonOptions<TStateProps, TOwnProps, State> {
+    readonly areStatesEqual: ExtendedEqualityFn<State, TOwnProps>;
+    readonly areStatePropsEqual: EqualityFn<TStateProps>;
+    readonly areOwnPropsEqual: EqualityFn<TOwnProps>;
+}
+export declare function pureFinalPropsSelectorFactory<TStateProps, TOwnProps, TDispatchProps, TMergedProps, State>(mapStateToProps: WrappedMapStateToProps<TStateProps, TOwnProps, State>, mapDispatchToProps: WrappedMapDispatchToProps<TDispatchProps, TOwnProps>, mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>, dispatch: Dispatch<Action<unknown>>, { areStatesEqual, areOwnPropsEqual, areStatePropsEqual, }: PureSelectorFactoryComparisonOptions<TStateProps, TOwnProps, State>): (nextState: State, nextOwnProps: TOwnProps) => TMergedProps;
+interface WrappedMapStateToProps<TStateProps, TOwnProps, State> {
+    (state: State, ownProps: TOwnProps): TStateProps;
+    readonly dependsOnOwnProps: boolean;
+}
+interface WrappedMapDispatchToProps<TDispatchProps, TOwnProps> {
+    (dispatch: Dispatch<Action<unknown>>, ownProps: TOwnProps): TDispatchProps;
+    readonly dependsOnOwnProps: boolean;
+}
+export interface InitOptions<TStateProps, TOwnProps, TMergedProps, State> extends PureSelectorFactoryComparisonOptions<TStateProps, TOwnProps, State> {
+    readonly shouldHandleStateChanges: boolean;
+    readonly displayName: string;
+    readonly wrappedComponentName: string;
+    readonly WrappedComponent: ComponentType<TOwnProps>;
+    readonly areMergedPropsEqual: EqualityFn<TMergedProps>;
+}
+export interface SelectorFactoryOptions<TStateProps, TOwnProps, TDispatchProps, TMergedProps, State> extends InitOptions<TStateProps, TOwnProps, TMergedProps, State> {
+    readonly initMapStateToProps: (dispatch: Dispatch<Action<unknown>>, options: InitOptions<TStateProps, TOwnProps, TMergedProps, State>) => WrappedMapStateToProps<TStateProps, TOwnProps, State>;
+    readonly initMapDispatchToProps: (dispatch: Dispatch<Action<unknown>>, options: InitOptions<TStateProps, TOwnProps, TMergedProps, State>) => WrappedMapDispatchToProps<TDispatchProps, TOwnProps>;
+    readonly initMergeProps: (dispatch: Dispatch<Action<unknown>>, options: InitOptions<TStateProps, TOwnProps, TMergedProps, State>) => MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>;
+}
+export default function finalPropsSelectorFactory<TStateProps, TOwnProps, TDispatchProps, TMergedProps, State>(dispatch: Dispatch<Action<unknown>>, { initMapStateToProps, initMapDispatchToProps, initMergeProps, ...options }: SelectorFactoryOptions<TStateProps, TOwnProps, TDispatchProps, TMergedProps, State>): (nextState: State, nextOwnProps: TOwnProps) => TMergedProps;
+export {};

server/node_modules/react-redux/es/connect/selectorFactory.js

@@ -0,0 +1,84 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["initMapStateToProps", "initMapDispatchToProps", "initMergeProps"];
+import verifySubselectors from './verifySubselectors';
+export 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);
+  };
+}
+// TODO: Add more comments
+// The selector returned by selectorFactory will memoize its results,
+// allowing connect's shouldComponentUpdate to return false if final
+// props have not changed.
+export default function finalPropsSelectorFactory(dispatch, _ref) {
+  let {
+    initMapStateToProps,
+    initMapDispatchToProps,
+    initMergeProps
+  } = _ref,
+      options = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+  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);
+}

server/node_modules/react-redux/es/connect/verifySubselectors.d.ts

@@ -0,0 +1 @@
+export default function verifySubselectors(mapStateToProps: unknown, mapDispatchToProps: unknown, mergeProps: unknown): void;

server/node_modules/react-redux/es/connect/verifySubselectors.js

@@ -0,0 +1,17 @@
+import warning from '../utils/warning';
+
+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.`);
+    }
+  }
+}
+
+export default function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps) {
+  verify(mapStateToProps, 'mapStateToProps');
+  verify(mapDispatchToProps, 'mapDispatchToProps');
+  verify(mergeProps, 'mergeProps');
+}

server/node_modules/react-redux/es/connect/wrapMapToProps.d.ts

@@ -0,0 +1,32 @@
+import type { ActionCreatorsMapObject, Dispatch, ActionCreator } from 'redux';
+import type { FixTypeLater } from '../types';
+declare type AnyState = {
+    [key: string]: any;
+};
+declare type StateOrDispatch<S extends AnyState = AnyState> = S | Dispatch;
+declare type AnyProps = {
+    [key: string]: any;
+};
+export declare type MapToProps<P extends AnyProps = AnyProps> = {
+    (stateOrDispatch: StateOrDispatch, ownProps?: P): FixTypeLater;
+    dependsOnOwnProps?: boolean;
+};
+export declare function wrapMapToPropsConstant(getConstant: (dispatch: Dispatch) => {
+    dispatch?: Dispatch;
+    dependsOnOwnProps?: boolean;
+} | ActionCreatorsMapObject | ActionCreator<any>): (dispatch: Dispatch) => {
+    (): ActionCreatorsMapObject<any> | ActionCreator<any> | {
+        dispatch?: Dispatch<import("redux").AnyAction> | undefined;
+        dependsOnOwnProps?: boolean | undefined;
+    };
+    dependsOnOwnProps: boolean;
+};
+export declare function getDependsOnOwnProps(mapToProps: MapToProps): boolean;
+export declare function wrapMapToPropsFunc<P extends AnyProps = AnyProps>(mapToProps: MapToProps, methodName: string): (dispatch: Dispatch, { displayName }: {
+    displayName: string;
+}) => {
+    (stateOrDispatch: StateOrDispatch, ownProps?: P | undefined): MapToProps;
+    dependsOnOwnProps: boolean;
+    mapToProps(stateOrDispatch: StateOrDispatch, ownProps?: P | undefined): MapToProps;
+};
+export {};

server/node_modules/react-redux/es/connect/wrapMapToProps.js

@@ -0,0 +1,70 @@
+import verifyPlainObject from '../utils/verifyPlainObject';
+export function wrapMapToPropsConstant( // * Note:
+//  It seems that the dispatch argument
+//  could be a dispatch function in some cases (ex: whenMapDispatchToPropsIsMissing)
+//  and a state object in some others (ex: whenMapStateToPropsIsMissing)
+// eslint-disable-next-line no-unused-vars
+getConstant) {
+  return function initConstantSelector(dispatch) {
+    const constant = getConstant(dispatch);
+
+    function constantSelector() {
+      return constant;
+    }
+
+    constantSelector.dependsOnOwnProps = false;
+    return constantSelector;
+  };
+} // dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args
+// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine
+// whether mapToProps needs to be invoked when props have changed.
+//
+// A length of one signals that mapToProps does not depend on props from the parent component.
+// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and
+// therefore not reporting its length accurately..
+// TODO Can this get pulled out so that we can subscribe directly to the store if we don't need ownProps?
+
+export function getDependsOnOwnProps(mapToProps) {
+  return mapToProps.dependsOnOwnProps ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;
+} // Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,
+// this function wraps mapToProps in a proxy function which does several things:
+//
+//  * Detects whether the mapToProps function being called depends on props, which
+//    is used by selectorFactory to decide if it should reinvoke on props changes.
+//
+//  * On first call, handles mapToProps if returns another function, and treats that
+//    new function as the true mapToProps for subsequent calls.
+//
+//  * On first call, verifies the first result is a plain object, in order to warn
+//    the developer that their mapToProps function is not returning a valid result.
+//
+
+export 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, undefined);
+    }; // allow detectFactoryAndVerify to get ownProps
+
+
+    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;
+  };
+}