@zeniai/client-epic-state 5.2.97 → 5.2.99

package/lib/esm/view/taskManager/taskDetailView/epics/fetchTaskDetailEpic.js

@@ -22,6 +22,17 @@ export const fetchTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(
     if (cacheOverride === true) {
         taskActions.push(removeTaskDetail(taskId));
     }
+    // The task is already loaded and the caller did not ask for a refresh, so
+    // serve it from the store. The `fetchState !== 'In-Progress'` check below
+    // only suppresses a duplicate request while one is in flight; it is not a
+    // cache check, because a loaded task sits at 'Completed' and so passes it.
+    // Without this, re-opening the same task refetches it every time.
+    if (cacheOverride === false && isLoadedTaskDetail(taskDetail)) {
+        // Rebuild the editable copy from the cached task entity rather than
+        // emitting nothing: leaving the page discards the local data, so a
+        // silent cache hit would render an empty form.
+        return of(initializeTaskToLocalStore(taskId));
+    }
     if (cacheOverride === true ||
         taskDetail == null ||
         taskDetail.fetchTaskStatus.fetchState !== 'In-Progress') {

package/lib/esm/view/taskManager/taskDetailView/epics/fetchTaskHistoryEpic.js

@@ -1,5 +1,5 @@
 import recordGet from 'lodash/get';
-import { concat, from, of } from 'rxjs';
+import { EMPTY, concat, from, of } from 'rxjs';
 import { catchError, filter, mergeMap } from 'rxjs/operators';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
 import { fetchTaskHistory, updateTaskHistory, updateTaskHistoryFetchStatus, } from '../taskDetailReducer';
@@ -8,6 +8,14 @@ export const fetchTaskHistoryEpic = (actions$, state$, zeniAPI) => actions$.pipe
     const historyActions = [];
     const state = state$.value;
     const taskHistoryDetail = recordGet(state.taskDetailState.taskHistoryById, taskId, undefined);
+    // Already fetched and no refresh asked for: keep what we have. As in
+    // fetchTaskDetailEpic, the 'In-Progress' check below is an in-flight
+    // guard, not a cache check.
+    if (cacheOverride === false &&
+        taskHistoryDetail != null &&
+        taskHistoryDetail.fetchState === 'Completed') {
+        return EMPTY;
+    }
     if (cacheOverride === true ||
         taskHistoryDetail == null ||
         taskHistoryDetail.fetchState !== 'In-Progress') {

package/lib/esm/view/taskManager/taskDetailView/taskDetailLocalData.js

@@ -17,6 +17,12 @@ export const buildTaskDetailLocalData = (task) => ({
         recurringEndDate: task.recurringEndDate,
     },
     savedRecurringEndDate: task.recurringEndDate,
+    // Explicitly cleared, not omitted. `saveTaskUpdatesToLocalStore` SHALLOW
+    // MERGES this over the existing local data, so a key left out here keeps
+    // whatever was there before. The task entity carries no recurrence count —
+    // this is a form-local value — so a rebuild from the entity must reset it,
+    // or an abandoned recurrence edit survives leaving and re-opening the task.
+    savedRecurringTasksCount: undefined,
     recurringStartDate: task.recurringStartDate,
     timeSpent: task.timeSpent,
     isPrivate: task.isPrivate,

package/lib/esm/view/taskManager/taskDetailView/taskDetailReducer.js

@@ -4,7 +4,6 @@ import { clearAll } from '../../../rootActions';
 import { initialCommonHistory } from '../../spendManagement/commonHistoryView/commonHistory';
 import { toHistoricEvent, } from '../../spendManagement/commonHistoryView/commonHistoryPayload';
 import { initialTaskDetail, } from './taskDetail';
-import { isLoadedTaskDetail } from './taskDetailLocalData';
 export const initialState = {
     newTaskState: initialTaskDetail,
     editTaskStateById: {},
@@ -21,12 +20,17 @@ const taskDetailView = createSlice({
     reducers: {
         fetchTaskDetailPage: {
             reducer(draft, action) {
-                const { taskId } = action.payload;
+                const { cacheOverride, taskId } = action.payload;
                 if (taskId != null) {
                     const detail = recordGet(draft.editTaskStateById, taskId, undefined);
-                    const isRefresh = action.payload.cacheOverride === true && isLoadedTaskDetail(detail);
-                    if (!isRefresh &&
-                        (action.payload.cacheOverride === true ||
+                    // An already-loaded task is served from the store on BOTH paths:
+                    // cacheOverride=true refreshes it in place, cacheOverride=false
+                    // re-opens it. Resetting the record to `initialTaskDetail` would put
+                    // `fetchTaskStatus` back to 'Not-Started' and throw the cached task
+                    // away, so the detail epic's cache check could never hit and every
+                    // open refetched behind a skeleton.
+                    if (detail?.fetchTaskStatus.fetchState !== 'Completed' &&
+                        (cacheOverride === true ||
                             detail == null ||
                             detail.fetchTaskStatus.fetchState !== 'In-Progress')) {
                         draft.editTaskStateById[taskId] = {
@@ -119,7 +123,29 @@ const taskDetailView = createSlice({
         discardTaskUpdatesInLocalStore(draft, action) {
             if (action.payload.taskId != null) {
                 const key = action.payload.taskId;
-                draft.editTaskStateById[key] = initialTaskDetail;
+                const existing = draft.editTaskStateById[key];
+                // Reset the MUTATION statuses. Nothing else.
+                //
+                // Replacing the whole record reset `fetchTaskStatus` to 'Not-Started',
+                // which threw the cached task away, so re-opening always refetched.
+                // But blanking `taskDetailLocalData` while keeping 'Completed' is just
+                // as wrong the other way: the page skeletons only on 'Not-Started' /
+                // 'In-Progress', so the detail page renders one more frame on its way
+                // out — now as an EMPTY form, which reads as "a new task" for an
+                // instant before the board appears. The skeleton used to cover that.
+                //
+                // The edits do not need clearing here: every open dispatches
+                // `initializeTaskToLocalStore`, and its epic overwrites the local data
+                // wholesale from the task entity. That is what actually discards them.
+                draft.editTaskStateById[key] =
+                    existing == null
+                        ? initialTaskDetail
+                        : {
+                            ...initialTaskDetail,
+                            taskId: existing.taskId,
+                            fetchTaskStatus: existing.fetchTaskStatus,
+                            taskDetailLocalData: existing.taskDetailLocalData,
+                        };
             }
             else {
                 draft.newTaskState = initialTaskDetail;
@@ -293,11 +319,21 @@ const taskDetailView = createSlice({
         },
         fetchTaskHistory: {
             reducer(draft, action) {
-                const { taskId, cacheOverride } = action.payload;
+                // `cacheOverride` is deliberately unused: a refresh of loaded history
+                // is silent either way now, and the epic decides whether to refetch.
+                const { taskId } = action.payload;
                 const detail = recordGet(draft.taskHistoryById, taskId, undefined);
-                if (cacheOverride === true ||
-                    detail == null ||
-                    detail.fetchState !== 'In-Progress') {
+                // Same as `fetchTaskDetailPage`: re-opening a task must not wipe the
+                // history it already has, or the history epic's cache check can never
+                // hit and every open refetches it.
+                //
+                // Only a record that does not exist yet is seeded. Keying this on
+                // `fetchState === 'Completed'` left a gap: a silent refresh moves the
+                // record to 'In-Progress' with its events intact, and a second refresh
+                // landing on top of that no longer saw 'Completed', so it rebuilt from
+                // `initialCommonHistory` and emptied `historicEvents` — the very flash
+                // this is here to prevent.
+                if (detail == null) {
                     draft.taskHistoryById[taskId] = {
                         ...initialCommonHistory,
                     };
@@ -321,8 +357,12 @@ const taskDetailView = createSlice({
         },
         updateTaskHistoryFetchStatus(draft, action) {
             const { taskId, fetchState, error } = action.payload;
+            // Keep the events that are already there. Spreading `initialCommonHistory`
+            // emptied the list on every status change, which the loading skeleton used
+            // to hide; now that a re-open serves from cache and shows no skeleton, a
+            // silent refresh would flash the history list empty and refill it.
             draft.taskHistoryById[taskId] = {
-                ...initialCommonHistory,
+                ...(draft.taskHistoryById[taskId] ?? initialCommonHistory),
                 fetchState,
                 error,
             };

package/lib/esm/view/taskManager/taskGroupView/taskGroupViewReducer.js

@@ -25,7 +25,24 @@ const taskGroupView = createSlice({
     initialState,
     reducers: {
         fetchAllTaskGroups(draft) {
-            draft.fetchState = 'In-Progress';
+            // Groups already in the store: refetch in the background and stay
+            // 'Completed'. This mirrors `fetchTaskList`, which has always done it.
+            //
+            // The board's fetch state is `reduceAnyFetchState([taskListState,
+            // taskGroupViewState, ...])`, so flipping this one slice to
+            // 'In-Progress' skeletons the WHOLE board — every tab — even with the
+            // task list fully cached. The Pusher snapshot-on-connect catch-up
+            // refetches groups on every re-subscribe, which is why returning from a
+            // task made the board look like it was reloading when no task request
+            // was in flight at all.
+            //
+            // Keyed on "has a fetch ever completed", NOT on `taskGroupsIds.length`:
+            // a tenant that uses no groups has a legitimately empty list, and
+            // counting ids makes that indistinguishable from a cold load — so every
+            // catch-up would skeleton the board for exactly the orgs this is meant
+            // to help.
+            draft.fetchState =
+                draft.fetchState === 'Completed' ? 'Completed' : 'In-Progress';
             draft.error = undefined;
         },
         updateTaskGroupsOnSuccess(draft, action) {

package/lib/view/taskManager/taskDetailView/epics/fetchTaskDetailEpic.js

@@ -28,6 +28,17 @@ const fetchTaskDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, ope
     if (cacheOverride === true) {
         taskActions.push((0, taskDetailReducer_1.removeTaskDetail)(taskId));
     }
+    // The task is already loaded and the caller did not ask for a refresh, so
+    // serve it from the store. The `fetchState !== 'In-Progress'` check below
+    // only suppresses a duplicate request while one is in flight; it is not a
+    // cache check, because a loaded task sits at 'Completed' and so passes it.
+    // Without this, re-opening the same task refetches it every time.
+    if (cacheOverride === false && (0, taskDetailLocalData_1.isLoadedTaskDetail)(taskDetail)) {
+        // Rebuild the editable copy from the cached task entity rather than
+        // emitting nothing: leaving the page discards the local data, so a
+        // silent cache hit would render an empty form.
+        return (0, rxjs_1.of)((0, taskDetailReducer_1.initializeTaskToLocalStore)(taskId));
+    }
     if (cacheOverride === true ||
         taskDetail == null ||
         taskDetail.fetchTaskStatus.fetchState !== 'In-Progress') {

package/lib/view/taskManager/taskDetailView/epics/fetchTaskHistoryEpic.js

@@ -14,6 +14,14 @@ const fetchTaskHistoryEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, op
     const historyActions = [];
     const state = state$.value;
     const taskHistoryDetail = (0, get_1.default)(state.taskDetailState.taskHistoryById, taskId, undefined);
+    // Already fetched and no refresh asked for: keep what we have. As in
+    // fetchTaskDetailEpic, the 'In-Progress' check below is an in-flight
+    // guard, not a cache check.
+    if (cacheOverride === false &&
+        taskHistoryDetail != null &&
+        taskHistoryDetail.fetchState === 'Completed') {
+        return rxjs_1.EMPTY;
+    }
     if (cacheOverride === true ||
         taskHistoryDetail == null ||
         taskHistoryDetail.fetchState !== 'In-Progress') {

package/lib/view/taskManager/taskDetailView/taskDetailLocalData.js

@@ -23,6 +23,12 @@ const buildTaskDetailLocalData = (task) => ({
         recurringEndDate: task.recurringEndDate,
     },
     savedRecurringEndDate: task.recurringEndDate,
+    // Explicitly cleared, not omitted. `saveTaskUpdatesToLocalStore` SHALLOW
+    // MERGES this over the existing local data, so a key left out here keeps
+    // whatever was there before. The task entity carries no recurrence count —
+    // this is a form-local value — so a rebuild from the entity must reset it,
+    // or an abandoned recurrence edit survives leaving and re-opening the task.
+    savedRecurringTasksCount: undefined,
     recurringStartDate: task.recurringStartDate,
     timeSpent: task.timeSpent,
     isPrivate: task.isPrivate,

package/lib/view/taskManager/taskDetailView/taskDetailReducer.js

@@ -11,7 +11,6 @@ const rootActions_1 = require("../../../rootActions");
 const commonHistory_1 = require("../../spendManagement/commonHistoryView/commonHistory");
 const commonHistoryPayload_1 = require("../../spendManagement/commonHistoryView/commonHistoryPayload");
 const taskDetail_1 = require("./taskDetail");
-const taskDetailLocalData_1 = require("./taskDetailLocalData");
 exports.initialState = {
     newTaskState: taskDetail_1.initialTaskDetail,
     editTaskStateById: {},
@@ -28,12 +27,17 @@ const taskDetailView = (0, toolkit_1.createSlice)({
     reducers: {
         fetchTaskDetailPage: {
             reducer(draft, action) {
-                const { taskId } = action.payload;
+                const { cacheOverride, taskId } = action.payload;
                 if (taskId != null) {
                     const detail = (0, get_1.default)(draft.editTaskStateById, taskId, undefined);
-                    const isRefresh = action.payload.cacheOverride === true && (0, taskDetailLocalData_1.isLoadedTaskDetail)(detail);
-                    if (!isRefresh &&
-                        (action.payload.cacheOverride === true ||
+                    // An already-loaded task is served from the store on BOTH paths:
+                    // cacheOverride=true refreshes it in place, cacheOverride=false
+                    // re-opens it. Resetting the record to `initialTaskDetail` would put
+                    // `fetchTaskStatus` back to 'Not-Started' and throw the cached task
+                    // away, so the detail epic's cache check could never hit and every
+                    // open refetched behind a skeleton.
+                    if (detail?.fetchTaskStatus.fetchState !== 'Completed' &&
+                        (cacheOverride === true ||
                             detail == null ||
                             detail.fetchTaskStatus.fetchState !== 'In-Progress')) {
                         draft.editTaskStateById[taskId] = {
@@ -126,7 +130,29 @@ const taskDetailView = (0, toolkit_1.createSlice)({
         discardTaskUpdatesInLocalStore(draft, action) {
             if (action.payload.taskId != null) {
                 const key = action.payload.taskId;
-                draft.editTaskStateById[key] = taskDetail_1.initialTaskDetail;
+                const existing = draft.editTaskStateById[key];
+                // Reset the MUTATION statuses. Nothing else.
+                //
+                // Replacing the whole record reset `fetchTaskStatus` to 'Not-Started',
+                // which threw the cached task away, so re-opening always refetched.
+                // But blanking `taskDetailLocalData` while keeping 'Completed' is just
+                // as wrong the other way: the page skeletons only on 'Not-Started' /
+                // 'In-Progress', so the detail page renders one more frame on its way
+                // out — now as an EMPTY form, which reads as "a new task" for an
+                // instant before the board appears. The skeleton used to cover that.
+                //
+                // The edits do not need clearing here: every open dispatches
+                // `initializeTaskToLocalStore`, and its epic overwrites the local data
+                // wholesale from the task entity. That is what actually discards them.
+                draft.editTaskStateById[key] =
+                    existing == null
+                        ? taskDetail_1.initialTaskDetail
+                        : {
+                            ...taskDetail_1.initialTaskDetail,
+                            taskId: existing.taskId,
+                            fetchTaskStatus: existing.fetchTaskStatus,
+                            taskDetailLocalData: existing.taskDetailLocalData,
+                        };
             }
             else {
                 draft.newTaskState = taskDetail_1.initialTaskDetail;
@@ -300,11 +326,21 @@ const taskDetailView = (0, toolkit_1.createSlice)({
         },
         fetchTaskHistory: {
             reducer(draft, action) {
-                const { taskId, cacheOverride } = action.payload;
+                // `cacheOverride` is deliberately unused: a refresh of loaded history
+                // is silent either way now, and the epic decides whether to refetch.
+                const { taskId } = action.payload;
                 const detail = (0, get_1.default)(draft.taskHistoryById, taskId, undefined);
-                if (cacheOverride === true ||
-                    detail == null ||
-                    detail.fetchState !== 'In-Progress') {
+                // Same as `fetchTaskDetailPage`: re-opening a task must not wipe the
+                // history it already has, or the history epic's cache check can never
+                // hit and every open refetches it.
+                //
+                // Only a record that does not exist yet is seeded. Keying this on
+                // `fetchState === 'Completed'` left a gap: a silent refresh moves the
+                // record to 'In-Progress' with its events intact, and a second refresh
+                // landing on top of that no longer saw 'Completed', so it rebuilt from
+                // `initialCommonHistory` and emptied `historicEvents` — the very flash
+                // this is here to prevent.
+                if (detail == null) {
                     draft.taskHistoryById[taskId] = {
                         ...commonHistory_1.initialCommonHistory,
                     };
@@ -328,8 +364,12 @@ const taskDetailView = (0, toolkit_1.createSlice)({
         },
         updateTaskHistoryFetchStatus(draft, action) {
             const { taskId, fetchState, error } = action.payload;
+            // Keep the events that are already there. Spreading `initialCommonHistory`
+            // emptied the list on every status change, which the loading skeleton used
+            // to hide; now that a re-open serves from cache and shows no skeleton, a
+            // silent refresh would flash the history list empty and refill it.
             draft.taskHistoryById[taskId] = {
-                ...commonHistory_1.initialCommonHistory,
+                ...(draft.taskHistoryById[taskId] ?? commonHistory_1.initialCommonHistory),
                 fetchState,
                 error,
             };

package/lib/view/taskManager/taskGroupView/taskGroupViewReducer.js

@@ -29,7 +29,24 @@ const taskGroupView = (0, toolkit_1.createSlice)({
     initialState: exports.initialState,
     reducers: {
         fetchAllTaskGroups(draft) {
-            draft.fetchState = 'In-Progress';
+            // Groups already in the store: refetch in the background and stay
+            // 'Completed'. This mirrors `fetchTaskList`, which has always done it.
+            //
+            // The board's fetch state is `reduceAnyFetchState([taskListState,
+            // taskGroupViewState, ...])`, so flipping this one slice to
+            // 'In-Progress' skeletons the WHOLE board — every tab — even with the
+            // task list fully cached. The Pusher snapshot-on-connect catch-up
+            // refetches groups on every re-subscribe, which is why returning from a
+            // task made the board look like it was reloading when no task request
+            // was in flight at all.
+            //
+            // Keyed on "has a fetch ever completed", NOT on `taskGroupsIds.length`:
+            // a tenant that uses no groups has a legitimately empty list, and
+            // counting ids makes that indistinguishable from a cold load — so every
+            // catch-up would skeleton the board for exactly the orgs this is meant
+            // to help.
+            draft.fetchState =
+                draft.fetchState === 'Completed' ? 'Completed' : 'In-Progress';
             draft.error = undefined;
         },
         updateTaskGroupsOnSuccess(draft, action) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeniai/client-epic-state",
-  "version": "5.2.97",
+  "version": "5.2.99",
   "description": "Shared module between Web & Mobile containing required abstractions for state management, async network communication. ",
   "main": "lib/index.js",
   "module": "lib/esm/index.js",