isomorfeus-redux 4.2.0 → 22.9.0.rc1

data/node_modules/redux/src/createStore.js

@@ -1,347 +0,0 @@
-import $$observable from './utils/symbol-observable'
-
-import ActionTypes from './utils/actionTypes'
-import isPlainObject from './utils/isPlainObject'
-import { kindOf } from './utils/kindOf'
-
-/**
- * @deprecated
- *
- * **We recommend using the `configureStore` method
- * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
- *
- * Redux Toolkit is our recommended approach for writing Redux logic today,
- * including store setup, reducers, data fetching, and more.
- *
- * **For more details, please read this Redux docs page:**
- * **https://redux.js.org/introduction/why-rtk-is-redux-today**
- *
- * `configureStore` from Redux Toolkit is an improved version of `createStore` that
- * simplifies setup and helps avoid common bugs.
- *
- * You should not be using the `redux` core package by itself today, except for learning purposes.
- * The `createStore` method from the core `redux` package will not be removed, but we encourage
- * all users to migrate to using Redux Toolkit for all Redux code.
- *
- * If you want to use `createStore` without this visual deprecation warning, use
- * the `legacy_createStore` import instead:
- *
- * `import { legacy_createStore as createStore} from 'redux'`
- *
- */
-export function createStore(reducer, preloadedState, enhancer) {
-  if (
-    (typeof preloadedState === 'function' && typeof enhancer === 'function') ||
-    (typeof enhancer === 'function' && typeof arguments[3] === 'function')
-  ) {
-    throw new Error(
-      'It looks like you are passing several store enhancers to ' +
-        'createStore(). This is not supported. Instead, compose them ' +
-        'together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.'
-    )
-  }
-
-  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
-    enhancer = preloadedState
-    preloadedState = undefined
-  }
-
-  if (typeof enhancer !== 'undefined') {
-    if (typeof enhancer !== 'function') {
-      throw new Error(
-        `Expected the enhancer to be a function. Instead, received: '${kindOf(
-          enhancer
-        )}'`
-      )
-    }
-
-    return enhancer(createStore)(reducer, preloadedState)
-  }
-
-  if (typeof reducer !== 'function') {
-    throw new Error(
-      `Expected the root reducer to be a function. Instead, received: '${kindOf(
-        reducer
-      )}'`
-    )
-  }
-
-  let currentReducer = reducer
-  let currentState = preloadedState
-  let currentListeners = []
-  let nextListeners = currentListeners
-  let isDispatching = false
-
-  /**
-   * This makes a shallow copy of currentListeners so we can use
-   * nextListeners as a temporary list while dispatching.
-   *
-   * This prevents any bugs around consumers calling
-   * subscribe/unsubscribe in the middle of a dispatch.
-   */
-  function ensureCanMutateNextListeners() {
-    if (nextListeners === currentListeners) {
-      nextListeners = currentListeners.slice()
-    }
-  }
-
-  /**
-   * Reads the state tree managed by the store.
-   *
-   * @returns {any} The current state tree of your application.
-   */
-  function getState() {
-    if (isDispatching) {
-      throw new Error(
-        'You may not call store.getState() while the reducer is executing. ' +
-          'The reducer has already received the state as an argument. ' +
-          'Pass it down from the top reducer instead of reading it from the store.'
-      )
-    }
-
-    return currentState
-  }
-
-  /**
-   * Adds a change listener. It will be called any time an action is dispatched,
-   * and some part of the state tree may potentially have changed. You may then
-   * call `getState()` to read the current state tree inside the callback.
-   *
-   * You may call `dispatch()` from a change listener, with the following
-   * caveats:
-   *
-   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
-   * If you subscribe or unsubscribe while the listeners are being invoked, this
-   * will not have any effect on the `dispatch()` that is currently in progress.
-   * However, the next `dispatch()` call, whether nested or not, will use a more
-   * recent snapshot of the subscription list.
-   *
-   * 2. The listener should not expect to see all state changes, as the state
-   * might have been updated multiple times during a nested `dispatch()` before
-   * the listener is called. It is, however, guaranteed that all subscribers
-   * registered before the `dispatch()` started will be called with the latest
-   * state by the time it exits.
-   *
-   * @param {Function} listener A callback to be invoked on every dispatch.
-   * @returns {Function} A function to remove this change listener.
-   */
-  function subscribe(listener) {
-    if (typeof listener !== 'function') {
-      throw new Error(
-        `Expected the listener to be a function. Instead, received: '${kindOf(
-          listener
-        )}'`
-      )
-    }
-
-    if (isDispatching) {
-      throw new Error(
-        'You may not call store.subscribe() while the reducer is executing. ' +
-          'If you would like to be notified after the store has been updated, subscribe from a ' +
-          'component and invoke store.getState() in the callback to access the latest state. ' +
-          'See https://redux.js.org/api/store#subscribelistener for more details.'
-      )
-    }
-
-    let isSubscribed = true
-
-    ensureCanMutateNextListeners()
-    nextListeners.push(listener)
-
-    return function unsubscribe() {
-      if (!isSubscribed) {
-        return
-      }
-
-      if (isDispatching) {
-        throw new Error(
-          'You may not unsubscribe from a store listener while the reducer is executing. ' +
-            'See https://redux.js.org/api/store#subscribelistener for more details.'
-        )
-      }
-
-      isSubscribed = false
-
-      ensureCanMutateNextListeners()
-      const index = nextListeners.indexOf(listener)
-      nextListeners.splice(index, 1)
-      currentListeners = null
-    }
-  }
-
-  /**
-   * Dispatches an action. It is the only way to trigger a state change.
-   *
-   * The `reducer` function, used to create the store, will be called with the
-   * current state tree and the given `action`. Its return value will
-   * be considered the **next** state of the tree, and the change listeners
-   * will be notified.
-   *
-   * The base implementation only supports plain object actions. If you want to
-   * dispatch a Promise, an Observable, a thunk, or something else, you need to
-   * wrap your store creating function into the corresponding middleware. For
-   * example, see the documentation for the `redux-thunk` package. Even the
-   * middleware will eventually dispatch plain object actions using this method.
-   *
-   * @param {Object} action A plain object representing “what changed”. It is
-   * a good idea to keep actions serializable so you can record and replay user
-   * sessions, or use the time travelling `redux-devtools`. An action must have
-   * a `type` property which may not be `undefined`. It is a good idea to use
-   * string constants for action types.
-   *
-   * @returns {Object} For convenience, the same action object you dispatched.
-   *
-   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
-   * return something else (for example, a Promise you can await).
-   */
-  function dispatch(action) {
-    if (!isPlainObject(action)) {
-      throw new Error(
-        `Actions must be plain objects. Instead, the actual type was: '${kindOf(
-          action
-        )}'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.`
-      )
-    }
-
-    if (typeof action.type === 'undefined') {
-      throw new Error(
-        'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.'
-      )
-    }
-
-    if (isDispatching) {
-      throw new Error('Reducers may not dispatch actions.')
-    }
-
-    try {
-      isDispatching = true
-      currentState = currentReducer(currentState, action)
-    } finally {
-      isDispatching = false
-    }
-
-    const listeners = (currentListeners = nextListeners)
-    for (let i = 0; i < listeners.length; i++) {
-      const listener = listeners[i]
-      listener()
-    }
-
-    return action
-  }
-
-  /**
-   * Replaces the reducer currently used by the store to calculate the state.
-   *
-   * You might need this if your app implements code splitting and you want to
-   * load some of the reducers dynamically. You might also need this if you
-   * implement a hot reloading mechanism for Redux.
-   *
-   * @param {Function} nextReducer The reducer for the store to use instead.
-   * @returns {void}
-   */
-  function replaceReducer(nextReducer) {
-    if (typeof nextReducer !== 'function') {
-      throw new Error(
-        `Expected the nextReducer to be a function. Instead, received: '${kindOf(
-          nextReducer
-        )}`
-      )
-    }
-
-    currentReducer = nextReducer
-
-    // This action has a similiar effect to ActionTypes.INIT.
-    // Any reducers that existed in both the new and old rootReducer
-    // will receive the previous state. This effectively populates
-    // the new state tree with any relevant data from the old one.
-    dispatch({ type: ActionTypes.REPLACE })
-  }
-
-  /**
-   * Interoperability point for observable/reactive libraries.
-   * @returns {observable} A minimal observable of state changes.
-   * For more information, see the observable proposal:
-   * https://github.com/tc39/proposal-observable
-   */
-  function observable() {
-    const outerSubscribe = subscribe
-    return {
-      /**
-       * The minimal observable subscription method.
-       * @param {Object} observer Any object that can be used as an observer.
-       * The observer object should have a `next` method.
-       * @returns {subscription} An object with an `unsubscribe` method that can
-       * be used to unsubscribe the observable from the store, and prevent further
-       * emission of values from the observable.
-       */
-      subscribe(observer) {
-        if (typeof observer !== 'object' || observer === null) {
-          throw new TypeError(
-            `Expected the observer to be an object. Instead, received: '${kindOf(
-              observer
-            )}'`
-          )
-        }
-
-        function observeState() {
-          if (observer.next) {
-            observer.next(getState())
-          }
-        }
-
-        observeState()
-        const unsubscribe = outerSubscribe(observeState)
-        return { unsubscribe }
-      },
-
-      [$$observable]() {
-        return this
-      },
-    }
-  }
-
-  // When a store is created, an "INIT" action is dispatched so that every
-  // reducer returns their initial state. This effectively populates
-  // the initial state tree.
-  dispatch({ type: ActionTypes.INIT })
-
-  return {
-    dispatch,
-    subscribe,
-    getState,
-    replaceReducer,
-    [$$observable]: observable,
-  }
-}
-
-/**
- * Creates a Redux store that holds the state tree.
- *
- * **We recommend using `configureStore` from the
- * `@reduxjs/toolkit` package**, which replaces `createStore`:
- * **https://redux.js.org/introduction/why-rtk-is-redux-today**
- *
- * The only way to change the data in the store is to call `dispatch()` on it.
- *
- * There should only be a single store in your app. To specify how different
- * parts of the state tree respond to actions, you may combine several reducers
- * into a single reducer function by using `combineReducers`.
- *
- * @param {Function} reducer A function that returns the next state tree, given
- * the current state tree and the action to handle.
- *
- * @param {any} [preloadedState] The initial state. You may optionally specify it
- * to hydrate the state from the server in universal apps, or to restore a
- * previously serialized user session.
- * If you use `combineReducers` to produce the root reducer function, this must be
- * an object with the same shape as `combineReducers` keys.
- *
- * @param {Function} [enhancer] The store enhancer. You may optionally specify it
- * to enhance the store with third-party capabilities such as middleware,
- * time travel, persistence, etc. The only store enhancer that ships with Redux
- * is `applyMiddleware()`.
- *
- * @returns {Store} A Redux store that lets you read the state, dispatch actions
- * and subscribe to changes.
- */
-export const legacy_createStore = createStore

data/node_modules/redux/src/index.js

@@ -1,37 +0,0 @@
-import { createStore, legacy_createStore } from './createStore'
-import combineReducers from './combineReducers'
-import bindActionCreators from './bindActionCreators'
-import applyMiddleware from './applyMiddleware'
-import compose from './compose'
-import warning from './utils/warning'
-import __DO_NOT_USE__ActionTypes from './utils/actionTypes'
-
-/*
- * This is a dummy function to check if the function name has been altered by minification.
- * If the function has been minified and NODE_ENV !== 'production', warn the user.
- */
-function isCrushed() {}
-
-if (
-  process.env.NODE_ENV !== 'production' &&
-  typeof isCrushed.name === 'string' &&
-  isCrushed.name !== 'isCrushed'
-) {
-  warning(
-    'You are currently using minified code outside of NODE_ENV === "production". ' +
-      'This means that you are running a slower development build of Redux. ' +
-      'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' +
-      'or setting mode to production in webpack (https://webpack.js.org/concepts/mode/) ' +
-      'to ensure you have the correct code for your production build.'
-  )
-}
-
-export {
-  createStore,
-  legacy_createStore,
-  combineReducers,
-  bindActionCreators,
-  applyMiddleware,
-  compose,
-  __DO_NOT_USE__ActionTypes,
-}

data/node_modules/redux/src/utils/actionTypes.js

@@ -1,17 +0,0 @@
-/**
- * These are private action types reserved by Redux.
- * For any unknown actions, you must return the current state.
- * If the current state is undefined, you must return the initial state.
- * Do not reference these action types directly in your code.
- */
-
-const randomString = () =>
-  Math.random().toString(36).substring(7).split('').join('.')
-
-const ActionTypes = {
-  INIT: `@@redux/INIT${randomString()}`,
-  REPLACE: `@@redux/REPLACE${randomString()}`,
-  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`,
-}
-
-export default ActionTypes

data/node_modules/redux/src/utils/formatProdErrorMessage.js

@@ -1,15 +0,0 @@
-/**
- * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
- *
- * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
- * during build.
- * @param {number} code
- */
-function formatProdErrorMessage(code) {
-  return (
-    `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or ` +
-    'use the non-minified dev environment for full errors. '
-  )
-}
-
-export default formatProdErrorMessage

data/node_modules/redux/src/utils/isPlainObject.js

@@ -1,14 +0,0 @@
-/**
- * @param {any} obj The object to inspect.
- * @returns {boolean} True if the argument appears to be a plain object.
- */
-export default function isPlainObject(obj) {
-  if (typeof obj !== 'object' || obj === null) return false
-
-  let proto = obj
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto)
-  }
-
-  return Object.getPrototypeOf(obj) === proto
-}

data/node_modules/redux/src/utils/kindOf.js

@@ -1,70 +0,0 @@
-// Inlined / shortened version of `kindOf` from https://github.com/jonschlinkert/kind-of
-function miniKindOf(val) {
-  if (val === void 0) return 'undefined'
-  if (val === null) return 'null'
-
-  const type = typeof val
-  switch (type) {
-    case 'boolean':
-    case 'string':
-    case 'number':
-    case 'symbol':
-    case 'function': {
-      return type
-    }
-    default:
-      break
-  }
-
-  if (Array.isArray(val)) return 'array'
-  if (isDate(val)) return 'date'
-  if (isError(val)) return 'error'
-
-  const constructorName = ctorName(val)
-  switch (constructorName) {
-    case 'Symbol':
-    case 'Promise':
-    case 'WeakMap':
-    case 'WeakSet':
-    case 'Map':
-    case 'Set':
-      return constructorName
-    default:
-      break
-  }
-
-  // other
-  return type.slice(8, -1).toLowerCase().replace(/\s/g, '')
-}
-
-function ctorName(val) {
-  return typeof val.constructor === 'function' ? val.constructor.name : null
-}
-
-function isError(val) {
-  return (
-    val instanceof Error ||
-    (typeof val.message === 'string' &&
-      val.constructor &&
-      typeof val.constructor.stackTraceLimit === 'number')
-  )
-}
-
-function isDate(val) {
-  if (val instanceof Date) return true
-  return (
-    typeof val.toDateString === 'function' &&
-    typeof val.getDate === 'function' &&
-    typeof val.setDate === 'function'
-  )
-}
-
-export function kindOf(val) {
-  let typeOfVal = typeof val
-
-  if (process.env.NODE_ENV !== 'production') {
-    typeOfVal = miniKindOf(val)
-  }
-
-  return typeOfVal
-}

data/node_modules/redux/src/utils/symbol-observable.js

@@ -1,3 +0,0 @@
-// Inlined version of the `symbol-observable` polyfill
-export default (() =>
-  (typeof Symbol === 'function' && Symbol.observable) || '@@observable')()

data/node_modules/redux/src/utils/warning.js

@@ -1,19 +0,0 @@
-/**
- * Prints a warning in the console if it exists.
- *
- * @param {String} message The warning message.
- * @returns {void}
- */
-export default function warning(message) {
-  /* eslint-disable no-console */
-  if (typeof console !== 'undefined' && typeof console.error === 'function') {
-    console.error(message)
-  }
-  /* eslint-enable no-console */
-  try {
-    // This error was thrown as a convenience so that if you enable
-    // "break on all exceptions" in your console,
-    // it would pause the execution at this line.
-    throw new Error(message)
-  } catch (e) {} // eslint-disable-line no-empty
-}

data/node_modules/regenerator-runtime/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2014-present, Facebook, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/node_modules/regenerator-runtime/README.md

@@ -1,31 +0,0 @@
-# regenerator-runtime
-
-Standalone runtime for
-[Regenerator](https://github.com/facebook/regenerator)-compiled generator
-and `async` functions.
-
-To import the runtime as a module (recommended), either of the following
-import styles will work:
-```js
-// CommonJS
-const regeneratorRuntime = require("regenerator-runtime");
-
-// ECMAScript 2015
-import regeneratorRuntime from "regenerator-runtime";
-```
-
-To ensure that `regeneratorRuntime` is defined globally, either of the
-following styles will work:
-```js
-// CommonJS
-require("regenerator-runtime/runtime");
-
-// ECMAScript 2015
-import "regenerator-runtime/runtime.js";
-```
-
-To get the absolute file system path of `runtime.js`, evaluate the
-following expression:
-```js
-require("regenerator-runtime/path").path
-```

data/node_modules/regenerator-runtime/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "regenerator-runtime",
-  "author": "Ben Newman <bn@cs.stanford.edu>",
-  "description": "Runtime for Regenerator-compiled generator and async functions.",
-  "version": "0.13.9",
-  "main": "runtime.js",
-  "keywords": [
-    "regenerator",
-    "runtime",
-    "generator",
-    "async"
-  ],
-  "sideEffects": true,
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/facebook/regenerator/tree/master/packages/runtime"
-  },
-  "license": "MIT"
-}

data/node_modules/regenerator-runtime/path.js

@@ -1,11 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-exports.path = require("path").join(
-  __dirname,
-  "runtime.js"
-);