es-grid-template 1.9.62 → 1.9.64

package/es/ali-table/utils/convertColumnsChoose.d.ts

@@ -1,5 +1,5 @@
-import { TreeDataNode } from "rc-master-ui";
-import { ColumnTable } from "../../grid-component";
+import type { TreeDataNode } from "rc-master-ui";
+import type { ColumnTable } from "../../grid-component";
 export declare function convertColumnsToTreeData(columns: ColumnTable[], groupColumns?: string[], t?: any): TreeDataNode[];
 export declare function filterColumnsByField(columns: ColumnTable[], fieldList: string[]): ColumnTable[];
 export declare function filterVisibleColumns(columns: ColumnTable[]): ColumnTable[];

package/es/ali-table/utils/convertColumnsChoose.js

@@ -1,5 +1,3 @@
-// import type { ColumnTable } from "../../table-component"
-
 export function convertColumnsToTreeData(columns, groupColumns, t) {
   if (!columns) {
     return [];
@@ -57,6 +55,7 @@ export function filterColumnsByField(columns, fieldList) {
       if (fieldSet.has(col.field) || nextChildren && nextChildren.length) {
         result.push({
           ...col,
+          visible: true,
           ...(nextChildren ? {
             children: nextChildren
           } : {})

package/es/ali-table/utils/utility.d.ts

@@ -1,4 +1,4 @@
-import type { FilterItem, Sorter } from "../../grid-component/type";
+import type { AnyObject, ColumnTable, FilterItem, RowDnd, Sorter } from "../../grid-component/type";
 type PreparedFilter = FilterItem & {
     normalizedValue: any;
     operatorLower: string;
@@ -9,4 +9,19 @@ export declare function sortData1(data: any[], sorter: Sorter[]): any[];
 export declare function sortData(data: any[], sorter: Sorter[]): any[];
 export declare function filterDataByColumns1(data: any[], queries: FilterItem[] | undefined, sorter: Sorter[] | undefined, keysFilter: string[] | undefined, ignoreAccents?: boolean): any[];
 export declare const getMaxDepth: (data: any[]) => number;
+export declare const addRowIdArray: (inputArray: any[]) => any[];
+export declare const unFlattenData: <RecordType extends AnyObject = AnyObject>(data: RecordType[]) => RecordType[];
+export declare const flattenArray: <RecordType extends AnyObject = AnyObject>(arr: any[]) => RecordType[];
+export declare function updateOrInsert1(dataArray: any[], dataFilter: any[]): any[];
+export declare function updateOrInsert3<T extends {
+    rowId: PropertyKey;
+}>(dataArray: T[], dataFilter: Partial<T>[]): T[];
+type Row = {
+    rowId: number;
+    [key: string]: any;
+};
+export declare function updateOrInsert<T extends Row>(dataArray: T[], dataFilter: Partial<T>[]): T[];
+export declare function filterVisibleColumns<T extends ColumnTable>(columns: T[]): T[];
+export declare const sortByType: (arr: ColumnTable[], rowDnd?: RowDnd) => ColumnTable[];
+export declare function getVisibleColumnFields<T extends ColumnTable>(columns: T[]): string[];
 export {};

package/es/ali-table/utils/utility.js

@@ -1,4 +1,4 @@
-import { compareDates, compareValues, convertFomatedDateToDate, getSortValue, isDate, isDateString, isDateValue, parseToDate, removeVietnameseTones } from "../../table-component/hook/utils";
+import { compareDates, compareValues, convertFomatedDateToDate, getSortValue, isDate, isDateString, isDateValue, newGuid, parseToDate, removeVietnameseTones } from "../../table-component/hook/utils";
 const prepareFilters = (queries, ignoreAccents = true) => {
   return queries.map(query => {
     const {
@@ -252,4 +252,444 @@ export const getMaxDepth = data => {
     }
   }
   return maxDepth;
-};
+};
+export const addRowIdArray = inputArray => {
+  if (!inputArray || inputArray.length === 0) return [];
+  const result = new Array(inputArray.length);
+  const pending = [];
+  for (let index = inputArray.length - 1; index >= 0; index -= 1) {
+    pending.push({
+      source: inputArray[index],
+      target: result,
+      index
+    });
+  }
+  while (pending.length > 0) {
+    const {
+      source,
+      target,
+      index,
+      parentId
+    } = pending.pop();
+    const rowId = source.id ?? source.rowId ?? newGuid();
+    const node = {
+      ...source,
+      rowId,
+      ...(parentId !== undefined && source.parentId == null ? {
+        parentId
+      } : {})
+    };
+    target[index] = node;
+    if (Array.isArray(source.children) && source.children.length > 0) {
+      const children = new Array(source.children.length);
+      node.children = children;
+      for (let childIndex = source.children.length - 1; childIndex >= 0; childIndex -= 1) {
+        pending.push({
+          source: source.children[childIndex],
+          target: children,
+          index: childIndex,
+          parentId: rowId
+        });
+      }
+    }
+  }
+  return result;
+};
+export const unFlattenData = data => {
+  if (!data || data.length === 0) return [];
+  const idToNodeMap = new Map();
+  for (let index = 0; index < data.length; index += 1) {
+    const item = data[index];
+    idToNodeMap.set(item.rowId, {
+      ...item
+    });
+  }
+  const tree = [];
+  for (let index = 0; index < data.length; index += 1) {
+    const item = data[index];
+    const currentNode = idToNodeMap.get(item.rowId);
+    if (!currentNode || !item.parentId) {
+      if (currentNode) tree.push(currentNode);
+      continue;
+    }
+    const parentNode = idToNodeMap.get(item.parentId);
+    if (parentNode) {
+      const parentWithChildren = parentNode;
+      const children = parentWithChildren.children ?? (parentWithChildren.children = []);
+      children.push(currentNode);
+    } else {
+      tree.push(currentNode);
+    }
+  }
+  return tree;
+};
+export const flattenArray = arr => {
+  if (!arr) {
+    return [];
+  }
+  const result = [];
+  const pending = [...arr].reverse();
+  while (pending.length > 0) {
+    const item = pending.pop();
+    if (!item) continue;
+    const {
+      children,
+      ...rest
+    } = item;
+    result.push(rest);
+    if (Array.isArray(children)) {
+      for (let index = children.length - 1; index >= 0; index -= 1) {
+        pending.push(children[index]);
+      }
+    }
+  }
+  return result;
+};
+export function updateOrInsert1(dataArray, dataFilter) {
+  const nodesByRowId = new Map();
+  let head;
+  let tail;
+  for (const item of dataArray) {
+    const node = {
+      item,
+      next: undefined
+    };
+    if (!head) head = node;
+    if (tail) tail.next = node;
+    tail = node;
+
+    // Preserve findIndex semantics when duplicate rowId values exist.
+    if (!nodesByRowId.has(item.rowId)) {
+      nodesByRowId.set(item.rowId, node);
+    }
+  }
+  for (let index = 0; index < dataFilter.length; index += 1) {
+    const filterItem = dataFilter[index];
+    const existingNode = nodesByRowId.get(filterItem.rowId);
+    if (existingNode) {
+      existingNode.item = {
+        ...existingNode.item,
+        ...filterItem
+      };
+      continue;
+    }
+    const node = {
+      item: filterItem,
+      next: undefined
+    };
+    nodesByRowId.set(filterItem.rowId, node);
+    const previousItem = dataFilter[index - 1];
+    const previousNode = previousItem ? nodesByRowId.get(previousItem.rowId) : undefined;
+    if (previousNode) {
+      node.next = previousNode.next;
+      previousNode.next = node;
+      if (tail === previousNode) tail = node;
+    } else {
+      if (tail) tail.next = node;else head = node;
+      tail = node;
+    }
+  }
+  const result = [];
+  let current = head;
+  while (current) {
+    result.push(current.item);
+    current = current.next;
+  }
+  return result;
+}
+
+// export const addRowIdArray = (inputArray: any[]) => {
+//   if (!inputArray || inputArray.length === 0) return []
+
+//   const result = new Array<any>(inputArray.length)
+//   const pending: { source: any, target: any[], index: number, parentId?: any }[] = []
+
+//   for (let index = inputArray.length - 1; index >= 0; index -= 1) {
+//     pending.push({ source: inputArray[index], target: result, index })
+//   }
+
+//   while (pending.length > 0) {
+//     const { source, target, index, parentId } = pending.pop() as {
+//       source: any
+//       target: any[]
+//       index: number
+//       parentId?: any
+//     }
+
+//     const rowId = source.id ?? source.rowId ?? newGuid()
+//     const node = {
+//       ...source,
+//       rowId,
+//       ...(parentId !== undefined && source.parentId == null ? { parentId } : {})
+//     }
+//     target[index] = node
+
+//     if (Array.isArray(source.children) && source.children.length > 0) {
+//       const children = new Array<any>(source.children.length)
+//       node.children = children
+
+//       for (let childIndex = source.children.length - 1; childIndex >= 0; childIndex -= 1) {
+//         pending.push({
+//           source: source.children[childIndex],
+//           target: children,
+//           index: childIndex,
+//           parentId: rowId
+//         })
+//       }
+//     }
+//   }
+
+//   return result
+// }
+
+export function updateOrInsert3(dataArray, dataFilter) {
+  const dataLength = dataArray.length;
+  const filterLength = dataFilter.length;
+
+  // rowId -> index trong data
+  const indexByRowId = new Map();
+
+  // next[index] = index tiếp theo
+  // -1 = không có next
+  const next = new Int32Array(dataLength + filterLength);
+  next.fill(-1);
+
+  // Data hiện tại
+  const items = new Array(dataLength + filterLength);
+  let head = dataLength > 0 ? 0 : -1;
+  let tail = dataLength - 1;
+  for (let i = 0; i < dataLength; i++) {
+    const item = dataArray[i];
+    items[i] = item;
+
+    // Preserve findIndex semantics:
+    // duplicate rowId -> giữ item đầu tiên
+    if (!indexByRowId.has(item.rowId)) {
+      indexByRowId.set(item.rowId, i);
+    }
+    if (i > 0) {
+      next[i - 1] = i;
+    }
+  }
+  let size = dataLength;
+  for (let i = 0; i < filterLength; i++) {
+    const filterItem = dataFilter[i];
+    const rowId = filterItem.rowId;
+    const existingIndex = indexByRowId.get(rowId);
+
+    // =========================
+    // UPDATE
+    // =========================
+    if (existingIndex !== undefined) {
+      const existingItem = items[existingIndex];
+
+      // Nếu chấp nhận mutate object -> nhanh nhất
+      Object.assign(existingItem, filterItem);
+      continue;
+    }
+
+    // =========================
+    // INSERT
+    // =========================
+    const newIndex = size++;
+    items[newIndex] = filterItem;
+    next[newIndex] = -1;
+    indexByRowId.set(rowId, newIndex);
+
+    // previous item trong dataFilter
+    const previousItem = dataFilter[i - 1];
+    if (previousItem) {
+      const previousIndex = indexByRowId.get(previousItem.rowId);
+      if (previousIndex !== undefined) {
+        next[newIndex] = next[previousIndex];
+        next[previousIndex] = newIndex;
+        if (tail === previousIndex) {
+          tail = newIndex;
+        }
+        continue;
+      }
+    }
+
+    // Không có previous -> append cuối
+    if (tail !== -1) {
+      next[tail] = newIndex;
+    } else {
+      head = newIndex;
+    }
+    tail = newIndex;
+  }
+
+  // =========================
+  // BUILD RESULT
+  // =========================
+  const result = new Array(size);
+  let current = head;
+  let resultIndex = 0;
+  while (current !== -1) {
+    result[resultIndex++] = items[current];
+    current = next[current];
+  }
+  return result;
+}
+export function updateOrInsert(dataArray, dataFilter) {
+  const dataLength = dataArray.length;
+  const filterLength = dataFilter.length;
+  if (filterLength === 0) {
+    return dataArray;
+  }
+
+  // =========================================================
+  // Fast lookup bằng Map
+  // =========================================================
+
+  const indexByRowId = new Map();
+  for (let i = 0; i < dataLength; i++) {
+    const rowId = dataArray[i].rowId;
+    if (!indexByRowId.has(rowId)) {
+      indexByRowId.set(rowId, i);
+    }
+  }
+
+  // =========================================================
+  // Xác định update + insert
+  // =========================================================
+
+  const inserted = new Map();
+  for (let i = 0; i < filterLength; i++) {
+    const item = dataFilter[i];
+    const rowId = item.rowId;
+    const index = indexByRowId.get(rowId);
+    if (index !== undefined) {
+      // UPDATE trực tiếp
+      Object.assign(dataArray[index], item);
+    } else {
+      inserted.set(rowId, item);
+    }
+  }
+
+  // Không insert
+  if (inserted.size === 0) {
+    return dataArray;
+  }
+
+  // =========================================================
+  // Build insertion map
+  // =========================================================
+
+  const insertAfter = new Map();
+  let pending = [];
+  for (let i = 0; i < filterLength; i++) {
+    const item = dataFilter[i];
+    const rowId = item.rowId;
+    if (!inserted.has(rowId)) {
+      pending = [];
+      continue;
+    }
+    pending.push(item);
+    const previous = i > 0 ? dataFilter[i - 1] : undefined;
+    if (previous) {
+      const previousId = previous.rowId;
+      let list = insertAfter.get(previousId);
+      if (!list) {
+        list = [];
+        insertAfter.set(previousId, list);
+      }
+      list.push(item);
+      pending = [];
+    }
+  }
+
+  // =========================================================
+  // Build result 1 lần
+  // =========================================================
+
+  const result = new Array(dataLength + inserted.size);
+  let resultIndex = 0;
+  for (let i = 0; i < dataLength; i++) {
+    const item = dataArray[i];
+    result[resultIndex++] = item;
+    const rows = insertAfter.get(item.rowId);
+    if (rows) {
+      for (let j = 0; j < rows.length; j++) {
+        result[resultIndex++] = rows[j];
+      }
+    }
+  }
+  return result;
+}
+export function filterVisibleColumns(columns) {
+  let changed = false;
+  const result = [];
+  for (const column of columns) {
+    if (column.visible === false) {
+      changed = true;
+      continue;
+    }
+    if (column.children?.length) {
+      const children = filterVisibleColumns(column.children);
+      if (children !== column.children) {
+        changed = true;
+        result.push({
+          ...column,
+          children
+        });
+      } else {
+        result.push(column);
+      }
+    } else {
+      result.push(column);
+    }
+  }
+  return changed ? result : columns;
+}
+
+// Sorting function
+export const sortByType = (arr, rowDnd) => {
+  const colDnd = {
+    field: 'drag-handle',
+    width: 50,
+    fixed: 'left',
+    headerText: '',
+    allowFiltering: false,
+    allowResizing: false,
+    allowSortering: false
+  };
+  const cols = rowDnd?.enabled ? [{
+    ...colDnd
+  }, ...arr] : [...arr];
+
+  // const visibleColumns = filterVisibleColumns(cols)
+
+  if (cols) {
+    return cols.sort((a, b) => {
+      if ((a.fixed ?? a.fixedType) === 'left' && (b.fixed ?? b.fixedType) !== 'left') {
+        return -1;
+      } else if ((a.fixed ?? a.fixedType) !== 'left' && (b.fixed ?? b.fixedType) === 'left') {
+        return 1;
+      } else if ((a.fixed ?? a.fixedType) === 'right' && (b.fixed ?? b.fixedType) !== 'right') {
+        return 1;
+      } else if ((a.fixed ?? a.fixedType) !== 'right' && (b.fixed ?? b.fixedType) === 'right') {
+        return -1;
+      }
+      return 0;
+    });
+  } else {
+    return [];
+  }
+};
+export function getVisibleColumnFields(columns) {
+  const result = [];
+  const traverse = items => {
+    for (const column of items) {
+      if (column?.visible === false) continue;
+      if (column.field) {
+        result.push(column.field);
+      }
+      if (column.children && column.children?.length) {
+        traverse(column.children);
+      }
+    }
+  };
+  traverse(columns);
+  return result;
+}

package/es/grid-component/type.d.ts

@@ -825,8 +825,8 @@ export type RangeState = {
     endRowIndex: number | undefined;
     startColIndex: number | undefined;
     endColIndex: number | undefined;
-    rowIds: string[];
-    colIds: string[];
+    rowIds?: string[];
+    colIds?: string[];
     type?: any;
 };
 export type Sorter = {