@heartlandone/vega 2.83.0 → 2.85.0

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-renderer.d.ts

@@ -5,10 +5,15 @@ import { RTETableBlock } from '../dto/table-block';
  * Renderer for the RTETableBlock.
  */
 export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
+  private tableToolbar;
   /**
    * @inheritDoc
    */
   doRender(h: VegaRTECreateElementFunction, renderData: RTETableBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * Destroys the table toolbar popover.
+   */
+  destroy(): void;
   /**
    * @inheritDoc
    */
@@ -35,4 +40,14 @@ export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    * @param {HTMLElement} tableRef - The table trigger element used to locate the rich text content container.
    */
   private destroySelectionAnchor;
+  /**
+   * Renders the table setting popover toolbar if the context is editable.
+   *
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private renderTableToolbar;
+  /**
+   * Destroys the table setting popover toolbar if it exists.
+   */
+  private destroyTableToolbar;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-setting-popover-renderer.d.ts

@@ -1,47 +1,50 @@
-import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
 import { RTETableBlock } from '../dto/table-block';
-import { TableDynamicPopoverRenderer } from './table-dynamic-popover-renderer';
 import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
+import { RTERenderContext } from '../../../interface';
 /**
- * Centralizes the popover rendering and interaction logic for table settings.
+ * Shared popover renderer for table settings.
  */
 export declare class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
   private popoverRef;
   private tableSettingRef;
-  private tableData;
+  private tableBlock;
   private tableDynamicPopover;
-  private popoverShow;
+  private popoverContainer;
   private settingHandlers;
+  constructor(renderContext: RTERenderContext);
   /**
-   * Show table setting popover when table is clicked.
-   * Only the popover belonging to the nearest table will be shown,
-   * which avoids outer tables showing their popover when an inner (nested) table is clicked.
+   * Destroys the dynamic popover renderer and removes the container from the DOM.
+   */
+  destroy(): void;
+  /**
+   * Re-targets and shows the table setting popover for the clicked table.
    *
-   * @param {MouseEvent} event - The MouseEvent that triggered the table action
-   * @param {HTMLElement} trigger - The element that can triggered the popover open.
+   * @param {MouseEvent} event - The MouseEvent that triggered the click.
+   * @param {RTETableBlock} tableBlock - The clicked table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the clicked table's DOM element.
    */
-  handleTableClick: (event: MouseEvent, trigger: HTMLElement) => void;
+  handleTableClick: (event: MouseEvent, tableBlock: RTETableBlock, getTableRef: () => HTMLElement) => void;
   /**
    * Sync the selected cells from the table selection to the table setting component.
    */
   syncSelectedCells: () => void;
   /**
-   * Render the popover host and inject the table-setting component with refs wired up.
-   *
-   * @param {VegaRTECreateElementFunction} h - The create element function.
-   * @param {RTETableBlock} renderData - The table block to render.
-   * @param {() => HTMLElement} getTableRef - Current table DOM reference
-   * @param {TableDynamicPopoverRenderer} tableDynamicPopover - Renderer used to show
-   *  the secondary table popover (for example, table-properties-specific settings).
-   * @returns {VegaRTERenderResult} The rendered popover structure.
+   * Builds the popover DOM and appends it to the RTE host. Idempotent: subsequent calls are no-ops.
    */
-  render(h: VegaRTECreateElementFunction, renderData: RTETableBlock, getTableRef: () => HTMLElement, tableDynamicPopover: TableDynamicPopoverRenderer): VegaRTERenderResult;
+  render(): void;
   /**
-   * Updates the table setting component caption state to match the given table data.
+   * Updates the table setting component caption state to match the current table data.
    */
   private updateTableSettingCaption;
   /**
-   * Receive setting menu click events.
+   * Re-targets the shared popovers to the given table.
+   *
+   * @param {RTETableBlock} tableBlock - The clicked table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the clicked table's DOM element.
+   */
+  private reTarget;
+  /**
+   * Handles setting menu click events.
    *
    * @param {CustomEvent<Array<string>>} event - The custom event emitted from the setting menu.
    */

package/dist/types/components/vega-table/interface.d.ts

@@ -2,6 +2,7 @@ import { VNode } from '../../stencil-public-runtime';
 import * as VegaComponents from '../../components';
 import { JSXBase } from '../../stencil-public-runtime';
 import { BreakpointsForPrefixType } from '../../types/ui.type';
+export type { DragDropEventPayload } from '../../types/ui.type';
 /**
  * A virtual DOM node
  */
@@ -493,3 +494,4 @@ export declare type TableHeadCellObserverPayload = {
  * Column pinning position for horizontal scrolling layout.
  */
 export declare type VegaTablePinnedType = 'left' | 'right';
+export declare type VegaTableRowExpandableType = boolean | ((rowKey: string) => boolean);

package/dist/types/components/vega-table/slimmers/controllers/vega-table-expand-row-controller.d.ts

@@ -1,5 +1,6 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTable } from '../../vega-table';
+import { VegaTableDataSourceItem } from '../../interface';
 /**
  * The expand row controller of VegaTable
  */
@@ -7,7 +8,10 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
   static readonly expandRowSlotNamePrefix: string;
   host: VegaTable['host'];
   expandedRowKeySet: VegaTable['expandedRowKeySet'];
+  expandableRows: VegaTable['expandableRows'];
+  hasExpandableRow: VegaTable['hasExpandableRow'];
   rowExpandable: VegaTable['rowExpandable'];
+  currentData: VegaTable['currentData'];
   rowExpandEventEmitter: VegaTable['rowExpandEventEmitter'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   private mutationObserver;
@@ -20,6 +24,10 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
    * Component lifecycle - disconnectedCallback
    */
   disconnectedCallback(): void;
+  /**
+   * Component lifecycle - componentWillLoad
+   */
+  componentWillLoad(): void;
   /**
    * Component lifecycle - componentDidLoad
    */
@@ -50,6 +58,17 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
    * The callback to handle [watchRowExpandable]{@link VegaTable.watchRowExpandable}
    */
   watchRowExpandable(): void;
+  /**
+   * Set the expandable rows based on the rowExpandable prop
+   */
+  watchCurrentData(): void;
+  /**
+   * Whether the row is expandable
+   *
+   * @param {VegaTableDataSourceItem} row - The row data
+   * @returns {boolean} Return true if the row is expandable
+   */
+  isExpandableRow: (row: VegaTableDataSourceItem) => boolean;
   /**
    * Whether the row is expandable
    *
@@ -90,4 +109,20 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
    * @returns {boolean} a boolean value indicating whether the input is acceptable observer.
    */
   private isAcceptableTableRowObserver;
+  /**
+   * Sets expandable rows and hasExpandableRow based on rowExpandable and currentData
+   */
+  private setExpandableRows;
+  /**
+   * Whether the row is expandable by rowKey
+   *
+   * @param {string} rowKey - The row key of the row
+   * @returns {boolean} Return true if the row is expandable
+   */
+  private isRowExpandable;
+  /**
+   * Clear the expand row slot which is not expandable anymore to avoid confusion,
+   *    this can be triggered by the change of rowExpandable or currentData
+   */
+  private clearUnusedExpandRowSlot;
 }

package/dist/types/components/vega-table/slimmers/controllers/vega-table-row-draggable-controller.d.ts

@@ -0,0 +1,52 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTable } from '../../vega-table';
+import { DraggableElementSlimmer } from '../../../../helpers/slimmers/draggable-element-slimmer';
+/**
+ * The row draggable controller for the vega-table
+ */
+export declare class VegaTableRowDraggableController extends VegaSlimmer {
+  rowDraggable: VegaTable['rowDraggable'];
+  protected host: VegaTable['host'];
+  protected vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
+  protected isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
+  protected vegaTableBodyRenderer: VegaTable['vegaTableBodyRenderer'];
+  protected vegaTableSortController: VegaTable['vegaTableSortController'];
+  protected rowDragDropEventEmitter: VegaTable['rowDragDropEventEmitter'];
+  protected readonly draggableElementSlimmer: DraggableElementSlimmer;
+  /**
+   * Component lifecycle - [connectedCallback]{@link VegaPopover.connectedCallback}
+   */
+  connectedCallback(): void;
+  /**
+   * Component lifecycle - [disconnectedCallback]{@link VegaPopover.disconnectedCallback}
+   */
+  disconnectedCallback(): void;
+  /**
+   * Component lifecycle - [componentDidLoad]{@link VegaPopover.componentDidLoad}
+   */
+  componentDidLoad(): void;
+  /**
+   * Watches for changes to the rowDraggable property and initializes or destroys the DraggableElement instance accordingly.
+   * If rowDraggable is true, it calls setRowDraggableElement to initialize the instance;
+   * if false, it calls destroyRowDraggableElement to clean up.
+   */
+  watchRowDraggable(): void;
+  /**
+   * Resolve the draggable container for current render mode.
+   *
+   * @returns {Nullable<HTMLElement>} The table body container used by drag behavior.
+   */
+  private getDragContainer;
+  /**
+   * Handles the drag and drop event emitted by the DraggableElement instance, re-emitting it through the rowDragDropEventEmitter with additional details.
+   *
+   * @param {DragDropEventPayload} payload - An object containing payload about the drag event.
+   */
+  private onDragDrop;
+  /**
+   * Handles the logic for reordering rows in the table when a drag and drop action is completed.
+   *
+   * @param {DragDropEventPayload} payload - An object containing details about the completed drag event, including fromIndex and toIndex.
+   */
+  private onDragEnd;
+}

package/dist/types/components/vega-table/slimmers/controllers/vega-table-sort-controller.d.ts

@@ -22,6 +22,10 @@ export declare class VegaTableSortController extends VegaSlimmer {
    * @param {VegaTableSortOrderType} nextSortOrder - The next sorter order
    */
   handleHeadSortClick(column: VegaTableColumnConfig, nextSortOrder: VegaTableSortOrderType): void;
+  /**
+   * The method to clear all sorters
+   */
+  clearSorter: () => void;
   /**
    * Sync the default sort order from the columns
    */

package/dist/types/components/vega-table/slimmers/renderers/vega-table-body-renderer.d.ts

@@ -6,15 +6,17 @@ export declare class VegaTableBodyRenderer extends VegaSlimmer {
   rowDivider: VegaTable['rowDivider'];
   columns: VegaTable['columns'];
   currentBreakpoint: VegaTable['currentBreakpoint'];
-  rowExpandable: VegaTable['rowExpandable'];
   rowClickable: VegaTable['rowClickable'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   vegaTablePaginationController: VegaTable['vegaTablePaginationController'];
   vegaTableRowSelectionController: VegaTable['vegaTableRowSelectionController'];
   vegaTableRowRenderer: VegaTable['vegaTableRowRenderer'];
   columnStructureModel: VegaTable['columnStructureModel'];
+  vegaTableExpandRowController: VegaTable['vegaTableExpandRowController'];
   private tableFormRef;
+  private tableBodyRef;
   getTableFormRef(): Nullable<HTMLVegaFormElement>;
+  getTableBodyRef(): Nullable<HTMLVegaTableBodyElement>;
   render(): HTMLTableSectionElement;
   private renderTableBody;
 }

package/dist/types/components/vega-table/slimmers/renderers/vega-table-col-group-renderer.d.ts

@@ -4,7 +4,8 @@ export declare class VegaTableColGroupRenderer extends VegaSlimmer {
   paddingX: VegaTable['paddingX'];
   columnStructureModel: VegaTable['columnStructureModel'];
   columns: VegaTable['columns'];
-  rowExpandable: VegaTable['rowExpandable'];
+  hasExpandableRow: VegaTable['hasExpandableRow'];
+  rowDraggable: VegaTable['rowDraggable'];
   vegaTableRowSelectionController: VegaTable['vegaTableRowSelectionController'];
   render(): HTMLElement;
   private getColResponsiveClass;

package/dist/types/components/vega-table/utils.d.ts

@@ -20,6 +20,7 @@ export declare const generateTextAlignClass: (align: ColumnAlignType) => string;
  *
  * @param {number} columnLength - The number of columns in a table or grid.
  * @param {boolean} withMultipleSelection - A boolean value indicating whether the table has a column for multiple selection.
- * @returns {number} the value of `columnLength` plus 2 if `withMultipleSelection` is true, or plus 1 if `withMultipleSelection` is false.
+ * @param {boolean} withRowDraggable - A boolean value indicating whether the table has a column for row draggable.
+ * @returns {number} the value of `columnLength` plus 2 if `withMultipleSelection` is true, or plus 1 if `withMultipleSelection` is false, plus 1 if `withRowDraggable` is true.
  */
-export declare const generateColSpan: (columnLength: number, withMultipleSelection: boolean) => number;
+export declare const generateColSpan: (columnLength: number, withMultipleSelection: boolean, withRowDraggable: boolean) => number;

package/dist/types/components/vega-table/vega-table-expand-row/slimmers/controllers/vega-table-expand-row-col-span-controller.d.ts

@@ -7,6 +7,7 @@ export declare class VegaTableExpandRowColSpanController extends VegaSlimmer {
   host: VegaTableExpandRow['host'];
   colSpan: VegaTableExpandRow['colSpan'];
   withMultipleSelection: VegaTableExpandRow['withMultipleSelection'];
+  withRowDraggable: VegaTableExpandRow['withRowDraggable'];
   /**
    * Update the expand row content col span when component will load
    */
@@ -19,6 +20,10 @@ export declare class VegaTableExpandRowColSpanController extends VegaSlimmer {
    * Update the expand row content col span when selection type changed
    */
   watchWithMultipleSelection(): void;
+  /**
+   * Update the expand row content col span when draggable state changed
+   */
+  watchWithRowDraggable(): void;
   /**
    * Update state colSpan
    */

package/dist/types/components/vega-table/vega-table-expand-row/slimmers/controllers/vega-table-expand-row-state-controller.d.ts

@@ -7,6 +7,7 @@ import { VegaTableExpandRowColSpanController } from './vega-table-expand-row-col
 export declare class VegaTableExpandRowStateController extends SubStateObserverSlimmer<HTMLVegaTableExpandRowElement> {
   host: VegaTableExpandRow['host'];
   withMultipleSelection: VegaTableExpandRow['withMultipleSelection'];
+  withRowDraggable: VegaTableExpandRow['withRowDraggable'];
   vegaTableExpandRowColSpanController: VegaTableExpandRowColSpanController;
   constructor();
 }

package/dist/types/components/vega-table/vega-table-expand-row/vega-table-expand-row.d.ts

@@ -27,6 +27,8 @@ export declare class VegaTableExpandRow {
    */
   withMultipleSelection: boolean;
   watchWithMultipleSelection(): void;
+  withRowDraggable: boolean;
+  watchWithRowDraggable(): void;
   /**
    * Indicates whether the row is expanded.
    */

package/dist/types/components/vega-table/vega-table-foot-row/slimmers/controllers/vega-table-foot-row-state-controller.d.ts

@@ -9,7 +9,8 @@ export declare class VegaTableFootRowStateController extends SubStateObserverSli
   paddingX: VegaTableFootRow['paddingX'];
   columnDivider: VegaTableFootRow['columnDivider'];
   density: VegaTableFootRow['density'];
-  expandable: VegaTableFootRow['expandable'];
+  hasExpandableRow: VegaTableFootRow['hasExpandableRow'];
+  draggable: VegaTableFootRow['draggable'];
   constructor();
   /**
    * Update the selection config with the new config

package/dist/types/components/vega-table/vega-table-foot-row/slimmers/renderers/vega-table-foot-row-renderer.d.ts

@@ -4,8 +4,10 @@ export declare class VegaTableFootRowRenderer extends VegaSlimmer {
   host: VegaTableFootRow['host'];
   paddingX: VegaTableFootRow['paddingX'];
   selectionType: VegaTableFootRow['selectionType'];
-  expandable: VegaTableFootRow['expandable'];
+  hasExpandableRow: VegaTableFootRow['hasExpandableRow'];
+  draggable: VegaTableFootRow['draggable'];
   render(): VegaTableFootRow;
   private renderFooterSelectionCell;
   private renderFooterExpandableCell;
+  private renderFooterDraggableCell;
 }

package/dist/types/components/vega-table/vega-table-foot-row/vega-table-foot-row.d.ts

@@ -18,9 +18,9 @@ export declare class VegaTableFootRow {
   host: HTMLVegaTableFootRowElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
-   * Indicates whether the row is expandable.
+   * Indicates whether the table has a expandable row.
    */
-  expandable: boolean;
+  hasExpandableRow: boolean;
   /**
    * Configures row selection behavior.
    */
@@ -33,6 +33,10 @@ export declare class VegaTableFootRow {
    * Sync from {@link VegaTable.columnDivider}
    */
   columnDivider?: boolean;
+  /**
+   * Sync from {@link VegaTable.rowDraggable}
+   */
+  draggable?: boolean;
   /**
    * Sync from {@link VegaTable.density}
    */

package/dist/types/components/vega-table/vega-table-head/vega-table-head.d.ts

@@ -16,6 +16,7 @@ export declare class VegaTableHead {
    * Indicates whether the table header is fixed.
    */
   fixed: boolean;
+  connectedCallback(): void;
   disconnectedCallback(): void;
   render(): VegaTableHead;
   private handleTableHeadRefChange;

package/dist/types/components/vega-table/vega-table-head-row/slimmers/controllers/vega-table-head-row-state-controller.d.ts

@@ -5,13 +5,14 @@ import { SubStateObserverSlimmer } from '../../../../../helpers/slimmers/sub-sta
  */
 export declare class VegaTableHeadRowStateController extends SubStateObserverSlimmer<HTMLVegaTableHeadRowElement> {
   host: VegaTableHeadRow['host'];
-  expandable: VegaTableHeadRow['expandable'];
+  hasExpandableRow: VegaTableHeadRow['hasExpandableRow'];
   selectionType: VegaTableHeadRow['selectionType'];
   paddingX: VegaTableHeadRow['paddingX'];
   columnDivider: VegaTableHeadRow['columnDivider'];
   density: VegaTableHeadRow['density'];
   isTemplateRenderMode: VegaTableHeadRow['isTemplateRenderMode'];
   isEmptyTable: VegaTableHeadRow['isEmptyTable'];
+  draggable: VegaTableHeadRow['draggable'];
   constructor();
   /**
    * Update the selection config with the new config

package/dist/types/components/vega-table/vega-table-head-row/slimmers/renderers/vega-table-head-row-renderer.d.ts

@@ -7,7 +7,8 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   hideSelectAll: VegaTableHeadRow['hideSelectAll'];
   selectAllDisabled: VegaTableHeadRow['selectAllDisabled'];
   checkedAll: VegaTableHeadRow['checkedAll'];
-  expandable: VegaTableHeadRow['expandable'];
+  hasExpandableRow: VegaTableHeadRow['hasExpandableRow'];
+  draggable: VegaTableHeadRow['draggable'];
   isEmptyTable: VegaTableHeadRow['isEmptyTable'];
   isTemplateRenderMode: VegaTableHeadRow['isTemplateRenderMode'];
   renderInput: VegaTableHeadRow['renderInput'];
@@ -26,6 +27,7 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   render(): VegaTableHeadRow;
   private renderHeaderSelectionCell;
   private handleSelectAll;
+  private renderHeaderDraggableCell;
   private renderHeaderExpandableCell;
   private handleClick;
   private getRowRenderInput;

package/dist/types/components/vega-table/vega-table-head-row/vega-table-head-row.d.ts

@@ -26,9 +26,9 @@ export declare class VegaTableHeadRow {
   host: HTMLVegaTableHeadRowElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
-   * Indicates whether the row is expandable.
+   * Indicates whether the table has an expandable row.
    */
-  expandable: boolean;
+  hasExpandableRow: boolean;
   /**
    * Configures row selection behavior.
    */
@@ -58,6 +58,10 @@ export declare class VegaTableHeadRow {
    */
   isTemplateRenderMode: boolean;
   renderInput: Nullable<ColumnRenderInputModel[]>;
+  /**
+   * Sync from {@link VegaTable.rowDraggable}
+   */
+  draggable?: boolean;
   /**
    * Indicates whether the checkbox is disabled.
    *

package/dist/types/components/vega-table/vega-table-row/slimmers/controllers/vega-table-row-state-controller.d.ts

@@ -6,11 +6,14 @@ import { SubStateObserverSlimmer } from '../../../../../helpers/slimmers/sub-sta
 export declare class VegaTableRowStateController extends SubStateObserverSlimmer<HTMLVegaTableRowElement> {
   host: VegaTableRow['host'];
   expandable: VegaTableRow['expandable'];
+  hasExpandableRow: VegaTableRow['hasExpandableRow'];
   clickable: VegaTableRow['clickable'];
   paddingX: VegaTableRow['paddingX'];
   selectionType: VegaTableRow['selectionType'];
   columnDivider: VegaTableRow['columnDivider'];
   density: VegaTableRow['density'];
+  draggable: VegaTableRow['draggable'];
+  rowKey: VegaTableRow['rowKey'];
   constructor();
   /**
    * Component watch method - [watchRowSelection]{@link VegaTableRow.watchSelectionType}

package/dist/types/components/vega-table/vega-table-row/slimmers/renderers/vega-table-row-renderer.d.ts

@@ -10,8 +10,10 @@ export declare class VegaTableRowRenderer extends VegaSlimmer {
   expanded: VegaTableRow['expanded'];
   paddingX: VegaTableRow['paddingX'];
   expandable: VegaTableRow['expandable'];
+  hasExpandableRow: VegaTableRow['hasExpandableRow'];
   vegaClick: VegaTableRow['vegaClick'];
   selectionType: VegaTableRow['selectionType'];
+  draggable: VegaTableRow['draggable'];
   vegaTableRowSelectionController: VegaTableRow['vegaTableRowSelectionController'];
   vegaTableRowExpandController: VegaTableRow['vegaTableRowExpandController'];
   vegaTableRowClickController: VegaTableRow['vegaTableRowClickController'];
@@ -21,6 +23,7 @@ export declare class VegaTableRowRenderer extends VegaSlimmer {
   getParentTableRef(): Nullable<HTMLVegaTableElement>;
   render(): VegaTableRow;
   private renderExpandRowSpace;
+  private renderDragIcon;
   private renderRowSelection;
   private renderExpandIcon;
   private onRowClick;

package/dist/types/components/vega-table/vega-table-row/vega-table-row.d.ts

@@ -36,6 +36,10 @@ export declare class VegaTableRow {
   host: HTMLVegaTableRowElement;
   currentBreakpoint: BreakpointsTokenType;
   clicked?: boolean;
+  /**
+   * Indicates whether the table has an expandable row.
+   */
+  hasExpandableRow?: boolean;
   /**
    * Indicates whether the row is expandable.
    */
@@ -71,6 +75,10 @@ export declare class VegaTableRow {
    * Sync from {@link VegaTable.density}
    */
   density?: ResponsiveType<VegaTableDensityType>;
+  /**
+   * Sync from {@link VegaTable.rowDraggable}
+   */
+  draggable: boolean;
   /**
    * Defines a unique key for the row.
    *

package/dist/types/components/vega-table/vega-table.d.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import { ImmutableSet } from '../../helpers/immutable/immutable-set';
 import { BreakpointsTokenType } from '../../types/design-token.type';
-import { ResponsiveType } from '../../types/ui.type';
-import { VegaTableChangePropType, VegaTableColumnConfig, VegaTableDataSourceItem, VegaTableDensityType, VegaTablePagination, VegaTableRowClickPropType, VegaTableRowSelectionConfig, VegaTableRowSelectProp, VegaTableSelectAllProp, VegaTableScrollConfig, VegaTableSortConfig, VegaTableRowSelectAllEventDetail, VegaTableRowSelectEventDetail, VegaTableRowExpandEventDetail, VegaTableGroupColumnConfig } from './interface';
+import { DragDropEventPayload, ResponsiveType } from '../../types/ui.type';
+import { VegaTableChangePropType, VegaTableColumnConfig, VegaTableDataSourceItem, VegaTableDensityType, VegaTablePagination, VegaTableRowClickPropType, VegaTableRowSelectionConfig, VegaTableRowSelectProp, VegaTableSelectAllProp, VegaTableScrollConfig, VegaTableSortConfig, VegaTableRowSelectAllEventDetail, VegaTableRowSelectEventDetail, VegaTableRowExpandEventDetail, VegaTableGroupColumnConfig, VegaTableRowExpandableType } from './interface';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { VegaTableCellRenderer } from './slimmers/renderers/vega-table-cell-renderer';
 import { VegaTableExpandRowController } from './slimmers/controllers/vega-table-expand-row-controller';
@@ -32,6 +32,7 @@ import { VegaTableColumnStructureModelController } from './slimmers/controllers/
 import { ColumnStructureModel } from './slimmers/controllers/dto/column-structure-model';
 import { VegaTableRenderInputController } from './slimmers/controllers/vega-table-render-input-controller';
 import { VegaTablePinnedRenderer } from './slimmers/renderers/vega-table-pinned-renderer';
+import { VegaTableRowDraggableController } from './slimmers/controllers/vega-table-row-draggable-controller';
 /**
  * @vegaVersion 1.3.0
  */
@@ -49,7 +50,6 @@ export declare class VegaTable {
   protected readonly vegaTableCellRenderer: VegaTableCellRenderer;
   protected readonly vegaTablePaginationRenderer: VegaTablePaginationRenderer;
   protected readonly vegaTableScrollContainerRenderer: VegaTableScrollContainerRenderer;
-  protected readonly vegaTableExpandRowController: VegaTableExpandRowController;
   protected readonly vegaTableRowSelectionController: VegaTableRowSelectionController;
   protected readonly vegaTableDataSourceController: VegaTableDataSourceController;
   protected readonly vegaTablePaginationController: VegaTablePaginationController;
@@ -57,13 +57,20 @@ export declare class VegaTable {
   protected readonly vegaTableSortController: VegaTableSortController;
   protected readonly vegaTableColGroupRenderer: VegaTableColGroupRenderer;
   protected readonly vegaTableChildrenController: VegaTableChildrenController;
+  protected readonly vegaTableRowDraggableController: VegaTableRowDraggableController;
+  /**
+   * vegaTableExpandRowController should be injected after childrenController and VegaTableDataSourceController,
+   *     because it needs to wait for sync currentData to set expandableRows.
+   */
+  protected readonly vegaTableExpandRowController: VegaTableExpandRowController;
   /**
    * The below method is e2e-test covered in
    * @see{module:should-render-responsive-columns-with-expandable-row-and-current-breakpoint-is-smaller-than-S}
    */
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected readonly rowSelectionNotifySlimmer: SubStateNotifySlimmerBase;
-  protected readonly rowExpandableNotifySlimmer: SubStateNotifySlimmerBase;
+  protected readonly expandableRowsNotifySlimmer: SubStateNotifySlimmerBase;
+  protected readonly hasExpandableRowNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly paddingXNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly rowClickableNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly scrollConfigNotifySlimmer: SubStateNotifySlimmerBase;
@@ -73,11 +80,13 @@ export declare class VegaTable {
   protected selectAllChangeEventEmitter: EventEmitSlimmerBase;
   protected rowClickEventEmitter: EventEmitSlimmerBase;
   protected rowExpandEventEmitter: EventEmitSlimmerBase;
+  protected rowDragDropEventEmitter: EventEmitSlimmerBase;
   protected readonly rowDividerNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly columnDividerNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly densityNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly isTemplateRenderModeNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly currentDataNotifySlimmer: SubStateNotifySlimmerBase;
+  protected readonly rowDraggableNotifySlimmer: SubStateNotifySlimmerBase;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableElement>;
   protected rowSelectEventEmitter: EventEmitSlimmerBase;
   protected rowSelectAllEventEmitter: EventEmitSlimmerBase;
@@ -111,6 +120,10 @@ export declare class VegaTable {
   watchTemplateRenderMode(): void;
   columnStructureModel: ColumnStructureModel;
   watchColumnStructureModel(): void;
+  expandableRows: string[];
+  watchExpandableRows(): void;
+  hasExpandableRow: boolean;
+  watchHasExpandableRow(): void;
   /**
    * Defines the columns of the table.
    *
@@ -153,7 +166,7 @@ export declare class VegaTable {
    *
    * @vegaVersion 1.3.0
    */
-  rowExpandable: boolean;
+  rowExpandable: VegaTableRowExpandableType;
   watchRowExpandable(): void;
   /**
    * Specifies whether rows in the table can be clicked.
@@ -164,6 +177,13 @@ export declare class VegaTable {
    */
   rowClickable: boolean;
   watchRowClickable(): void;
+  /**
+   * Specifies whether the table supports row dragging for reordering.
+   *
+   * @vegaVersion 2.85.0
+   */
+  rowDraggable: boolean;
+  watchRowDraggable(): void;
   /**
    * Specifies whether dividers should be displayed
    *    between rows in the table.
@@ -341,6 +361,21 @@ export declare class VegaTable {
    * @vegaVersion 2.23.0
    */
   rowSelectAll: EventEmitter<VegaTableRowSelectAllEventDetail>;
+  /**
+   * An event emitter notifying when a row is drag and drop,
+   *    it include full lifecycle, like drag start, drag, drag enter, drag leave, drag over, drop and drag end.
+   *
+   * @vegaVersion 2.85.0
+   */
+  vegaRowDragDrop: EventEmitter<DragDropEventPayload>;
+  /**
+   * An event emitter notifying when a row is drag and drop,
+   *     it include full lifecycle, like drag start, drag, drag enter, drag leave, drag over, drop and drag end.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.85.0
+   */
+  rowDragDrop: EventEmitter<DragDropEventPayload>;
   /**
    * Invoke this method to expand the row with the specified `rowKey`,
    *    revealing additional content.

package/dist/types/components/vega-time-picker/slimmers/renderers/vega-time-picker-range-clear-button-renderer.d.ts

@@ -3,6 +3,7 @@ import { VegaTimePicker } from '../../vega-time-picker';
 export declare class VegaTimePickerRangeClearButtonRenderer extends VegaSlimmer {
   disabled: VegaTimePicker['disabled'];
   value: VegaTimePicker['value'];
+  showClearIcon: VegaTimePicker['showClearIcon'];
   valueController: VegaTimePicker['valueController'];
   endDropdownController: VegaTimePicker['endDropdownController'];
   rangeInputRenderer: VegaTimePicker['rangeInputRenderer'];
@@ -10,9 +11,11 @@ export declare class VegaTimePickerRangeClearButtonRenderer extends VegaSlimmer
   /** The `onClickClearIcon` function is a private method that is called when the clear icon is clicked. It performs the following actions: */
   private onClickClearIcon;
   /**
-   * The function checks if the value is an array and if either of the elements in the array is truthy, returning true if so.
+   * Determines whether the range clear button should be visible. The button
+   * is shown only when the clear icon feature is enabled, the component is
+   * not disabled, and at least one end of the range value is non-empty.
    *
-   * @returns {boolean} a boolean value.
+   * @returns {boolean} `true` when the clear button should be visible.
    */
-  private isInvisible;
+  private shouldShowClearButton;
 }