@octanejs/redux-toolkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dominic Gannaway
+
+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.

package/README.md

@@ -0,0 +1,59 @@
+# @octanejs/redux-toolkit
+
+[Redux Toolkit](https://redux-toolkit.js.org) and RTK Query for the
+[octane](https://github.com/octanejs/octane) UI framework.
+
+Redux Toolkit's store, reducer, middleware, selector, and RTK Query cache core
+are framework-agnostic, so this package re-exports the real
+`@reduxjs/toolkit@2.12.0` implementation. The React-specific RTK Query hooks,
+`ApiProvider`, and dynamic-middleware dispatch-hook factory are ported onto
+octane and `@octanejs/redux`.
+
+Imports migrate by changing only the package name:
+
+```ts
+// before
+import { configureStore, createSlice } from '@reduxjs/toolkit';
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';
+
+// after
+import { configureStore, createSlice } from '@octanejs/redux-toolkit';
+import { createApi, fetchBaseQuery } from '@octanejs/redux-toolkit/query/react';
+```
+
+The `/react` compatibility subpaths retain their upstream names even though
+their implementation is Octane-backed. All four upstream entry points exist:
+
+- `@octanejs/redux-toolkit`
+- `@octanejs/redux-toolkit/react`
+- `@octanejs/redux-toolkit/query`
+- `@octanejs/redux-toolkit/query/react`
+
+## RTK Query
+
+```tsrx
+import { ApiProvider } from '@octanejs/redux-toolkit/query/react';
+import { api } from './api';
+
+function Post(props) @{
+	const result = api.useGetPostQuery(props.id);
+	@if (result.isLoading) { <p>Loading…</p> }
+	@else if (result.isError) { <p>Failed</p> }
+	@else { <p>{result.data.title as string}</p> }
+}
+
+function App() @{
+	<ApiProvider api={api}>
+		<Post id={1} />
+	</ApiProvider>
+}
+```
+
+For an existing Redux store, configure `api.reducer` and `api.middleware` in
+the normal way and use `Provider` from `@octanejs/redux`.
+
+## Status
+
+Current scope, known divergences, and verification status are tracked in the
+generated [bindings status table](../../docs/bindings-status.md), sourced from
+this package's [`status.json`](./status.json).

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@octanejs/redux-toolkit",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "description": "Redux Toolkit for the octane renderer — reuses Redux Toolkit and RTK Query core unchanged and ports the React hook adapters onto octane.",
+  "author": {
+    "name": "Dominic Gannaway",
+    "email": "dg@domgan.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/octanejs/octane.git",
+    "directory": "packages/redux-toolkit"
+  },
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./react": "./src/react/index.ts",
+    "./query": "./src/query/index.ts",
+    "./query/react": "./src/query/react/index.ts"
+  },
+  "dependencies": {
+    "@reduxjs/toolkit": "^2.9.0",
+    "redux": "^5.0.1",
+    "reselect": "5.2.0",
+    "@octanejs/redux": "0.1.2"
+  },
+  "peerDependencies": {
+    "octane": "0.1.5"
+  },
+  "devDependencies": {
+    "@tsrx/react": "^0.2.37",
+    "esbuild": "^0.28.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-redux": "9.3.0",
+    "vitest": "^4.1.9",
+    "octane": "0.1.5"
+  },
+  "scripts": {
+    "test": "vitest run --root ../.. --project redux-toolkit --project redux-toolkit-ssr"
+  }
+}

package/src/dynamicMiddleware/react.ts

@@ -0,0 +1,97 @@
+// Port of @reduxjs/toolkit@2.12.0 dynamicMiddleware/react. The middleware core
+// is reused verbatim; only the dispatch-hook factory swaps react-redux for the
+// octane binding.
+import type {
+	DynamicMiddlewareInstance,
+	GetDispatch,
+	GetState,
+	MiddlewareApiConfig,
+	TSHelpersExtractDispatchExtensions,
+} from '@reduxjs/toolkit';
+import { createDynamicMiddleware as createCoreDynamicMiddleware } from '@reduxjs/toolkit';
+import type { Context } from 'octane';
+import type { ReactReduxContextValue } from '@octanejs/redux';
+import {
+	createDispatchHook,
+	ReactReduxContext,
+	useDispatch as useDefaultDispatch,
+} from '@octanejs/redux';
+import type { Action, Dispatch, Middleware, UnknownAction } from 'redux';
+
+export type UseDispatchWithMiddlewareHook<
+	Middlewares extends Middleware<any, State, DispatchType>[] = [],
+	State = any,
+	DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;
+
+export type CreateDispatchWithMiddlewareHook<
+	State = any,
+	DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+> = {
+	<
+		Middlewares extends [
+			Middleware<any, State, DispatchType>,
+			...Middleware<any, State, DispatchType>[],
+		],
+	>(
+		...middlewares: Middlewares
+	): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;
+	withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<
+		GetState<MiddlewareConfig>,
+		GetDispatch<MiddlewareConfig>
+	>;
+};
+
+type ActionFromDispatch<DispatchType extends Dispatch<Action>> =
+	DispatchType extends Dispatch<infer DispatchedAction> ? DispatchedAction : never;
+
+type OctaneDynamicMiddlewareInstance<
+	State = any,
+	DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+> = DynamicMiddlewareInstance<State, DispatchType> & {
+	createDispatchWithMiddlewareHookFactory: (
+		context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>,
+	) => CreateDispatchWithMiddlewareHook<State, DispatchType>;
+	createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;
+};
+
+export const createDynamicMiddleware = <
+	State = any,
+	DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+>(): OctaneDynamicMiddlewareInstance<State, DispatchType> => {
+	const instance = createCoreDynamicMiddleware<State, DispatchType>();
+	const createDispatchWithMiddlewareHookFactory = (
+		context: Context<ReactReduxContextValue<
+			State,
+			ActionFromDispatch<DispatchType>
+		> | null> = ReactReduxContext as Context<ReactReduxContextValue<
+			State,
+			ActionFromDispatch<DispatchType>
+		> | null>,
+	) => {
+		const useDispatch =
+			context === ReactReduxContext
+				? useDefaultDispatch
+				: createDispatchHook<State, ActionFromDispatch<DispatchType>>(context as any);
+
+		function createDispatchWithMiddlewareHook<
+			Middlewares extends Middleware<any, State, DispatchType>[],
+		>(...middlewares: Middlewares) {
+			instance.addMiddleware(...middlewares);
+			return useDispatch;
+		}
+		createDispatchWithMiddlewareHook.withTypes = () => createDispatchWithMiddlewareHook;
+		return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<
+			State,
+			DispatchType
+		>;
+	};
+
+	const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();
+
+	return {
+		...instance,
+		createDispatchWithMiddlewareHookFactory,
+		createDispatchWithMiddlewareHook,
+	};
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+// Redux Toolkit's root entry is framework-agnostic. Keep the real upstream
+// implementation and its full runtime/type surface.
+export * from '@reduxjs/toolkit';

package/src/query/index.ts

@@ -0,0 +1,3 @@
+// RTK Query's core entry is UI-agnostic. The generated octane hooks live at
+// the compatibility subpath `@octanejs/redux-toolkit/query/react`.
+export * from '@reduxjs/toolkit/query';

package/src/query/react/ApiProvider.tsrx

@@ -0,0 +1,32 @@
+// Port of RTK Query's ApiProvider. It owns an isolated Toolkit store and uses
+// @octanejs/redux's Provider; query hooks can also use a caller-supplied context.
+import { useContext, useEffect, useState } from 'octane';
+import { configureStore } from '@reduxjs/toolkit';
+import { Provider, ReactReduxContext } from '@octanejs/redux';
+import { setupListeners } from '@reduxjs/toolkit/query';
+
+export function ApiProvider(props) @{
+	const context = props.context || ReactReduxContext;
+	const existingContext = useContext(context);
+	if (existingContext) {
+		throw new Error('Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.');
+	}
+
+	const [store] = useState(
+		() => configureStore({
+			reducer: {
+				[props.api.reducerPath]: props.api.reducer,
+			},
+			middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(props.api.middleware),
+		}),
+	);
+
+	useEffect(
+		() => props.setupListeners === false
+			? undefined
+			: setupListeners(store.dispatch, props.setupListeners),
+		[props.setupListeners, store.dispatch],
+	);
+
+	<Provider store={store} context={context}>{props.children}</Provider>
+}

package/src/query/react/ApiProvider.tsrx.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from 'octane';
+import type { ReactReduxContextValue } from '@octanejs/redux';
+import type { Api, setupListeners } from '@reduxjs/toolkit/query';
+
+export declare function ApiProvider(props: {
+	children?: unknown;
+	api: Api<any, {}, any, any>;
+	setupListeners?: Parameters<typeof setupListeners>[1] | false;
+	context?: Context<ReactReduxContextValue | null>;
+}): unknown;