@griddo/ax 12.6.1 → 12.6.2

package/config/griddo-config/index.js

@@ -87,7 +87,6 @@ const griddoAxAliases = {
 	"@ax/routes": path.resolve(__dirname, "../../src/routes"),
 	"@ax/types": path.resolve(__dirname, "../../src/types"),
 	"@ax/schemas": path.resolve(__dirname, "../../src/schemas"),
-	"@ax/store": path.resolve(__dirname, "../../src/store"),
 	"@ax/locales": path.resolve(__dirname, "../../src/locales"),
 	"@ax/constants": path.resolve(__dirname, "../../src/constants"),
 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@griddo/ax",
 	"description": "Griddo Author Experience",
-	"version": "12.6.1",
+	"version": "12.6.2",
 	"authors": [
 		"Álvaro Sánchez' <alvaro.sanches@secuoyas.com>",
 		"Diego M. Béjar <diego.bejar@secuoyas.com>",
@@ -46,7 +46,6 @@
 		"@dnd-kit/sortable": "10.0.0",
 		"@griddo/api-types": "^1.0.12",
 		"@pmmmwh/react-refresh-webpack-plugin": "0.5.16",
-		"@reduxjs/toolkit": "2.9.0",
 		"@styled-system/prop-types": "5.1.5",
 		"@styled-system/theme-get": "5.1.2",
 		"@svgr/webpack": "8.1.0",
@@ -78,6 +77,7 @@
 		"babel-preset-react-app": "10.1.0",
 		"case-sensitive-paths-webpack-plugin": "2.4.0",
 		"compress.js": "1.2.2",
+		"connected-react-router": "6.9.3",
 		"css-loader": "6.11.0",
 		"css-minimizer-webpack-plugin": "5.0.1",
 		"date-fns": "2.30.0",
@@ -126,6 +126,7 @@
 		"react-textarea-autosize": "8.5.9",
 		"react-timezone-map-select": "1.2.25",
 		"redux": "4.2.1",
+		"redux-devtools-extension": "2.13.9",
 		"redux-persist": "6.0.0",
 		"reflect-metadata": "0.1.13",
 		"resolve": "1.22.10",
@@ -200,5 +201,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "e0eec02188240c74c8fdacfa7a04fbafdc38c597"
+	"gitHead": "1e6a3ad08eb17a4c57f80fffb65193a82a577969"
 }

package/src/GlobalStore.tsx

@@ -1,78 +1,35 @@
-import type { IRootState } from "@ax/types";
-
-import { configureStore } from "@reduxjs/toolkit";
-import { type Action, combineReducers, type Reducer } from "redux";
-import {
-	FLUSH,
-	PAUSE,
-	PERSIST,
-	type PersistConfig,
-	type PersistedState,
-	type Persistor,
-	PURGE,
-	persistReducer,
-	persistStore,
-	REGISTER,
-	REHYDRATE,
-} from "redux-persist";
+import { createStore, type Reducer, combineReducers, applyMiddleware, type Action, type StoreEnhancer } from "redux";
+import { persistReducer, persistStore, type PersistConfig, type Persistor } from "redux-persist";
 import storage from "redux-persist/lib/storage"; // defaults to localStorage for web
+import { connectRouter, routerMiddleware } from "connected-react-router";
+import { composeWithDevTools } from "redux-devtools-extension";
+import thunk from "redux-thunk";
 
-import { activityLogInitialState, activityLogReducer } from "./containers/ActivityLog/slice";
-import { analyticsInitialState, analyticsReducer } from "./containers/Analytics/slice";
+import { appReducer, appInitialState } from "./containers/App/reducer";
+import { sitesReducer, sitesInitialState } from "./containers/Sites/reducer";
+import { pageEditorReducer, pageEditorInitialState } from "./containers/PageEditor/reducer";
+import { menuReducer, menuInitialState } from "./containers/Navigation/Menu/reducer";
+import { navigationReducer, navigationInitialState } from "./containers/Navigation/Defaults/reducer";
+import { structuredDataReducer, structuredDataInitialState } from "./containers/StructuredData/reducer";
+import { languagesReducer, languagesInitialState } from "./containers/Settings/Languages/reducer";
+import { dataPacksReducer, dataPacksInitialState } from "./containers/Settings/DataPacks/reducer";
+import { socialReducer, socialInitialState } from "./containers/Settings/Social/reducer";
+import { usersReducer, usersInitialState } from "./containers/Users/reducer";
+import { galleryReducer, galleryInitialState } from "./containers/Gallery/reducer";
+import { domainsReducer, domainsInitialState } from "./containers/Domains/reducer";
+import { redirectsReducer, redirectsInitialState } from "./containers/Redirects/reducer";
+import { analyticsReducer, analyticsInitialState } from "./containers/Analytics/reducer";
+import { integrationsReducer, integrationsInitialState } from "./containers/Integrations/reducer";
+import { fileDriveReducer, fileDriveInitialState } from "./containers/FileDrive/reducer";
+import { formsReducer, formsInitialState } from "./containers/Forms/reducer";
+import { activityLogReducer, activityLogInitialState } from "./containers/ActivityLog/reducer";
 import { LOGOUT } from "./containers/App/constants";
-import { appInitialState, appReducer } from "./containers/App/reducer";
-import { domainsInitialState, domainsReducer } from "./containers/Domains/slice";
-import { fileDriveInitialState, fileDriveReducer } from "./containers/FileDrive/reducer";
-import { formsInitialState, formsReducer } from "./containers/Forms/reducer";
-import { galleryInitialState, galleryReducer } from "./containers/Gallery/reducer";
-import { integrationsInitialState, integrationsReducer } from "./containers/Integrations/reducer";
-import { navigationInitialState, navigationReducer } from "./containers/Navigation/Defaults/reducer";
-import { menuInitialState, menuReducer } from "./containers/Navigation/Menu/reducer";
-import { pageEditorInitialState, pageEditorReducer } from "./containers/PageEditor/reducer";
-import { redirectsInitialState, redirectsReducer } from "./containers/Redirects/slice";
-import { dataPacksInitialState, dataPacksReducer } from "./containers/Settings/DataPacks/reducer";
-import { languagesInitialState, languagesReducer } from "./containers/Settings/Languages/slice";
-import { socialInitialState, socialReducer } from "./containers/Settings/Social/slice";
-import { sitesInitialState, sitesReducer } from "./containers/Sites/reducer";
-import { structuredDataInitialState, structuredDataReducer } from "./containers/StructuredData/reducer";
-import { usersInitialState, usersReducer } from "./containers/Users/reducer";
-
-// Every area migrated to RTK leaves redux-persist (docs/adr/0002): its state is a
-// copy of the server's that the screen reloads on mount, so persisting it only
-// meant starting up with stale data. `app` stays in — it carries the session.
-//
-// The test is that EVERY consumer reloads it, not just its settings screen, so
-// `social` and `analytics` stay in for now: six page-editor screens read `state.social`
-// and `AnalyticsField` reads `state.analytics`, and none of them fetches — the persist
-// was their only loader on a hard refresh. They leave in waves 2-4 with those consumers
-// (docs/RTK-MIGRATION.md §5).
-const blacklist = ["menu", "app", "languages", "domains", "redirects", "activityLog"];
-
-/**
- * redux-persist applies the blacklist only when WRITING: `createPersistoid` filters the
- * keys it stages, but `getStoredState` returns every key the previous releases wrote and
- * `autoMergeLevel1` hard-sets them all (`newState[key] = inboundState[key]`). So adding
- * an area to the blacklist does not stop it from being rehydrated once — it only stops
- * the next write.
- *
- * Without this, the first boot after the deploy restores the areas that just left the
- * persist from a stale blob, which is exactly what ADR 0002 removes: state from another
- * site, in a screen that then PUTs it back. Deleting the keys from the inbound state is
- * enough (the first write afterwards replaces the whole blob), and it needs no `version`
- * bump — `persistReducer` calls `migrate` on every rehydrate.
- */
-export const dropBlacklistedAreas = async (state: PersistedState): Promise<PersistedState> => {
-	if (!state) return state;
 
-	const kept = { ...state } as Record<string, unknown>;
-	for (const area of blacklist) {
-		delete kept[area];
-	}
-	return kept as PersistedState;
-};
+import type { IRootState } from "@ax/types";
 
+const blacklist = ["router", "menu", "app", "languages"];
 export class GlobalStore {
-	private persistConfig: PersistConfig<any> = { key: "root", storage, blacklist, migrate: dropBlacklistedAreas };
+	private persistConfig: PersistConfig<any> = { key: "root", storage, blacklist };
 
 	private authPersistConfig = {
 		key: "app",
@@ -80,8 +37,11 @@ export class GlobalStore {
 		blacklist: ["error", "isLoggingIn", "isRehydrated", "isSaving", "loadingCount", "user"],
 	};
 
-	public configureStore() {
+	public configureStore(history: History) {
+		let middleware: StoreEnhancer = applyMiddleware(thunk, routerMiddleware(history));
+
 		const globalReducer: Reducer<any> = combineReducers({
+			router: connectRouter(history),
 			app: persistReducer(this.authPersistConfig, appReducer as Reducer<any, Action<any>>),
 			sites: sitesReducer as Reducer<any, Action<any>>,
 			pageEditor: pageEditorReducer as Reducer<any, Action<any>>,
@@ -105,6 +65,7 @@ export class GlobalStore {
 		const rootReducer = (state: IRootState | undefined, action: any) => {
 			if (action.type === LOGOUT) {
 				state = {
+					router: state?.router,
 					app: state?.app || appInitialState,
 					sites: sitesInitialState,
 					pageEditor: pageEditorInitialState,
@@ -129,27 +90,10 @@ export class GlobalStore {
 			return globalReducer(state, action);
 		};
 
-		// configureStore already wires redux-thunk and the devtools extension (in
-		// non-production), which is why redux-devtools-extension is gone from the deps.
-		const store = configureStore({
-			reducer: persistReducer(this.persistConfig, rootReducer),
-			middleware: (getDefaultMiddleware) =>
-				getDefaultMiddleware({
-					// redux-persist dispatches these with non-serializable payloads by design.
-					// Kept ON otherwise: it only logs, and its warnings are the worklist for
-					// the offenders documented in docs/RTK-MIGRATION.md §5 (5 Date instances in
-					// state, app.error.btnAction holding a function).
-					serializableCheck: {
-						ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER],
-					},
-					// OFF on purpose. The three editors (PageEditor, Forms, Navigation/Defaults)
-					// mutate live store references and re-dispatch the regenerated tree
-					// (docs/RTK-MIGRATION.md §2.1), so this would log on every edit — and it
-					// deep-scans the whole tree per action, which is costly on a state this big.
-					// Re-enable per area as each editor is sanitised (waves 2-4).
-					immutableCheck: false,
-				}),
-		});
+		if (process.env.NODE_ENV !== "production") {
+			middleware = composeWithDevTools(middleware);
+		}
+		const store = createStore(persistReducer(this.persistConfig, rootReducer), middleware);
 		const persistor: Persistor = persistStore(store);
 		return { store, persistor };
 	}

package/src/__tests__/hooks/heartbeat.test.tsx

@@ -0,0 +1,88 @@
+import "@testing-library/jest-dom";
+
+import { useEditingHeartbeat } from "@ax/hooks";
+
+import { renderHook } from "@testing-library/react";
+
+const HEARTBEAT = 30000;
+
+const ORIGINAL = 213;
+const TRANSLATION = 214;
+
+describe("useEditingHeartbeat hook", () => {
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	const renderHeartbeat = (pageID: number | null, sendPagePing: (id: number) => void) =>
+		renderHook(({ pageID }) => useEditingHeartbeat(pageID, sendPagePing), { initialProps: { pageID } });
+
+	it("locks the page on mount, without waiting for the first interval", () => {
+		const sendPagePing = vi.fn();
+
+		renderHeartbeat(ORIGINAL, sendPagePing);
+
+		expect(sendPagePing).toHaveBeenCalledTimes(1);
+		expect(sendPagePing).toHaveBeenCalledWith(ORIGINAL);
+	});
+
+	it("renews the lock every 30 seconds", () => {
+		const sendPagePing = vi.fn();
+
+		renderHeartbeat(ORIGINAL, sendPagePing);
+		vi.advanceTimersByTime(HEARTBEAT * 2);
+
+		// t+0 (mount) + t+30s + t+60s
+		expect(sendPagePing).toHaveBeenCalledTimes(3);
+		expect(sendPagePing.mock.calls.every(([id]) => id === ORIGINAL)).toBe(true);
+	});
+
+	// sc-118275: creating a translation from inside the editor changes pageID in the store without
+	// remounting. The heartbeat used to be pinned to the id it captured on mount, so it kept
+	// renewing the lock of the original page and left the translation unlocked.
+	it("follows the page when its id changes under an editor that never remounts", () => {
+		const sendPagePing = vi.fn();
+
+		const { rerender } = renderHeartbeat(ORIGINAL, sendPagePing);
+		vi.advanceTimersByTime(HEARTBEAT);
+		sendPagePing.mockClear();
+
+		rerender({ pageID: TRANSLATION });
+
+		// No 30 second gap: the page actually being edited is locked as soon as it exists.
+		expect(sendPagePing).toHaveBeenCalledTimes(1);
+		expect(sendPagePing).toHaveBeenCalledWith(TRANSLATION);
+
+		vi.advanceTimersByTime(HEARTBEAT * 2);
+
+		expect(sendPagePing).toHaveBeenCalledTimes(3);
+		// The original is left alone so its lock expires; renewing it would block the rest of the
+		// team on a page nobody is touching.
+		expect(sendPagePing).not.toHaveBeenCalledWith(ORIGINAL);
+	});
+
+	it("does not ping while there is no page yet", () => {
+		const sendPagePing = vi.fn();
+
+		renderHeartbeat(null, sendPagePing);
+		vi.advanceTimersByTime(HEARTBEAT * 2);
+
+		expect(sendPagePing).not.toHaveBeenCalled();
+	});
+
+	it("stops renewing the lock once the editor is closed", () => {
+		const sendPagePing = vi.fn();
+
+		const { unmount } = renderHeartbeat(ORIGINAL, sendPagePing);
+		unmount();
+		sendPagePing.mockClear();
+
+		vi.advanceTimersByTime(HEARTBEAT * 2);
+
+		expect(sendPagePing).not.toHaveBeenCalled();
+	});
+});

package/src/components/MainWrapper/index.tsx

@@ -6,12 +6,12 @@ import AppBar, { type IAppBarProps } from "./AppBar";
 import * as S from "./style";
 
 const MainWrapper = (props: IWrapperProps): JSX.Element => {
-	const { children, fixedAppBar, fullWidth, hasAnimation, screen } = props;
+	const { children, fixedAppBar, fullWidth, hasAnimation } = props;
 
 	const { isOnline } = useNetworkStatus();
 
 	return (
-		<S.Wrapper fixedAppBar={fixedAppBar} data-testid="main-wrapper" data-screen={screen}>
+		<S.Wrapper fixedAppBar={fixedAppBar} data-testid="main-wrapper">
 			{hasAnimation && <S.BackgroundAnimation />}
 			<AppBar {...props} />
 			<S.Main fullWidth={fullWidth} data-testid="main-component" id="main-component">
@@ -30,18 +30,6 @@ const MainWrapper = (props: IWrapperProps): JSX.Element => {
 export interface IWrapperProps extends IAppBarProps {
 	children?: any[] | JSX.Element;
 	fullWidth?: boolean;
-	/**
-	 * Stable per-screen identifier for e2e, emitted as `data-screen`. Separate from
-	 * `data-testid="main-wrapper"`, which is the same on all 32 screens and is already
-	 * consumed by tests here and in griddo-qa's `identifiers.ts`.
-	 *
-	 * It exists because nothing else identifies a screen: `title` is display copy and
-	 * is not even unique — Robots and Redirects are both "SEO Settings", and the global
-	 * and the site Analytics screens are both "Analytics Settings". The e2e specs had
-	 * to assert on `location.pathname` with exact equality, and `/settings/analytics`
-	 * is a substring of `/sites/settings/analytics`.
-	 */
-	screen?: string;
 }
 
 export default MainWrapper;

package/src/containers/ActivityLog/{thunks.ts → actions.tsx}

@@ -1,15 +1,5 @@
-import { logs } from "@ax/api";
-import { appActions } from "@ax/containers/App";
-import { formsActions } from "@ax/containers/Forms";
-import { integrationsActions } from "@ax/containers/Integrations";
-import { navigationActions } from "@ax/containers/Navigation";
-import { pageEditorActions } from "@ax/containers/PageEditor";
-import { sitesActions } from "@ax/containers/Sites";
-import { structuredDataActions } from "@ax/containers/StructuredData";
-import { usersActions } from "@ax/containers/Users";
-import { handleRequest } from "@ax/helpers";
-import type { AppDispatch } from "@ax/store";
-import type { IRootState } from "@ax/types";
+import type { Dispatch } from "redux";
+import { format } from "date-fns";
 
 import type {
 	LogActivityExportRequest,
@@ -20,106 +10,99 @@ import type {
 	LogContentTypeDTO,
 	PaginationResponse,
 } from "@griddo/api-types";
-import { createAsyncThunk } from "@reduxjs/toolkit";
-import { format } from "date-fns";
-import type { Dispatch } from "redux";
+import { logs } from "@ax/api";
+import { appActions } from "@ax/containers/App";
+import { usersActions } from "@ax/containers/Users";
+import { pageEditorActions } from "@ax/containers/PageEditor";
+import { sitesActions } from "@ax/containers/Sites";
+import { integrationsActions } from "@ax/containers/Integrations";
+import { formsActions } from "@ax/containers/Forms";
+import { navigationActions } from "@ax/containers/Navigation";
+import { structuredDataActions } from "@ax/containers/StructuredData";
+import { handleRequest } from "@ax/helpers";
+import type { ILogItemsByDay, ILogItemsByUser, IRootState } from "@ax/types";
+
+import { SET_ACTIVITY_LOG, SET_LIST_MODE } from "./constants";
+import type { ISetActivityLog, ISetListMode } from "./interfaces";
+
+function setActivityLog(activityLog: ILogItemsByDay | ILogItemsByUser): ISetActivityLog {
+	return { type: SET_ACTIVITY_LOG, payload: { activityLog } };
+}
+
+function setListMode(listMode: string): ISetListMode {
+	return { type: SET_LIST_MODE, payload: { listMode } };
+}
 
-import { setActivityLog } from "./slice";
+function getActivityLog(params: LogActivityPaginationRequest): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => logs.getLogActivityTimelineByDay(params);
 
-/**
- * Read and export side of UC-AX-view-activity-log, plus the deep-link dispatcher, as
- * createAsyncThunk.
- *
- * They keep calling `handleRequest` inside for the same reason the Languages pilot does —
- * see docs/RTK-MIGRATION.md §5.
- *
- * `goToLogContent` is the last of the wave's mines and the one that does not get cleaned up
- * here: it is a 160-line navigation switch that reaches into SEVEN areas that have not been
- * migrated yet, invoking their thunks by hand as `thunk(args)(dispatch, getState)`. That still
- * works while those areas are legacy, and it is exactly what stops working when they are not —
- * a createAsyncThunk expects the `(dispatch, getState, extra)` triple. **When `sites` migrates
- * in wave 3, the twelve `sitesActions.getSite(site)(dispatch, getState)` calls below break.**
- * Its body is transplanted verbatim on purpose — diffed line by line against the legacy one —
- * and the single-argument rule is the only edit it took.
- */
-const onError = (response: unknown, dispatch: Dispatch) => appActions.handleError(response)(dispatch);
+			const responseActions = {
+				handleSuccess: (response: PaginationResponse<LogActivityGroupedDayDTO>) => {
+					dispatch(setActivityLog(response));
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
 
-/**
- * The store's real dispatch and state, declared once.
- *
- * `AppDispatch` is a redux 4 `AnyAction` thunk dispatch (`src/store/hooks.ts`), so the
- * nineteen legacy action creators and the seven legacy thunks that `goToLogContent` still
- * reaches for keep type-checking, and `getState()` comes back as `IRootState` instead of
- * `unknown`. Without this RTK types `dispatch` against redux 5's `UnknownAction`, which the
- * hand-written action interfaces are not assignable to — the §8.3 friction, reaching
- * production code here for the first time rather than just test files.
- */
-const createAppAsyncThunk = createAsyncThunk.withTypes<{ state: IRootState; dispatch: AppDispatch }>();
+			await handleRequest(callback, responseActions, [appActions.setIsLoading])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
 
-export const getActivityLog = createAsyncThunk(
-	"activityLog/getActivityLog",
-	async (params: LogActivityPaginationRequest, { dispatch }) =>
-		handleRequest(
-			async () => logs.getLogActivityTimelineByDay(params),
-			{
-				handleSuccess: (response: PaginationResponse<LogActivityGroupedDayDTO>) => dispatch(setActivityLog(response)),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[appActions.setIsLoading],
-		)(dispatch),
-);
+function getActivityLogByUser(params: LogActivityPaginationRequest): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const callback = async () => logs.getLogActivityTimelineByUser(params);
 
-export const getActivityLogByUser = createAsyncThunk(
-	"activityLog/getActivityLogByUser",
-	async (params: LogActivityPaginationRequest, { dispatch }) =>
-		handleRequest(
-			async () => logs.getLogActivityTimelineByUser(params),
-			{
-				handleSuccess: (response: PaginationResponse<LogActivityGroupedUserDTO<LogActivityGroupedUserDTO[]>>) =>
-					dispatch(setActivityLog(response)),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[appActions.setIsLoading],
-		)(dispatch),
-);
+			const responseActions = {
+				handleSuccess: (response: PaginationResponse<LogActivityGroupedUserDTO<LogActivityGroupedUserDTO[]>>) => {
+					dispatch(setActivityLog(response));
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
 
-// The export comes back as a blob and is handed to the browser through a throwaway
-// `<a download>`. Kept verbatim from the legacy thunk, side effects included: it is the only
-// place in the area that touches the DOM.
-const saveExport = (payload: BlobPart, extension: string) => {
-	const dateString = format(new Date(), "yyyy-MM-dd");
-	const url = window.URL.createObjectURL(new Blob([payload]));
-	const a = document.createElement("a");
-	a.href = url;
-	a.download = `activity-log-${dateString}.${extension}`;
-	document.body.appendChild(a);
-	a.click();
-	window.URL.revokeObjectURL(url);
-};
+			await handleRequest(callback, responseActions, [appActions.setIsLoading])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
+}
 
-export const downloadActivityLog = createAsyncThunk(
-	"activityLog/downloadActivityLog",
-	// No loading flag, as before: the export runs without the screen's spinner.
-	async (data: LogActivityExportRequest, { dispatch }) =>
-		handleRequest(
-			async () => logs.logExport(data),
-			{
-				handleSuccess: (response: BlobPart) => saveExport(response, data.format[0]),
-				handleError: (response: unknown) => onError(response, dispatch),
-			},
-			[],
-		)(dispatch),
-);
+function downloadActivityLog(data: LogActivityExportRequest): (dispatch: Dispatch) => Promise<void> {
+	return async (dispatch) => {
+		try {
+			const responseActions = {
+				handleSuccess: (response: any) => {
+					const dateString = format(new Date(), "yyyy-MM-dd");
+					const url = window.URL.createObjectURL(new Blob([response]));
+					const a = document.createElement("a");
+					a.href = url;
+					a.download = `activity-log-${dateString}.${data.format[0]}`;
+					document.body.appendChild(a);
+					a.click();
+					window.URL.revokeObjectURL(url);
+				},
+				handleError: (response: any) => appActions.handleError(response)(dispatch),
+			};
 
-interface IGoToLogContentArgs {
-	contentType: LogContentTypeDTO | null;
-	content: LogContentDTO | null;
-	site: number | null;
+			const callback = async () => logs.logExport(data);
+
+			await handleRequest(callback, responseActions, [])(dispatch);
+		} catch (e) {
+			console.log(e);
+		}
+	};
 }
 
-export const goToLogContent = createAppAsyncThunk(
-	"activityLog/goToLogContent",
-	async ({ contentType, content, site }: IGoToLogContentArgs, { dispatch, getState }) => {
+function goToLogContent(
+	contentType: LogContentTypeDTO | null,
+	content: LogContentDTO | null,
+	site: number | null,
+): (dispatch: Dispatch, getState: () => IRootState) => void {
+	return async (dispatch, getState) => {
 		const {
 			app: { lang, globalLangs },
 		} = getState();
@@ -274,5 +257,7 @@ export const goToLogContent = createAppAsyncThunk(
 					break;
 			}
 		}
-	},
-);
+	};
+}
+
+export { getActivityLog, getActivityLogByUser, setListMode, downloadActivityLog, goToLogContent };

package/src/containers/ActivityLog/constants.tsx

@@ -0,0 +1,6 @@
+const NAME = "activityLog";
+
+const SET_ACTIVITY_LOG = `${NAME}/SET_ACTIVITY_LOG`;
+const SET_LIST_MODE = `${NAME}/SET_LIST_MODE`;
+
+export { SET_ACTIVITY_LOG, SET_LIST_MODE };

package/src/containers/ActivityLog/index.tsx

@@ -1,17 +1,4 @@
-import { setListMode } from "./slice";
-import { downloadActivityLog, getActivityLog, getActivityLogByUser, goToLogContent } from "./thunks";
+import * as activityLogActions from "./actions";
+import { activityLogReducer } from "./reducer";
 
-// `setActivityLog` stays private, as it was: the legacy `actions.tsx` did not export it
-// either — only the thunks write the page.
-const activityLogActions = {
-	getActivityLog,
-	getActivityLogByUser,
-	setListMode,
-	downloadActivityLog,
-	goToLogContent,
-};
-
-export { activityLogActions };
-
-export type { IActivityLogState } from "./slice";
-export { activityLogInitialState, activityLogReducer } from "./slice";
+export { activityLogActions, activityLogReducer };

package/src/containers/ActivityLog/interfaces.tsx

@@ -0,0 +1,12 @@
+import type { ILogItemsByDay, ILogItemsByUser } from "@ax/types";
+import type { SET_ACTIVITY_LOG, SET_LIST_MODE } from "./constants";
+
+export interface ISetActivityLog {
+	type: typeof SET_ACTIVITY_LOG;
+	payload: { activityLog: ILogItemsByDay | ILogItemsByUser };
+}
+
+export interface ISetListMode {
+	type: typeof SET_LIST_MODE;
+	payload: { listMode: string };
+}

package/src/containers/ActivityLog/reducer.tsx

@@ -0,0 +1,24 @@
+import type { ILogItemsByDay, ILogItemsByUser } from "@ax/types";
+import { SET_ACTIVITY_LOG, SET_LIST_MODE } from "./constants";
+
+export interface IActivityLogState {
+	activityLog: ILogItemsByDay | ILogItemsByUser;
+	listMode: string;
+}
+
+export const initialState: IActivityLogState = {
+	activityLog: { totalItems: 0, items: [] },
+	listMode: "default",
+};
+
+export function reducer(state = initialState, action: any): IActivityLogState {
+	switch (action.type) {
+		case SET_ACTIVITY_LOG:
+		case SET_LIST_MODE:
+			return { ...state, ...action.payload };
+		default:
+			return state;
+	}
+}
+
+export { initialState as activityLogInitialState, reducer as activityLogReducer };