@zeniai/client-epic-state 4.20.0-beta2ND → 4.20.0-beta3RR

package/lib/view/companyTaskManagerView/companyTaskManagerViewReducer.d.ts

@@ -4,10 +4,10 @@ import { CompanyTaskManagerViewPayload } from './companyTaskManagerViewPayload';
 import { CompanyTaskManagerViewState, CompanyTaskManagerViewUIState } from './companyTaskManagerViewState';
 export declare const initialUIState: CompanyTaskManagerViewUIState;
 export declare const initialState: CompanyTaskManagerViewState;
-export declare const fetchCompanyTaskManagerView: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[pageToken: PageToken, sortKey: "status" | "name" | "tags" | "createdBy" | "dueDate" | "priority" | "assignee" | "taskName", sortOrder: "ascending" | "descending", keepExistingListItems?: any, searchString?: string | undefined], {
+export declare const fetchCompanyTaskManagerView: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[pageToken: PageToken, sortKey: "status" | "name" | "tags" | "createdBy" | "dueDate" | "priority" | "assignee" | "visibility" | "taskName", sortOrder: "ascending" | "descending", keepExistingListItems?: any, searchString?: string | undefined], {
     pageToken: PageToken;
     searchString: string | undefined;
-    sortKey: "status" | "name" | "tags" | "createdBy" | "dueDate" | "priority" | "assignee" | "taskName";
+    sortKey: "status" | "name" | "tags" | "createdBy" | "dueDate" | "priority" | "assignee" | "visibility" | "taskName";
     sortOrder: "ascending" | "descending";
     keepExistingListItems: any;
 }, "companyTaskManagerView/fetchCompanyTaskManagerView", never, never>, updateCompanyTaskManagerViewOnSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{

package/lib/view/companyView/types/cockpitTypes.d.ts

@@ -7,7 +7,7 @@ export declare const toPortfolioSortKeyType: (v: string) => "expenses" | "runway
 export declare const toManagementSortKeyType: (v: string) => "status" | "bookCloseDate" | "group" | "taxStatus" | "controller" | "preparer" | "reviewer" | "annualRecurringRevenue" | "companyName" | "monthlyRecurringRevenue" | "task" | "notes" | "plans" | "customerSuccessManager" | "apAnalyst" | "reportSent" | "taxLead" | "satisfaction";
 export declare const toOnboardingSortKeyType: (v: string) => "companyName" | "businessVerified" | "identityVerified" | "bankAccountLinked" | "customerCreated" | "groupCreated" | "qboLinked" | "notes" | "enroller" | "invite" | "latestCreated";
 export declare const toHealthSortKeyType: (v: string) => "group" | "runway" | "controller" | "companyName" | "monthlyRecurringRevenue" | "companyEngagementMetricsUpdatedAt" | "customerSatisfactionScore" | "externalProductServiceExposure" | "netPromoterScore" | "customerSuccessManager" | "lastReportSent" | "issues" | "productVerticals" | "churnProbability" | "subscriptionDate" | "renewalDate" | "dashboardLastSeen" | "lastEngagement";
-export declare const toTaskManagerSortKeyType: (v: string) => "status" | "name" | "tags" | "createdBy" | "dueDate" | "priority" | "assignee" | "taskName";
+export declare const toTaskManagerSortKeyType: (v: string) => "status" | "name" | "tags" | "createdBy" | "dueDate" | "priority" | "assignee" | "visibility" | "taskName";
 export type PortfolioViewSortKey = ReturnType<typeof toPortfolioSortKeyType>;
 export type ManagementViewSortKey = ReturnType<typeof toManagementSortKeyType>;
 export type OnboardingViewSortKey = ReturnType<typeof toOnboardingSortKeyType>;

package/lib/view/companyView/types/cockpitTypes.js

@@ -71,6 +71,7 @@ const ALL_TASK_MANAGER_SORT_KEYS = [
     'dueDate',
     'assignee',
     'tags',
+    'visibility',
     'createdBy',
 ];
 const toPortfolioSortKeyType = (v) => (0, stringToUnion_1.stringToUnion)(v, ALL_PORTFOLIO_SORT_KEYS);

package/lib/view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector.js

@@ -52,11 +52,16 @@ const getProfitAndLossClassesHorizontalView = (filter, accountState, classState,
     const calculatedSections = {};
     let reportCurrency = currencyHelper_1.defaultCustomerCurrency;
     if (fetchState.fetchState === 'Completed' && selectedPeriod != null) {
+        // Get section reports using existing selector infrastructure
+        const sectionReports = {};
+        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
+            sectionReports[sectionId] = (0, sectionClassesViewSelector_1.getSectionClassesViewReport)(accountState, classState, sectionsState, { reportId, sectionId }, filter);
+        });
         reportCurrency =
             profitAndLossClassesViewState.currency ?? currencyHelper_1.defaultCustomerCurrency;
-        // Fetch each section and pivot class→account to account→class in one pass
+        // Pivot each section from class→account to account→class
         HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            const sectionReport = (0, sectionClassesViewSelector_1.getSectionClassesViewReport)(accountState, classState, sectionsState, { reportId, sectionId }, filter);
+            const sectionReport = sectionReports[sectionId];
             if (sectionReport != null) {
                 sections[sectionId] = pivotSectionToHorizontal(sectionReport, classColumns, SECTION_TITLES[sectionId] ?? sectionId, reportCurrency);
             }
@@ -260,7 +265,7 @@ function sumBalancesInSlice(balances) {
     if (balances.length === 0) {
         return 0;
     }
-    const summed = (0, getSummationBalance_1.getSummationFreeRangeTotalBalance)(balances);
+    const summed = (0, getSummationBalance_1.getSummationFreeRangeTotalBalance)([...balances]);
     return summed?.balance.amount ?? 0;
 }
 /**

package/lib/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -28,31 +28,30 @@ function enrichHorizontalSection(report, section) {
         return total?.balance.amount ?? 0;
     });
     section.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, section.sectionTotal.amount);
-    const parentIndices = computeHorizontalAccountParentIndices(section.accounts);
-    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(parentIndices);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(section.accounts);
     const childrenRecord = {};
     childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
         childrenRecord[parentIndex] = childIndices;
     });
     section.treeLayout = {
         rootAccountRowIndices: section.accounts
-            .map((_, i) => (parentIndices[i] === -1 ? i : -1))
+            .map((_, i) => findHorizontalAccountParentIndex(section.accounts, i) === -1 ? i : -1)
             .filter((i) => i >= 0),
         childrenRowIndicesByParent: childrenRecord,
     };
-    const siblingsPerRow = buildSiblingIndicesPerRow(section.accounts, parentIndices);
-    const hasChildFlags = computeHorizontalHasChildFlags(parentIndices);
     for (let i = 0; i < section.accounts.length; i++) {
         const row = section.accounts[i];
-        // Same column order as `report.classColumns` (see `pivotSectionToHorizontal`).
-        const classRowAmounts = row.classBalances.map((b) => b.balance.amount);
+        const classRowAmounts = report.classColumns.map((col) => {
+            const cb = row.classBalances.find((b) => b.classId === col.classId);
+            return cb?.balance.amount ?? 0;
+        });
         row.accountReportData = {
             accountId: row.accountId,
             accountName: row.accountName,
             accountType: row.accountType,
             depth: row.depth,
             balancesInTimeframe: buildHorizontalClassColumnBalancesSlice(report, classRowAmounts, row.rowTotal.amount),
-            horizontalTreeView: buildHorizontalTreeViewFromPrecomputed(section.accounts, i, parentIndices, siblingsPerRow, hasChildFlags),
+            horizontalTreeView: buildHorizontalTreeView(section.accounts, i),
         };
     }
 }
@@ -124,143 +123,64 @@ function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmou
         },
     };
 }
-/**
- * Parent index per DFS row — O(n). Matches the scan in the former
- * `findHorizontalAccountParentIndex` (depth &lt;= 2 rows have no parent).
- */
-function computeHorizontalAccountParentIndices(rows) {
-    const accountRowCount = rows.length;
-    const parentIndex = new Array(accountRowCount).fill(-1);
-    const stack = [];
-    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
-        const accountRow = rows[rowIndex];
-        if (accountRow == null) {
-            continue;
-        }
-        const d = accountRow.depth;
-        while (stack.length > 0) {
-            const topRow = rows[stack[stack.length - 1]];
-            if (topRow == null) {
-                stack.pop();
-                continue;
-            }
-            if (topRow.depth < d) {
-                break;
-            }
-            stack.pop();
-        }
-        if (d > 2 && stack.length > 0) {
-            const peek = stack[stack.length - 1];
-            const parentRow = rows[peek];
-            if (parentRow != null && parentRow.depth === d - 1) {
-                parentIndex[rowIndex] = peek;
+function findHorizontalAccountParentIndex(dfsOrderedAccountRows, childRowIndex) {
+    const childDepth = dfsOrderedAccountRows[childRowIndex].depth;
+    if (childDepth <= 2) {
+        return -1;
+    }
+    for (let earlierRowIndex = childRowIndex - 1; earlierRowIndex >= 0; earlierRowIndex--) {
+        const earlierDepth = dfsOrderedAccountRows[earlierRowIndex].depth;
+        if (earlierDepth < childDepth) {
+            if (earlierDepth === childDepth - 1) {
+                return earlierRowIndex;
             }
+            return -1;
         }
-        stack.push(rowIndex);
     }
-    return parentIndex;
+    return -1;
 }
-/** Sibling row indices (same parent + depth), in traversal order — O(n). */
-function buildSiblingIndicesPerRow(rows, parentIndices) {
-    const accountRowCount = rows.length;
-    const keyToIndices = new Map();
-    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
-        const parentRowIndex = parentIndices[rowIndex];
-        const accountRow = rows[rowIndex];
-        if (parentRowIndex == null || accountRow == null) {
-            continue;
+function getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex) {
+    const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
+    const rowDepth = dfsOrderedAccountRows[rowIndex].depth;
+    const siblings = [];
+    for (let i = 0; i < dfsOrderedAccountRows.length; i++) {
+        if (dfsOrderedAccountRows[i].depth === rowDepth &&
+            findHorizontalAccountParentIndex(dfsOrderedAccountRows, i) ===
+                parentRowIndex) {
+            siblings.push(i);
         }
-        const key = `${parentRowIndex}:${accountRow.depth}`;
-        let g = keyToIndices.get(key);
-        if (g == null) {
-            g = [];
-            keyToIndices.set(key, g);
-        }
-        g.push(rowIndex);
-    }
-    const siblingsPerRow = new Array(accountRowCount);
-    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
-        const parentRowIndex = parentIndices[rowIndex];
-        const accountRow = rows[rowIndex];
-        if (parentRowIndex == null || accountRow == null) {
-            siblingsPerRow[rowIndex] = [rowIndex];
-            continue;
-        }
-        const key = `${parentRowIndex}:${accountRow.depth}`;
-        const group = keyToIndices.get(key);
-        siblingsPerRow[rowIndex] = group != null ? group : [rowIndex];
     }
-    return siblingsPerRow;
+    return siblings;
 }
-function computeHorizontalHasChildFlags(parentIndices) {
-    const rowCount = parentIndices.length;
-    const flags = new Array(rowCount).fill(false);
-    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-        const parentRowIndex = parentIndices[rowIndex];
-        if (parentRowIndex != null &&
-            parentRowIndex >= 0 &&
-            parentRowIndex < rowCount) {
-            flags[parentRowIndex] = true;
-        }
-    }
-    return flags;
+function horizontalAccountHasChildRows(dfsOrderedAccountRows, parentRowIndex) {
+    return dfsOrderedAccountRows.some((_, rowIndex) => findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex) ===
+        parentRowIndex);
 }
-function buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
-    const chain = [];
+function buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex) {
+    const ancestorRowIndicesRootToLeaf = [];
     let walkRowIndex = currentRowIndex;
     while (walkRowIndex >= 0) {
-        chain.unshift(walkRowIndex);
-        const parentRowIndex = parentIndices[walkRowIndex];
-        if (parentRowIndex == null) {
-            break;
-        }
-        walkRowIndex = parentRowIndex;
+        ancestorRowIndicesRootToLeaf.unshift(walkRowIndex);
+        walkRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, walkRowIndex);
     }
-    return chain.map((rowIndex) => {
-        const accountRow = dfsOrderedAccountRows[rowIndex];
-        const siblingIndices = siblingsPerRow[rowIndex];
-        const hasChild = hasChildFlags[rowIndex];
-        if (accountRow == null || siblingIndices == null) {
-            return {
-                depth: 0,
-                hasSibling: false,
-                hasChildren: hasChild === true,
-                isLastNode: true,
-                name: '',
-            };
-        }
+    return ancestorRowIndicesRootToLeaf.map((rowIndex) => {
+        const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex);
         return {
-            depth: accountRow.depth - 2,
+            depth: dfsOrderedAccountRows[rowIndex].depth - 2,
             hasSibling: siblingIndices.length > 1,
-            hasChildren: hasChild === true,
+            hasChildren: horizontalAccountHasChildRows(dfsOrderedAccountRows, rowIndex),
             isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
-            name: accountRow.accountName,
+            name: dfsOrderedAccountRows[rowIndex].accountName,
         };
     });
 }
-function buildHorizontalTreeViewFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
-    const siblingIndices = siblingsPerRow[currentRowIndex];
-    const accountRow = dfsOrderedAccountRows[currentRowIndex];
-    const hasChildrenFlag = hasChildFlags[currentRowIndex];
-    const treeDepth = accountRow != null ? Math.max(0, accountRow.depth - 2) : 0;
-    const hasChildren = hasChildrenFlag === true;
-    const sibs = siblingIndices ?? [currentRowIndex];
-    return {
-        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags),
-        treeDepth,
-        hasChildren,
-        hasSiblings: sibs.length > 1,
-        isLeaf: !hasChildren,
-        isLastNode: currentRowIndex === sibs[sibs.length - 1],
-    };
-}
-function buildHorizontalAccountChildIndicesByParent(parentIndices) {
+function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
     const childIndicesByParentRowIndex = new Map();
-    for (let rowIndex = 0; rowIndex < parentIndices.length; rowIndex++) {
-        const parentRowIndex = parentIndices[rowIndex];
-        if (parentRowIndex != null && parentRowIndex >= 0) {
+    for (let rowIndex = 0; rowIndex < dfsOrderedAccountRows.length; rowIndex++) {
+        const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
+        if (parentRowIndex >= 0) {
             let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
-            if (childRowIndices == null) {
+            if (childRowIndices === undefined) {
                 childRowIndices = [];
                 childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
             }
@@ -269,3 +189,16 @@ function buildHorizontalAccountChildIndicesByParent(parentIndices) {
     }
     return childIndicesByParentRowIndex;
 }
+function buildHorizontalTreeView(dfsOrderedAccountRows, currentRowIndex) {
+    const treeDepth = Math.max(0, dfsOrderedAccountRows[currentRowIndex].depth - 2);
+    const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, currentRowIndex);
+    const hasChildren = horizontalAccountHasChildRows(dfsOrderedAccountRows, currentRowIndex);
+    return {
+        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex),
+        treeDepth,
+        hasChildren,
+        hasSiblings: siblingIndices.length > 1,
+        isLeaf: !hasChildren,
+        isLastNode: currentRowIndex === siblingIndices[siblingIndices.length - 1],
+    };
+}

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

@@ -31,6 +31,7 @@ const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pipe((0, o
             savedRecurringEndDate: task.recurringEndDate,
             recurringStartDate: task.recurringStartDate,
             timeSpent: task.timeSpent,
+            isPrivate: task.isPrivate,
         };
         const actions = [
             (0, taskDetailReducer_1.saveTaskUpdatesToLocalStore)({ taskDetailLocalData, taskId }),

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

@@ -98,5 +98,6 @@ const prepareTaskPayload = (state, taskId, taskGroupId) => {
         sync_token: syncToken,
         task_group_ids: taskGroupId != null ? [taskGroupId] : [],
         time_spent: (0, formatMinutesToFromHHMM_1.convertHHMMStrToMinutes)(localData.timeSpent),
+        ...(taskId == null ? { is_private: localData.isPrivate ?? false } : {}),
     };
 };

package/lib/view/taskManager/taskDetailView/taskDetail.d.ts

@@ -32,6 +32,7 @@ export interface EditTaskLocalData {
     timeSpent: string;
     type: TaskType;
     dueDate?: ZeniDate;
+    isPrivate?: boolean;
     recurringFrequency?: RecurringFrequencyType;
     recurringStartDate?: ZeniDate;
     savedRecurringEndDate?: ZeniDate;

package/lib/view/taskManager/taskListView/taskList.d.ts

@@ -45,7 +45,7 @@ export interface TaskListUIState extends SpendManagementUIState {
     searchText: string;
     sortKey: TaskListViewSortKey;
 }
-declare const toTaskListSortKeyType: (v: string) => "status" | "name" | "dueDate" | "tag" | "priority" | "timeSpent" | "assignee" | "creationDate";
+declare const toTaskListSortKeyType: (v: string) => "status" | "name" | "dueDate" | "tag" | "priority" | "timeSpent" | "assignee" | "creationDate" | "visibility";
 export declare type TaskListViewSortKey = ReturnType<typeof toTaskListSortKeyType>;
 export declare const TASK_LIST_FILTER_CATEGORIES: TaskListFilterCategoryOption[];
 interface TaskListFilterCategoryOption {

package/lib/view/taskManager/taskListView/taskList.js

@@ -32,6 +32,7 @@ const ALL_TASK_LIST_SORT_KEYS = [
     'status',
     'priority',
     'timeSpent',
+    'visibility',
 ];
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const toTaskListSortKeyType = (v) => (0, stringToUnion_1.stringToUnion)(v, ALL_TASK_LIST_SORT_KEYS);

package/lib/view/taskManager/taskListView/taskListReducer.d.ts

@@ -23,10 +23,10 @@ export declare const fetchTaskListPage: import("@reduxjs/toolkit").ActionCreator
     filters: TaskListFilters;
 }, "taskList/updateTaskFilters">, updateTaskListOnNewGroupCreationSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     newTaskGroup: TaskGroupPayload;
-}, "taskList/updateTaskListOnNewGroupCreationSuccess">, bulkUpdateTaskList: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskIds: string[], groupId: string, updates: Partial<Task>], {
+}, "taskList/updateTaskListOnNewGroupCreationSuccess">, bulkUpdateTaskList: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[taskIds: string[], groupId: string | null, updates: Partial<Task>], {
     taskIds: string[];
     updates: Partial<Task>;
-    groupId: string;
+    groupId: string | null;
 }, "taskList/bulkUpdateTaskList", never, never>, updateTasksListOnBulkUpdateTasksSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     groupId: ID | null;
     taskIds: ID[];

package/lib/view/taskManager/taskListView/taskListSelector.js

@@ -23,8 +23,12 @@ const taskDetailSelector_1 = require("../taskDetailView/taskDetailSelector");
 const taskList_1 = require("./taskList");
 const taskListReducer_1 = require("./taskListReducer");
 const isDefaultFilters = (taskListState) => {
-    return ((0, isEqual_1.default)(taskListState.filters, taskListReducer_1.initialState.filters) &&
-        taskListReducer_1.initialState.uiState.searchText === taskListState.uiState.searchText);
+    if (taskListState.uiState.searchText !== taskListReducer_1.initialState.uiState.searchText) {
+        return false;
+    }
+    const hasNoActiveFilters = taskListState.filters.categories == null ||
+        taskListState.filters.categories.length === 0;
+    return (hasNoActiveFilters || (0, isEqual_1.default)(taskListState.filters, taskListReducer_1.initialState.filters));
 };
 const sortTasksList = (tagState, tasksList, sortKey, sortOrder) => {
     const tasksInOrder = (0, orderBy_1.default)(tasksList, (task) => {
@@ -42,6 +46,8 @@ const sortTasksList = (tagState, tasksList, sortKey, sortOrder) => {
                 return taskState_1.ALL_PRIORITY_CODE.indexOf(task.priority.code);
             case 'timeSpent':
                 return task.timeSpent;
+            case 'visibility':
+                return task.isPrivate ? 1 : 0;
             case 'name':
             default:
                 return task.name.toLowerCase();

package/package.json

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