fix engram rtk

2026-04-16 18:24:13 +02:00
parent a8dbb62b09
commit 0fc5392bd2
1030 changed files with 947923 additions and 3 deletions
--- a/frontend/node_modules/redux-thunk/LICENSE.md
+++ b/frontend/node_modules/redux-thunk/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present Dan Abramov
+
+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.
--- a/frontend/node_modules/redux-thunk/README.md
+++ b/frontend/node_modules/redux-thunk/README.md
@@ -0,0 +1,403 @@
+# Redux Thunk
+
+Thunk [middleware](https://redux.js.org/tutorials/fundamentals/part-4-store#middleware) for Redux. It allows writing functions with logic inside that can interact with a Redux store's `dispatch` and `getState` methods.
+
+For complete usage instructions and useful patterns, see the [Redux docs **Writing Logic with Thunks** page](https://redux.js.org/usage/writing-logic-thunks).
+
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/reduxjs/redux-thunk/test.yml?branch=master)
+[![npm version](https://img.shields.io/npm/v/redux-thunk.svg?style=flat-square)](https://www.npmjs.com/package/redux-thunk)
+[![npm downloads](https://img.shields.io/npm/dm/redux-thunk.svg?style=flat-square)](https://www.npmjs.com/package/redux-thunk)
+
+## Installation and Setup
+
+### Redux Toolkit
+
+If you're using [our official Redux Toolkit package](https://redux-toolkit.js.org) as recommended, there's nothing to install - RTK's `configureStore` API already adds the thunk middleware by default:
+
+```js
+import { configureStore } from '@reduxjs/toolkit'
+
+import todosReducer from './features/todos/todosSlice'
+import filtersReducer from './features/filters/filtersSlice'
+
+const store = configureStore({
+  reducer: {
+    todos: todosReducer,
+    filters: filtersReducer
+  }
+})
+
+// The thunk middleware was automatically added
+```
+
+### Manual Setup
+
+If you're using the basic Redux `createStore` API and need to set this up manually, first add the `redux-thunk` package:
+
+```sh
+npm install redux-thunk
+
+yarn add redux-thunk
+```
+
+The thunk middleware is the default export.
+
+<details>
+<summary><b>More Details: Importing the thunk middleware</b></summary>
+
+If you're using ES modules:
+
+```js
+import thunk from 'redux-thunk' // no changes here 😀
+```
+
+If you use Redux Thunk 2.x in a CommonJS environment,
+[don’t forget to add `.default` to your import](https://github.com/reduxjs/redux-thunk/releases/tag/v2.0.0):
+
+```diff
+- const thunk = require('redux-thunk')
+ const thunk = require('redux-thunk').default
+```
+
+Additionally, since 2.x, we also support a
+[UMD build](https://unpkg.com/redux-thunk/dist/redux-thunk.min.js) for use as a global script tag:
+
+```js
+const ReduxThunk = window.ReduxThunk
+```
+
+</details>
+
+Then, to enable Redux Thunk, use
+[`applyMiddleware()`](https://redux.js.org/api/applymiddleware):
+
+```js
+import { createStore, applyMiddleware } from 'redux'
+import thunk from 'redux-thunk'
+import rootReducer from './reducers/index'
+
+const store = createStore(rootReducer, applyMiddleware(thunk))
+```
+
+### Injecting a Custom Argument
+
+Since 2.1.0, Redux Thunk supports injecting a custom argument into the thunk middleware. This is typically useful for cases like using an API service layer that could be swapped out for a mock service in tests.
+
+For Redux Toolkit, the `getDefaultMiddleware` callback inside of `configureStore` lets you pass in a custom `extraArgument`:
+
+```js
+import { configureStore } from '@reduxjs/toolkit'
+import rootReducer from './reducer'
+import { myCustomApiService } from './api'
+
+const store = configureStore({
+  reducer: rootReducer,
+  middleware: getDefaultMiddleware =>
+    getDefaultMiddleware({
+      thunk: {
+        extraArgument: myCustomApiService
+      }
+    })
+})
+
+// later
+function fetchUser(id) {
+  // The `extraArgument` is the third arg for thunk functions
+  return (dispatch, getState, api) => {
+    // you can use api here
+  }
+}
+```
+
+If you need to pass in multiple values, combine them into a single object:
+
+```js
+const store = configureStore({
+  reducer: rootReducer,
+  middleware: getDefaultMiddleware =>
+    getDefaultMiddleware({
+      thunk: {
+        extraArgument: {
+          api: myCustomApiService,
+          otherValue: 42
+        }
+      }
+    })
+})
+
+// later
+function fetchUser(id) {
+  return (dispatch, getState, { api, otherValue }) => {
+    // you can use api and something else here
+  }
+}
+```
+
+If you're setting up the store by hand, the named export `withExtraArgument()` function should be used to generate the correct thunk middleware:
+
+```js
+const store = createStore(reducer, applyMiddleware(withExtraArgument(api)))
+```
+
+## Why Do I Need This?
+
+With a plain basic Redux store, you can only do simple synchronous updates by
+dispatching an action. Middleware extends the store's abilities, and lets you
+write async logic that interacts with the store.
+
+Thunks are the recommended middleware for basic Redux side effects logic,
+including complex synchronous logic that needs access to the store, and simple
+async logic like AJAX requests.
+
+For more details on why thunks are useful, see:
+
+- **Redux docs: Writing Logic with Thunks**  
+  https://redux.js.org/usage/writing-logic-thunks  
+  The official usage guide page on thunks. Covers why they exist, how the thunk middleware works, and useful patterns for using thunks.
+
+- **Stack Overflow: Dispatching Redux Actions with a Timeout**  
+  http://stackoverflow.com/questions/35411423/how-to-dispatch-a-redux-action-with-a-timeout/35415559#35415559  
+  Dan Abramov explains the basics of managing async behavior in Redux, walking
+  through a progressive series of approaches (inline async calls, async action
+  creators, thunk middleware).
+
+- **Stack Overflow: Why do we need middleware for async flow in Redux?**  
+  http://stackoverflow.com/questions/34570758/why-do-we-need-middleware-for-async-flow-in-redux/34599594#34599594  
+  Dan Abramov gives reasons for using thunks and async middleware, and some
+  useful patterns for using thunks.
+
+- **What the heck is a "thunk"?**  
+  https://daveceddia.com/what-is-a-thunk/  
+  A quick explanation for what the word "thunk" means in general, and for Redux
+  specifically.
+
+- **Thunks in Redux: The Basics**  
+  https://medium.com/fullstack-academy/thunks-in-redux-the-basics-85e538a3fe60  
+  A detailed look at what thunks are, what they solve, and how to use them.
+
+You may also want to read the
+**[Redux FAQ entry on choosing which async middleware to use](https://redux.js.org/faq/actions#what-async-middleware-should-i-use-how-do-you-decide-between-thunks-sagas-observables-or-something-else)**.
+
+While the thunk middleware is not directly included with the Redux core library,
+it is used by default in our
+**[`@reduxjs/toolkit` package](https://github.com/reduxjs/redux-toolkit)**.
+
+## Motivation
+
+Redux Thunk [middleware](https://redux.js.org/tutorials/fundamentals/part-4-store#middleware)
+allows you to write action creators that return a function instead of an action.
+The thunk can be used to delay the dispatch of an action, or to dispatch only if
+a certain condition is met. The inner function receives the store methods
+`dispatch` and `getState` as parameters.
+
+An action creator that returns a function to perform asynchronous dispatch:
+
+```js
+const INCREMENT_COUNTER = 'INCREMENT_COUNTER'
+
+function increment() {
+  return {
+    type: INCREMENT_COUNTER
+  }
+}
+
+function incrementAsync() {
+  return dispatch => {
+    setTimeout(() => {
+      // Yay! Can invoke sync or async actions with `dispatch`
+      dispatch(increment())
+    }, 1000)
+  }
+}
+```
+
+An action creator that returns a function to perform conditional dispatch:
+
+```js
+function incrementIfOdd() {
+  return (dispatch, getState) => {
+    const { counter } = getState()
+
+    if (counter % 2 === 0) {
+      return
+    }
+
+    dispatch(increment())
+  }
+}
+```
+
+## What’s a thunk?!
+
+A [thunk](https://en.wikipedia.org/wiki/Thunk) is a function that wraps an
+expression to delay its evaluation.
+
+```js
+// calculation of 1 + 2 is immediate
+// x === 3
+let x = 1 + 2
+
+// calculation of 1 + 2 is delayed
+// foo can be called later to perform the calculation
+// foo is a thunk!
+let foo = () => 1 + 2
+```
+
+The term [originated](https://en.wikipedia.org/wiki/Thunk#cite_note-1) as a
+humorous past-tense version of "think".
+
+## Composition
+
+Any return value from the inner function will be available as the return value
+of `dispatch` itself. This is convenient for orchestrating an asynchronous
+control flow with thunk action creators dispatching each other and returning
+Promises to wait for each other’s completion:
+
+```js
+import { createStore, applyMiddleware } from 'redux'
+import thunk from 'redux-thunk'
+import rootReducer from './reducers'
+
+// Note: this API requires redux@>=3.1.0
+const store = createStore(rootReducer, applyMiddleware(thunk))
+
+function fetchSecretSauce() {
+  return fetch('https://www.google.com/search?q=secret+sauce')
+}
+
+// These are the normal action creators you have seen so far.
+// The actions they return can be dispatched without any middleware.
+// However, they only express “facts” and not the “async flow”.
+
+function makeASandwich(forPerson, secretSauce) {
+  return {
+    type: 'MAKE_SANDWICH',
+    forPerson,
+    secretSauce
+  }
+}
+
+function apologize(fromPerson, toPerson, error) {
+  return {
+    type: 'APOLOGIZE',
+    fromPerson,
+    toPerson,
+    error
+  }
+}
+
+function withdrawMoney(amount) {
+  return {
+    type: 'WITHDRAW',
+    amount
+  }
+}
+
+// Even without middleware, you can dispatch an action:
+store.dispatch(withdrawMoney(100))
+
+// But what do you do when you need to start an asynchronous action,
+// such as an API call, or a router transition?
+
+// Meet thunks.
+// A thunk in this context is a function that can be dispatched to perform async
+// activity and can dispatch actions and read state.
+// This is an action creator that returns a thunk:
+function makeASandwichWithSecretSauce(forPerson) {
+  // We can invert control here by returning a function - the "thunk".
+  // When this function is passed to `dispatch`, the thunk middleware will intercept it,
+  // and call it with `dispatch` and `getState` as arguments.
+  // This gives the thunk function the ability to run some logic, and still interact with the store.
+  return function (dispatch) {
+    return fetchSecretSauce().then(
+      sauce => dispatch(makeASandwich(forPerson, sauce)),
+      error => dispatch(apologize('The Sandwich Shop', forPerson, error))
+    )
+  }
+}
+
+// Thunk middleware lets me dispatch thunk async actions
+// as if they were actions!
+
+store.dispatch(makeASandwichWithSecretSauce('Me'))
+
+// It even takes care to return the thunk’s return value
+// from the dispatch, so I can chain Promises as long as I return them.
+
+store.dispatch(makeASandwichWithSecretSauce('My partner')).then(() => {
+  console.log('Done!')
+})
+
+// In fact I can write action creators that dispatch
+// actions and async actions from other action creators,
+// and I can build my control flow with Promises.
+
+function makeSandwichesForEverybody() {
+  return function (dispatch, getState) {
+    if (!getState().sandwiches.isShopOpen) {
+      // You don’t have to return Promises, but it’s a handy convention
+      // so the caller can always call .then() on async dispatch result.
+
+      return Promise.resolve()
+    }
+
+    // We can dispatch both plain object actions and other thunks,
+    // which lets us compose the asynchronous actions in a single flow.
+
+    return dispatch(makeASandwichWithSecretSauce('My Grandma'))
+      .then(() =>
+        Promise.all([
+          dispatch(makeASandwichWithSecretSauce('Me')),
+          dispatch(makeASandwichWithSecretSauce('My wife'))
+        ])
+      )
+      .then(() => dispatch(makeASandwichWithSecretSauce('Our kids')))
+      .then(() =>
+        dispatch(
+          getState().myMoney > 42
+            ? withdrawMoney(42)
+            : apologize('Me', 'The Sandwich Shop')
+        )
+      )
+  }
+}
+
+// This is very useful for server side rendering, because I can wait
+// until data is available, then synchronously render the app.
+
+store
+  .dispatch(makeSandwichesForEverybody())
+  .then(() =>
+    response.send(ReactDOMServer.renderToString(<MyApp store={store} />))
+  )
+
+// I can also dispatch a thunk async action from a component
+// any time its props change to load the missing data.
+
+import { connect } from 'react-redux'
+import { Component } from 'react'
+
+class SandwichShop extends Component {
+  componentDidMount() {
+    this.props.dispatch(makeASandwichWithSecretSauce(this.props.forPerson))
+  }
+
+  componentDidUpdate(prevProps) {
+    if (prevProps.forPerson !== this.props.forPerson) {
+      this.props.dispatch(makeASandwichWithSecretSauce(this.props.forPerson))
+    }
+  }
+
+  render() {
+    return <p>{this.props.sandwiches.join('mustard')}</p>
+  }
+}
+
+export default connect(state => ({
+  sandwiches: state.sandwiches
+}))(SandwichShop)
+```
+
+## License
+
+MIT
--- a/frontend/node_modules/redux-thunk/dist/cjs/redux-thunk.cjs
+++ b/frontend/node_modules/redux-thunk/dist/cjs/redux-thunk.cjs
@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  thunk: () => thunk,
+  withExtraArgument: () => withExtraArgument
+});
+module.exports = __toCommonJS(src_exports);
+function createThunkMiddleware(extraArgument) {
+  const middleware = ({ dispatch, getState }) => (next) => (action) => {
+    if (typeof action === "function") {
+      return action(dispatch, getState, extraArgument);
+    }
+    return next(action);
+  };
+  return middleware;
+}
+var thunk = createThunkMiddleware();
+var withExtraArgument = createThunkMiddleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  thunk,
+  withExtraArgument
+});
--- a/frontend/node_modules/redux-thunk/dist/redux-thunk.d.ts
+++ b/frontend/node_modules/redux-thunk/dist/redux-thunk.d.ts
@@ -0,0 +1,60 @@
+import { Action, AnyAction, Middleware } from 'redux';
+
+/**
+ * The dispatch method as modified by React-Thunk; overloaded so that you can
+ * dispatch:
+ *   - standard (object) actions: `dispatch()` returns the action itself
+ *   - thunk actions: `dispatch()` returns the thunk's return value
+ *
+ * @template State The redux state
+ * @template ExtraThunkArg The extra argument passed to the inner function of
+ * thunks (if specified when setting up the Thunk middleware)
+ * @template BasicAction The (non-thunk) actions that can be dispatched.
+ */
+interface ThunkDispatch<State, ExtraThunkArg, BasicAction extends Action> {
+    /** Accepts a thunk function, runs it, and returns whatever the thunk itself returns */
+    <ReturnType>(thunkAction: ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>): ReturnType;
+    /** Accepts a standard action object, and returns that action object */
+    <Action extends BasicAction>(action: Action): Action;
+    /** A union of the other two overloads for TS inference purposes */
+    <ReturnType, Action extends BasicAction>(action: Action | ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>): Action | ReturnType;
+}
+/**
+ * A "thunk" action (a callback function that can be dispatched to the Redux
+ * store.)
+ *
+ * Also known as the "thunk inner function", when used with the typical pattern
+ * of an action creator function that returns a thunk action.
+ *
+ * @template ReturnType The return type of the thunk's inner function
+ * @template State The redux state
+ * @template ExtraThunkArg Optional extra argument passed to the inner function
+ * (if specified when setting up the Thunk middleware)
+ * @template BasicAction The (non-thunk) actions that can be dispatched.
+ */
+type ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction extends Action> = (dispatch: ThunkDispatch<State, ExtraThunkArg, BasicAction>, getState: () => State, extraArgument: ExtraThunkArg) => ReturnType;
+/**
+ * A generic type that takes a thunk action creator and returns a function
+ * signature which matches how it would appear after being processed using
+ * bindActionCreators(): a function that takes the arguments of the outer
+ * function, and returns the return type of the inner "thunk" function.
+ *
+ * @template ActionCreator Thunk action creator to be wrapped
+ */
+type ThunkActionDispatch<ActionCreator extends (...args: any[]) => ThunkAction<any, any, any, any>> = (...args: Parameters<ActionCreator>) => ReturnType<ReturnType<ActionCreator>>;
+/**
+ * @template State The redux state
+ * @template BasicAction The (non-thunk) actions that can be dispatched
+ * @template ExtraThunkArg An optional extra argument to pass to a thunk's
+ * inner function. (Only used if you call `withExtraArgument()`)
+ */
+type ThunkMiddleware<State = any, BasicAction extends Action = AnyAction, ExtraThunkArg = undefined> = Middleware<ThunkDispatch<State, ExtraThunkArg, BasicAction>, State, ThunkDispatch<State, ExtraThunkArg, BasicAction>>;
+
+/** A function that accepts a potential "extra argument" value to be injected later,
+ * and returns an instance of the thunk middleware that uses that value
+ */
+declare function createThunkMiddleware<State = any, BasicAction extends Action = AnyAction, ExtraThunkArg = undefined>(extraArgument?: ExtraThunkArg): ThunkMiddleware<State, BasicAction, ExtraThunkArg>;
+declare const thunk: ThunkMiddleware<any, AnyAction, undefined>;
+declare const withExtraArgument: typeof createThunkMiddleware;
+
+export { ThunkAction, ThunkActionDispatch, ThunkDispatch, ThunkMiddleware, thunk, withExtraArgument };
--- a/frontend/node_modules/redux-thunk/dist/redux-thunk.legacy-esm.js
+++ b/frontend/node_modules/redux-thunk/dist/redux-thunk.legacy-esm.js
@@ -0,0 +1,16 @@
+// src/index.ts
+function createThunkMiddleware(extraArgument) {
+  const middleware = ({ dispatch, getState }) => (next) => (action) => {
+    if (typeof action === "function") {
+      return action(dispatch, getState, extraArgument);
+    }
+    return next(action);
+  };
+  return middleware;
+}
+var thunk = createThunkMiddleware();
+var withExtraArgument = createThunkMiddleware;
+export {
+  thunk,
+  withExtraArgument
+};
--- a/frontend/node_modules/redux-thunk/dist/redux-thunk.mjs
+++ b/frontend/node_modules/redux-thunk/dist/redux-thunk.mjs
@@ -0,0 +1,16 @@
+// src/index.ts
+function createThunkMiddleware(extraArgument) {
+  const middleware = ({ dispatch, getState }) => (next) => (action) => {
+    if (typeof action === "function") {
+      return action(dispatch, getState, extraArgument);
+    }
+    return next(action);
+  };
+  return middleware;
+}
+var thunk = createThunkMiddleware();
+var withExtraArgument = createThunkMiddleware;
+export {
+  thunk,
+  withExtraArgument
+};
--- a/frontend/node_modules/redux-thunk/package.json
+++ b/frontend/node_modules/redux-thunk/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "redux-thunk",
+  "version": "3.1.0",
+  "license": "MIT",
+  "description": "Thunk middleware for Redux.",
+  "repository": "github:reduxjs/redux-thunk",
+  "bugs": "https://github.com/reduxjs/redux-thunk/issues",
+  "homepage": "https://github.com/reduxjs/redux-thunk",
+  "keywords": [
+    "redux",
+    "thunk",
+    "middleware",
+    "redux-middleware",
+    "flux"
+  ],
+  "author": "Dan Abramov <dan.abramov@me.com>",
+  "main": "dist/cjs/redux-thunk.cjs",
+  "module": "dist/redux-thunk.legacy-esm.js",
+  "types": "dist/redux-thunk.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/redux-thunk.d.ts",
+      "import": "./dist/redux-thunk.mjs",
+      "default": "./dist/cjs/redux-thunk.cjs"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "extend-redux.d.ts"
+  ],
+  "scripts": {
+    "clean": "rimraf lib dist es",
+    "prepublishOnly": "yarn clean && yarn lint && yarn test && yarn build",
+    "format": "prettier --write \"{src,test,typescript_test}/**/*.{js,ts}\"",
+    "format:check": "prettier --check \"{src,test,typescript_test}/**/*.{js,ts}\"",
+    "lint": "eslint \"{src,test,typescript_test}/**/*.{js,ts}\"",
+    "test": "vitest run",
+    "test:cov": "vitest run --coverage",
+    "test:typescript": "tsc --noEmit -p typescript_test/tsconfig.json",
+    "build": "tsup",
+    "prepack": "yarn build"
+  },
+  "peerDependencies": {
+    "redux": "^5.0.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.1.0",
+    "@typescript-eslint/parser": "^5.1.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "prettier": "^2.4.1",
+    "redux": "^5",
+    "rimraf": "^3.0.2",
+    "tsup": "7.0.0",
+    "typescript": "^5.0",
+    "vitest": "^0.32.0"
+  }
+}
--- a/frontend/node_modules/redux-thunk/src/index.ts
+++ b/frontend/node_modules/redux-thunk/src/index.ts
@@ -0,0 +1,43 @@
+import type { Action, AnyAction } from 'redux'
+
+import type { ThunkMiddleware } from './types'
+
+export type {
+  ThunkAction,
+  ThunkDispatch,
+  ThunkActionDispatch,
+  ThunkMiddleware
+} from './types'
+
+/** A function that accepts a potential "extra argument" value to be injected later,
+ * and returns an instance of the thunk middleware that uses that value
+ */
+function createThunkMiddleware<
+  State = any,
+  BasicAction extends Action = AnyAction,
+  ExtraThunkArg = undefined
+>(extraArgument?: ExtraThunkArg) {
+  // Standard Redux middleware definition pattern:
+  // See: https://redux.js.org/tutorials/fundamentals/part-4-store#writing-custom-middleware
+  const middleware: ThunkMiddleware<State, BasicAction, ExtraThunkArg> =
+    ({ dispatch, getState }) =>
+    next =>
+    action => {
+      // The thunk middleware looks for any functions that were passed to `store.dispatch`.
+      // If this "action" is really a function, call it and return the result.
+      if (typeof action === 'function') {
+        // Inject the store's `dispatch` and `getState` methods, as well as any "extra arg"
+        return action(dispatch, getState, extraArgument)
+      }
+
+      // Otherwise, pass the action down the middleware chain as usual
+      return next(action)
+    }
+  return middleware
+}
+
+export const thunk = createThunkMiddleware()
+
+// Export the factory function so users can create a customized version
+// with whatever "extra arg" they want to inject into their thunks
+export const withExtraArgument = createThunkMiddleware
--- a/frontend/node_modules/redux-thunk/src/types.ts
+++ b/frontend/node_modules/redux-thunk/src/types.ts
@@ -0,0 +1,91 @@
+import type { Action, AnyAction, Middleware } from 'redux'
+
+/**
+ * The dispatch method as modified by React-Thunk; overloaded so that you can
+ * dispatch:
+ *   - standard (object) actions: `dispatch()` returns the action itself
+ *   - thunk actions: `dispatch()` returns the thunk's return value
+ *
+ * @template State The redux state
+ * @template ExtraThunkArg The extra argument passed to the inner function of
+ * thunks (if specified when setting up the Thunk middleware)
+ * @template BasicAction The (non-thunk) actions that can be dispatched.
+ */
+export interface ThunkDispatch<
+  State,
+  ExtraThunkArg,
+  BasicAction extends Action
+> {
+  // When the thunk middleware is added, `store.dispatch` now has three overloads (NOTE: the order here matters for correct behavior and is very fragile - do not reorder these!):
+
+  // 1) The specific thunk function overload
+  /** Accepts a thunk function, runs it, and returns whatever the thunk itself returns */
+  <ReturnType>(
+    thunkAction: ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>
+  ): ReturnType
+
+  // 2) The base overload.
+  /** Accepts a standard action object, and returns that action object */
+  <Action extends BasicAction>(action: Action): Action
+
+  // 3) A union of the other two overloads. This overload exists to work around a problem
+  //   with TS inference ( see https://github.com/microsoft/TypeScript/issues/14107 )
+  /** A union of the other two overloads for TS inference purposes */
+  <ReturnType, Action extends BasicAction>(
+    action: Action | ThunkAction<ReturnType, State, ExtraThunkArg, BasicAction>
+  ): Action | ReturnType
+}
+
+/**
+ * A "thunk" action (a callback function that can be dispatched to the Redux
+ * store.)
+ *
+ * Also known as the "thunk inner function", when used with the typical pattern
+ * of an action creator function that returns a thunk action.
+ *
+ * @template ReturnType The return type of the thunk's inner function
+ * @template State The redux state
+ * @template ExtraThunkArg Optional extra argument passed to the inner function
+ * (if specified when setting up the Thunk middleware)
+ * @template BasicAction The (non-thunk) actions that can be dispatched.
+ */
+export type ThunkAction<
+  ReturnType,
+  State,
+  ExtraThunkArg,
+  BasicAction extends Action
+> = (
+  dispatch: ThunkDispatch<State, ExtraThunkArg, BasicAction>,
+  getState: () => State,
+  extraArgument: ExtraThunkArg
+) => ReturnType
+
+/**
+ * A generic type that takes a thunk action creator and returns a function
+ * signature which matches how it would appear after being processed using
+ * bindActionCreators(): a function that takes the arguments of the outer
+ * function, and returns the return type of the inner "thunk" function.
+ *
+ * @template ActionCreator Thunk action creator to be wrapped
+ */
+export type ThunkActionDispatch<
+  ActionCreator extends (...args: any[]) => ThunkAction<any, any, any, any>
+> = (
+  ...args: Parameters<ActionCreator>
+) => ReturnType<ReturnType<ActionCreator>>
+
+/**
+ * @template State The redux state
+ * @template BasicAction The (non-thunk) actions that can be dispatched
+ * @template ExtraThunkArg An optional extra argument to pass to a thunk's
+ * inner function. (Only used if you call `withExtraArgument()`)
+ */
+export type ThunkMiddleware<
+  State = any,
+  BasicAction extends Action = AnyAction,
+  ExtraThunkArg = undefined
+> = Middleware<
+  ThunkDispatch<State, ExtraThunkArg, BasicAction>,
+  State,
+  ThunkDispatch<State, ExtraThunkArg, BasicAction>
+>