@zeniai/client-epic-state 4.20.0-beta0ND → 4.20.0-beta0RR

package/lib/entity/task/taskPayload.d.ts

@@ -9,6 +9,7 @@ export interface TaskPayload {
     file_ids: string[];
     is_archived: boolean;
     is_deleted: boolean;
+    is_private: boolean;
     name: string;
     priority: AllowedValueWithCodePayload;
     recurring_end_date: string | null;

package/lib/entity/task/taskPayload.js

@@ -13,6 +13,7 @@ const mapTaskPayloadToTask = (payload) => ({
     fileIds: payload.file_ids,
     isArchived: payload.is_archived,
     isDeleted: payload.is_deleted,
+    isPrivate: payload.is_private,
     name: payload.name,
     syncToken: payload.sync_token ?? '',
     priority: {

package/lib/entity/task/taskState.d.ts

@@ -11,6 +11,7 @@ export interface Task {
     id: ID;
     isArchived: boolean;
     isDeleted: boolean;
+    isPrivate: boolean;
     name: string;
     priority: TaskPriority;
     status: TaskStatus;

package/lib/esm/entity/task/taskPayload.js

@@ -10,6 +10,7 @@ export const mapTaskPayloadToTask = (payload) => ({
     fileIds: payload.file_ids,
     isArchived: payload.is_archived,
     isDeleted: payload.is_deleted,
+    isPrivate: payload.is_private,
     name: payload.name,
     syncToken: payload.sync_token ?? '',
     priority: {

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

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

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector.js

@@ -49,11 +49,16 @@ export const getProfitAndLossClassesHorizontalView = (filter, accountState, clas
     const calculatedSections = {};
     let reportCurrency = defaultCustomerCurrency;
     if (fetchState.fetchState === 'Completed' && selectedPeriod != null) {
+        // Get section reports using existing selector infrastructure
+        const sectionReports = {};
+        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
+            sectionReports[sectionId] = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
+        });
         reportCurrency =
             profitAndLossClassesViewState.currency ?? 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 = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
+            const sectionReport = sectionReports[sectionId];
             if (sectionReport != null) {
                 sections[sectionId] = pivotSectionToHorizontal(sectionReport, classColumns, SECTION_TITLES[sectionId] ?? sectionId, reportCurrency);
             }
@@ -256,7 +261,7 @@ function sumBalancesInSlice(balances) {
     if (balances.length === 0) {
         return 0;
     }
-    const summed = getSummationFreeRangeTotalBalance(balances);
+    const summed = getSummationFreeRangeTotalBalance([...balances]);
     return summed?.balance.amount ?? 0;
 }
 /**

package/lib/esm/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -25,31 +25,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),
         };
     }
 }
@@ -121,157 +120,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 topIdx = stack[stack.length - 1];
-            if (topIdx == null) {
-                break;
-            }
-            const topRow = rows[topIdx];
-            if (topRow == null) {
-                stack.pop();
-                continue;
-            }
-            if (topRow.depth < d) {
-                break;
-            }
-            stack.pop();
-        }
-        if (d <= 2) {
-            parentIndex[rowIndex] = -1;
-        }
-        else if (stack.length === 0) {
-            parentIndex[rowIndex] = -1;
-        }
-        else {
-            const peek = stack[stack.length - 1];
-            if (peek == null) {
-                parentIndex[rowIndex] = -1;
-            }
-            else {
-                const parentRow = rows[peek];
-                parentIndex[rowIndex] =
-                    parentRow != null && parentRow.depth === d - 1 ? peek : -1;
+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;
-        }
-        const key = `${parentRowIndex}:${accountRow.depth}`;
-        let g = keyToIndices.get(key);
-        if (g == null) {
-            g = [];
-            keyToIndices.set(key, g);
+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);
         }
-        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);
             }
@@ -280,3 +186,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/esm/view/taskManager/taskDetailView/epics/initializeTaskToLocalStoreEpic.js

@@ -25,6 +25,7 @@ export const initializeTaskToLocalStoreEpic = (actions$, state$) => actions$.pip
             savedRecurringEndDate: task.recurringEndDate,
             recurringStartDate: task.recurringStartDate,
             timeSpent: task.timeSpent,
+            isPrivate: task.isPrivate,
         };
         const actions = [
             saveTaskUpdatesToLocalStore({ taskDetailLocalData, taskId }),

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

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

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

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

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

@@ -17,8 +17,12 @@ import { allTaskPriority, allTaskStatus, } from '../taskDetailView/taskDetailSel
 import { DUE_DATE_GROUP_KEYS, } from './taskList';
 import { initialState } from './taskListReducer';
 const isDefaultFilters = (taskListState) => {
-    return (isEqual(taskListState.filters, initialState.filters) &&
-        initialState.uiState.searchText === taskListState.uiState.searchText);
+    if (taskListState.uiState.searchText !== initialState.uiState.searchText) {
+        return false;
+    }
+    const hasNoActiveFilters = taskListState.filters.categories == null ||
+        taskListState.filters.categories.length === 0;
+    return (hasNoActiveFilters || isEqual(taskListState.filters, initialState.filters));
 };
 const sortTasksList = (tagState, tasksList, sortKey, sortOrder) => {
     const tasksInOrder = orderBy(tasksList, (task) => {