@globalpayments/vega 2.55.1 → 2.57.0

package/dist/collection/components/vega-table/slimmers/controllers/dto/column-structure-model.js

@@ -0,0 +1,238 @@
+import { isVegaTableColumnGroupingModelType } from '../../../../../types/type-guard';
+/**
+ * Represents the hierarchical structure of table columns (including group columns).
+ *
+ * Responsibilities:
+ * - Build the tree from flat or grouped column configs (.from / .fromGroupColumns)
+ * - Provide traversal helpers (iterator / dfs) with caching
+ * - Provide utility checks (isLeaf, hasGroupColumn, hasPinnedColumn)
+ * - Produce leaf column configs for rendering (generateColumnConfigByLeaves)
+ * - Order root children by pinned type for rendering (orderChildrenByPinned)
+ */
+export class ColumnStructureModel {
+  /**
+   * Constructor for ColumnStructureModel.
+   *
+   * @param {string} key - Unique key for the column.
+   * @param {number} level - Row level of this column (root uses ROOT_LEVEL).
+   * @param {ColumnStructureModel} [parent] - Optional parent node.
+   * @param {string} [label] - Optional display label for the column.
+   * @param {VegaTablePinnedType} [pinned] - Optional pinned metadata ('left'|'right'|null).
+   */
+  constructor(key, level, parent, label, pinned) {
+    this.key = key;
+    this.level = level;
+    this.parent = parent;
+    this.label = label;
+    this.pinned = pinned;
+    this.leaves = [];
+    this.orderedChildren = [];
+    this.iteratorCacheMap = new Map();
+  }
+  /**
+   * Creates the root ColumnStructureModel from column configs.
+   *
+   * @param {VegaTableColumnConfig[]} columnsConfig - Array of column configs.
+   * @param {Nullable<VegaTableGroupColumnConfig[]>} groupColumnConfig - Optional grouping configuration.
+   * @returns {ColumnStructureModel} Root column structure model.
+   */
+  static from(columnsConfig, groupColumnConfig) {
+    const rootModel = new ColumnStructureModel(this.ROOT_KEY, ColumnStructureModel.ROOT_LEVEL);
+    if (groupColumnConfig) {
+      rootModel.children = this.fromGroupColumns(rootModel, groupColumnConfig);
+      return rootModel;
+    }
+    else if (columnsConfig) {
+      rootModel.children = columnsConfig.map((column) => new ColumnStructureModel(column.key || column.prop || column.label, 0, rootModel, null, column.pinned));
+      return rootModel;
+    }
+    else {
+      rootModel.children = [];
+      return rootModel;
+    }
+  }
+  /**
+   * Recursively creates ColumnStructureModel children from group column configs.
+   *
+   * @param {ColumnStructureModel} parent - Parent node for the created children.
+   * @param {VegaTableGroupColumnConfig[]} groupColumns - Array of group column configs.
+   * @param {number} level - Current row level.
+   * @returns {ColumnStructureModel[]} Array of child column structure models.
+   */
+  static fromGroupColumns(parent, groupColumns, level = 0) {
+    if (groupColumns && groupColumns.length > 0) {
+      return groupColumns.map((groupColumn) => {
+        if (isVegaTableColumnGroupingModelType(groupColumn)) {
+          const current = new ColumnStructureModel(groupColumn.key, level, parent, groupColumn.label, groupColumn.pinned);
+          current.children = this.fromGroupColumns(current, groupColumn.children, level + 1);
+          return current;
+        }
+        else {
+          return new ColumnStructureModel(groupColumn.key, level, parent);
+        }
+      });
+    }
+    return [];
+  }
+  /**
+   * Generates an array of VegaTableColumnConfig for all leaf columns.
+   *
+   * @param {VegaTableColumnConfig[]} columns - Array of all column configs.
+   * @returns {VegaTableColumnConfig[]} Array of configs for leaf columns.
+   */
+  generateColumnConfigByLeaves(columns) {
+    return this.getLeaves().map((leaf) => columns.find((column) => column.key === leaf.key || column.prop === leaf.key || column.label === leaf.key));
+  }
+  /**
+   * Compute the maximum depth (highest level value) under this node.
+   * This is useful to determine the number of header rows required for rendering.
+   *
+   * @returns {number} Maximum level found in the subtree (or 0 when empty).
+   */
+  getMaxDepth() {
+    const models = this.dfsIterator();
+    if (models.length === 0) {
+      return 0;
+    }
+    return Math.max(...models.map((model) => model.level)) + 1;
+  }
+  /**
+   * Checks if this subtree contains any group (non-leaf) columns.
+   *
+   * @returns {boolean} True if any descendant is a group column.
+   */
+  hasGroupColumn() {
+    return !!this.children.find((model) => !model.isLeaf());
+  }
+  /**
+   * Checks if this subtree contains any left pinned children.
+   *
+   * @returns {boolean} True if any immediate child has a pinned value.
+   */
+  hasLeftPinnedColumn() {
+    return !!this.children.find((model) => model.pinned === 'left');
+  }
+  /**
+   * Checks if this subtree contains any right pinned children.
+   *
+   * @returns {boolean} True if any immediate child has a pinned value.
+   */
+  hasRightPinnedColumn() {
+    return !!this.children.find((model) => model.pinned === 'right');
+  }
+  /**
+   * Checks if this node is a leaf (no children).
+   *
+   * @returns {boolean} True when this node has no children.
+   */
+  isLeaf() {
+    return !this.children || this.children.length === 0;
+  }
+  /**
+   * Return an array of nodes for this subtree using the specified traversal mode.
+   *
+   * Currently only depth-first search ('dfs') is supported. The returned array is
+   * cached per-mode to avoid repeated traversal costs.
+   *
+   * @param {IteratorMode} mode - Traversal mode to use. Defaults to 'dfs'.
+   * @returns {ColumnStructureModel[]} Array of ColumnStructureModel nodes in traversal order.
+   */
+  iterator(mode = 'dfs') {
+    if (mode === 'dfs') {
+      return this.dfsIterator();
+    }
+    return [];
+  }
+  /**
+   * Gets all leaf nodes in the subtree, with caching.
+   *
+   * Subsequent calls return the cached array until the underlying model is rebuilt.
+   *
+   * @returns {ColumnStructureModel[]} Array of leaf column models.
+   */
+  getLeaves() {
+    if (this.leaves.length > 0) {
+      return this.leaves;
+    }
+    const leaves = this.dfsIterator().filter((model) => model.isLeaf());
+    this.leaves = leaves;
+    return leaves;
+  }
+  /**
+   * For root nodes, returns children ordered by pinned type (left, none, right).
+   * For non-root nodes, returns children in their natural order.
+   *
+   * @returns {ColumnStructureModel[]} Array of child column models.
+   */
+  getOrderedChildren() {
+    if (!this.isRoot())
+      return this.children;
+    return this.orderedChildren;
+  }
+  /**
+   * Orders root children by pinned type (left, none, right) and caches the result.
+   *
+   * For non-root nodes this method returns children in their natural order.
+   *
+   * @returns {ColumnStructureModel[]} Array of ordered child column models.
+   */
+  orderChildrenByPinned() {
+    if (!this.isRoot())
+      return this.children;
+    if (this.orderedChildren.length > 0) {
+      return this.orderedChildren;
+    }
+    const leftPinned = [];
+    const noPinned = [];
+    const rightPinned = [];
+    this.children.forEach((child) => {
+      if (child.pinned === 'left') {
+        leftPinned.push(child);
+      }
+      else if (child.pinned === 'right') {
+        rightPinned.push(child);
+      }
+      else {
+        noPinned.push(child);
+      }
+    });
+    const children = [...leftPinned, ...noPinned, ...rightPinned];
+    this.orderedChildren = children;
+    return children;
+  }
+  /**
+   * Checks if this node is the root node.
+   *
+   * @returns {boolean} True if root node, false otherwise.
+   */
+  isRoot() {
+    return this.level === ColumnStructureModel.ROOT_LEVEL;
+  }
+  /**
+   * Performs a depth-first traversal of the column structure.
+   *
+   * The traversal respects root-child pinned ordering (left/no/right) for the root node.
+   * Results are cached per-node to avoid repeated recursion costs.
+   *
+   * @returns {ColumnStructureModel[]} Array of all nodes in DFS order.
+   */
+  dfsIterator() {
+    if (this.iteratorCacheMap.has('dfs')) {
+      return this.iteratorCacheMap.get('dfs');
+    }
+    const localResult = [];
+    const children = this.orderChildrenByPinned();
+    if (!this.isRoot()) {
+      localResult.push(this);
+    }
+    if (children && children.length > 0) {
+      children.forEach((child) => {
+        localResult.push(...child.dfsIterator());
+      });
+    }
+    this.iteratorCacheMap.set('dfs', localResult);
+    return localResult;
+  }
+}
+ColumnStructureModel.ROOT_LEVEL = -1;
+ColumnStructureModel.ROOT_KEY = '#root-model#';

package/dist/collection/components/vega-table/slimmers/controllers/dto/test/column-render-input-model.test.js

@@ -0,0 +1,83 @@
+import { ColumnStructureModel } from '../column-structure-model';
+import { ColumnRenderInputModel } from '../column-render-input-model';
+describe('ColumnRenderInputModel', () => {
+  const columns = [
+    { key: 'a', label: 'A' },
+    { label: 'B' },
+    { prop: 'c', label: 'C' },
+  ];
+  const groupConfig = [
+    {
+      key: 'a',
+      label: 'Group A',
+      pinned: 'left',
+      children: [{ key: 'b', label: 'B', children: [{ key: 'c' }, { key: 'd' }] }],
+    },
+    { key: 'e' },
+    { key: 'h', label: 'Group H', pinned: 'right', children: [{ key: 'i' }] },
+  ];
+  it('normal columns', () => {
+    const root = ColumnStructureModel.from(columns, null);
+    const renders = ColumnRenderInputModel.from(root);
+    expect(renders.length).toBe(3);
+    expect(renders).toMatchSnapshot();
+  });
+  it('grouped columns', () => {
+    const root = ColumnStructureModel.from(null, groupConfig);
+    const renders = ColumnRenderInputModel.from(root);
+    expect(renders.length).toBe(3);
+    expect(renders).toMatchSnapshot();
+  });
+  it('getLeaves/iterator in columns', () => {
+    const root = ColumnStructureModel.from(columns, null);
+    const renders = ColumnRenderInputModel.from(root);
+    const leaves = renders.flatMap((model) => model.getLeaves());
+    expect(leaves.map((l) => l.key)).toEqual(['a', 'B', 'c']);
+    const iterator = renders.flatMap((model) => model.iterator());
+    expect(iterator.map((l) => l.key)).toEqual(['a', 'B', 'c']);
+  });
+  it('getLeaves/iterator in groupColumns', () => {
+    const root = ColumnStructureModel.from(null, groupConfig);
+    const renders = ColumnRenderInputModel.from(root);
+    const leaves = renders.flatMap((model) => model.getLeaves());
+    expect(leaves.map((l) => l.key)).toEqual(['c', 'd', 'e', 'i']);
+    const iterator = renders.flatMap((model) => model.iterator());
+    expect(iterator.map((l) => l.key)).toEqual([
+      'a',
+      'b',
+      'c',
+      'd',
+      'e',
+      'h',
+      'i',
+    ]);
+  });
+  it('leaves cache', () => {
+    const root = ColumnStructureModel.from(columns, null);
+    const renders = ColumnRenderInputModel.from(root);
+    const first = renders[0].getLeaves();
+    const second = renders[0].getLeaves();
+    expect(first).toBe(second);
+  });
+  it('iterator cache', () => {
+    const root = ColumnStructureModel.from(columns, null);
+    const renders = ColumnRenderInputModel.from(root);
+    const first = renders[0].iterator();
+    const second = renders[0].iterator();
+    expect(first).toBe(second);
+  });
+  it('empty group columns and columns', () => {
+    const root = ColumnStructureModel.from(null, null);
+    const renders = ColumnRenderInputModel.from(root);
+    expect(renders).toEqual([]);
+    const leaves = renders.flatMap((model) => model.getLeaves());
+    const iterator = renders.flatMap((model) => model.iterator());
+    expect(leaves).toEqual([]);
+    expect(iterator).toEqual([]);
+  });
+  it('call iterator with a not supported type', () => {
+    const root = ColumnStructureModel.from(columns, null);
+    const renders = ColumnRenderInputModel.from(root);
+    expect(renders[0].iterator('not-support')).toEqual([]);
+  });
+});

package/dist/collection/components/vega-table/slimmers/controllers/dto/test/column-structure-model.test.js

@@ -0,0 +1,147 @@
+import { ColumnStructureModel } from '../column-structure-model';
+describe('ColumnStructureModel', () => {
+  it('normal columns', () => {
+    const columns = [
+      { key: 'a', label: 'A' },
+      { label: 'B' },
+      { prop: 'c', label: 'C' },
+    ];
+    const root = ColumnStructureModel.from(columns, null);
+    const keys = root.iterator().map((m) => m.key);
+    expect(keys).toEqual(['a', 'B', 'c']);
+    const leafKeys = root.getLeaves().map((l) => l.key);
+    expect(leafKeys).toEqual(['a', 'B', 'c']);
+    expect(root.hasLeftPinnedColumn()).toBe(false);
+    expect(root.hasRightPinnedColumn()).toBe(false);
+    expect(root.hasGroupColumn()).toBe(false);
+    expect(root.getMaxDepth()).toBe(1);
+    expect(root.generateColumnConfigByLeaves(columns)).toEqual([
+      { key: 'a', label: 'A' },
+      { label: 'B' },
+      { prop: 'c', label: 'C' },
+    ]);
+  });
+  it('normal columns with pinned', () => {
+    const columns = [
+      { key: 'a', label: 'A' },
+      { key: 'c', pinned: 'right', label: 'C' },
+      { key: 'b', pinned: 'left', label: 'B' },
+    ];
+    const root = ColumnStructureModel.from(columns, null);
+    const keys = root.iterator().map((m) => m.key);
+    expect(keys).toEqual(['b', 'a', 'c']);
+    const leafKeys = root.getLeaves().map((l) => l.key);
+    expect(leafKeys).toEqual(['b', 'a', 'c']);
+    expect(root.hasLeftPinnedColumn()).toBe(true);
+    expect(root.hasRightPinnedColumn()).toBe(true);
+    expect(root.hasGroupColumn()).toBe(false);
+    expect(root.getMaxDepth()).toBe(1);
+    expect(root.generateColumnConfigByLeaves(columns)).toEqual([
+      { key: 'b', label: 'B', pinned: 'left' },
+      { key: 'a', label: 'A' },
+      { key: 'c', label: 'C', pinned: 'right' },
+    ]);
+  });
+  it('group columns', () => {
+    const groupConfig = [
+      {
+        key: 'a',
+        label: 'Group A',
+        children: [{ key: 'e' }, { key: 'f' }],
+      },
+      {
+        key: 'b',
+        label: 'Group B',
+        pinned: 'right',
+        children: [{ key: 'g' }],
+      },
+      { key: 'c', label: 'Group C', pinned: 'left' },
+      { key: 'd' },
+    ];
+    const root = ColumnStructureModel.from(null, groupConfig);
+    const keys = root.iterator().map((m) => m.key);
+    expect(keys).toEqual(['c', 'a', 'e', 'f', 'd', 'b', 'g']);
+    const leafKeys = root.getLeaves().map((l) => l.key);
+    expect(leafKeys).toEqual(['c', 'e', 'f', 'd', 'g']);
+    expect(root.hasLeftPinnedColumn()).toBe(true);
+    expect(root.hasRightPinnedColumn()).toBe(true);
+    expect(root.hasGroupColumn()).toBe(true);
+    expect(root.getMaxDepth()).toBe(2);
+    expect(root.generateColumnConfigByLeaves([
+      { key: 'e', label: 'E' },
+      { key: 'c', label: 'C' },
+      { key: 'f', label: 'F' },
+      { key: 'h', label: 'H' },
+      { key: 'd', label: 'D' },
+    ])).toEqual([
+      { key: 'c', label: 'C' },
+      { key: 'e', label: 'E' },
+      { key: 'f', label: 'F' },
+      { key: 'd', label: 'D' },
+      undefined,
+    ]);
+  });
+  it('iterator cache', () => {
+    const groupConfig = [
+      {
+        key: 'a',
+        label: 'Group A',
+        children: [{ key: 'e' }, { key: 'f' }],
+      },
+      { key: 'd' },
+    ];
+    const root = ColumnStructureModel.from(null, groupConfig);
+    expect(root.iterator('bfs')).toEqual([]);
+    const first = root.iterator();
+    const second = root.iterator();
+    expect(first).toBe(second);
+  });
+  it('leaves cache', () => {
+    const groupConfig = [
+      {
+        key: 'a',
+        label: 'Group A',
+        children: [{ key: 'e' }, { key: 'f' }],
+      },
+      { key: 'd' },
+    ];
+    const root = ColumnStructureModel.from(null, groupConfig);
+    const first = root.getLeaves();
+    const second = root.getLeaves();
+    expect(first).toBe(second);
+  });
+  it('order cache', () => {
+    const groupConfig = [
+      {
+        key: 'a',
+        label: 'Group A',
+        children: [{ key: 'e' }, { key: 'f' }],
+      },
+      { key: 'c', label: 'Group C', pinned: 'left' },
+      { key: 'd' },
+    ];
+    const root = ColumnStructureModel.from(null, groupConfig);
+    const first = root['orderChildrenByPinned']();
+    const second = root['orderChildrenByPinned']();
+    expect(first).toBe(second);
+    expect(root.children[0]['orderedChildren']).toEqual([]);
+  });
+  it('handles empty inputs (no columns / groups)', () => {
+    const root = ColumnStructureModel.from([], []);
+    expect(root.children).toEqual([]);
+    expect(root.iterator()).toEqual([]);
+    expect(root.getLeaves()).toEqual([]);
+    expect(root.getMaxDepth()).toBe(0);
+    expect(root.hasGroupColumn()).toBe(false);
+    expect(root.hasLeftPinnedColumn()).toBe(false);
+    expect(root.hasRightPinnedColumn()).toBe(false);
+    expect(root.generateColumnConfigByLeaves([
+      { key: 'e', label: 'E' },
+      { key: 'c', label: 'C' },
+    ])).toEqual([]);
+  });
+  it('call iterator with a not supported type', () => {
+    const root = ColumnStructureModel.from(null, null);
+    expect(root.iterator('not-support')).toEqual([]);
+  });
+});

package/dist/collection/components/vega-table/slimmers/controllers/vega-table-column-structure-model-controller.js

@@ -0,0 +1,66 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+import { ColumnStructureModel } from './dto/column-structure-model';
+/**
+ * Controller responsible for building and keeping the ColumnStructureModel in sync
+ * with the component's `columns` and `groupColumns` properties.
+ *
+ * This slimmer maps relevant component fields and lifecycle/watch hooks to
+ * automatically rebuild the column structure when inputs change.
+ */
+export class VegaTableColumnStructureModelController extends VegaSlimmer {
+  /**
+   * Component lifecycle hook mapped to the host's componentWillLoad.
+   * Initializes the ColumnStructureModel prior to initial render.
+   */
+  componentWillLoad() {
+    this.setColumnStructureModel();
+  }
+  /**
+   * Watch handler mapped to the host's watchColumns.
+   * Rebuilds the ColumnStructureModel when `columns` changes.
+   */
+  watchColumns() {
+    this.setColumnStructureModel();
+  }
+  /**
+   * Watch handler mapped to the host's watchGroupColumns.
+   * Rebuilds the ColumnStructureModel when `groupColumns` changes.
+   */
+  watchGroupColumns() {
+    this.setColumnStructureModel();
+  }
+  /**
+   * Build and assign the ColumnStructureModel from current `columns` and `groupColumns`.
+   * Uses `ColumnStructureModel.from` which returns a root model representing the column tree.
+   */
+  setColumnStructureModel() {
+    this.columnStructureModel = ColumnStructureModel.from(this.columns, this.groupColumns);
+  }
+}
+__decorate([
+  MapToComponentField()
+], VegaTableColumnStructureModelController.prototype, "host", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableColumnStructureModelController.prototype, "columns", void 0);
+__decorate([
+  MapToComponentField()
+], VegaTableColumnStructureModelController.prototype, "groupColumns", void 0);
+__decorate([
+  MapToComponentField({ writable: true })
+], VegaTableColumnStructureModelController.prototype, "columnStructureModel", void 0);
+__decorate([
+  MapToComponentMethod('componentWillLoad')
+], VegaTableColumnStructureModelController.prototype, "componentWillLoad", null);
+__decorate([
+  MapToComponentMethod('watchColumns')
+], VegaTableColumnStructureModelController.prototype, "watchColumns", null);
+__decorate([
+  MapToComponentMethod('watchGroupColumns')
+], VegaTableColumnStructureModelController.prototype, "watchGroupColumns", null);