@sme.up/ketchup 4.3.0-SNAPSHOT → 5.1.0-SNAPSHOT

package/dist/types/f-components/f-cell/f-cell-declarations.d.ts

@@ -1,20 +1,20 @@
 import type { VNode } from '../../stencil-public-runtime';
-import type { Cell, Column, Row } from '../../components/kup-data-table/kup-data-table-declarations';
-import type { FComponent, KupEventPayload } from '../../types/GenericTypes';
-export declare const autoAlignComps: string[];
+import { KupDataCell, KupDataColumn, KupDataRow } from '../../managers/kup-data/kup-data-declarations';
+import { FComponent, KupEventPayload, KupTagNames } from '../../types/GenericTypes';
+export declare const autoAlignComps: KupTagNames[];
 /**
  * Props of the f-cell component.
  */
 export interface FCellProps extends FComponent {
-  cell?: Cell;
-  column?: Column;
+  cell?: KupDataCell;
+  column?: KupDataColumn;
   component?: unknown;
   density?: FCellPadding;
   editable?: boolean;
   indents?: VNode[];
   previousValue?: string;
   renderKup?: boolean;
-  row?: Row;
+  row?: KupDataRow;
   setSizes?: boolean;
   shape?: FCellShapes;
 }
@@ -31,6 +31,7 @@ export interface FCellInfo {
  */
 export declare enum FCellEvents {
   CLICK = "kup-cell-click",
+  ICON_CLICK = "kup-cell-iconclick",
   INPUT = "kup-cell-input",
   UPDATE = "kup-cell-update"
 }
@@ -145,9 +146,9 @@ export declare const kupTypes: FCellTypes[];
  * Payload of the event fired when a cell is updated.
  */
 export interface FCellEventPayload extends KupEventPayload {
-  cell: Cell;
-  column: Column;
-  event: CustomEvent | InputEvent;
-  row: Row;
+  cell: KupDataCell;
+  column: KupDataColumn;
+  event: CustomEvent | InputEvent | MouseEvent;
+  row: KupDataRow;
   type: FCellTypes;
 }

package/dist/types/f-components/f-chip/f-chip-declarations.d.ts

@@ -1,32 +1,17 @@
 import type { FComponent } from '../../types/GenericTypes';
-import { KupObj } from '../../utils/kup-objects/kup-objects-declarations';
-import { TreeNode } from '../../components/kup-tree/kup-tree-declarations';
+import { KupChipNode } from '../../components/kup-chip/kup-chip-declarations';
 /**
  * Props of the f-chip component.
  */
 export interface FChipsProps extends FComponent {
-  data?: FChipData[];
-  dataNew?: TreeNode[];
-  onClick?: ((event: MouseEvent) => void)[];
-  onBlur?: ((event: FocusEvent) => void)[];
-  onFocus?: ((event: FocusEvent) => void)[];
-  onIconClick?: ((event: MouseEvent) => void)[];
+  data?: KupChipNode[];
+  onBlur?: ((chip: KupChipNode, e: FocusEvent) => void)[];
+  onClick?: ((chip: KupChipNode, e: PointerEvent) => void)[];
+  onExpansionClick?: ((chip: KupChipNode, e: PointerEvent) => void)[];
+  onFocus?: ((chip: KupChipNode, e: FocusEvent) => void)[];
+  onIconClick?: ((chip: KupChipNode, e: PointerEvent) => void)[];
   type?: FChipType;
 }
-/**
- * The object of a single chip contained in a chip set.
- * @property {string} value - Intrinsic/server side value.
- * @property {string} icon - Icon displayed on the left.
- * @property {string} label - Displayed text.
- * @property {boolean} checked - Defines whether a chip is selected or not.
- */
-export interface FChipData {
-  label: string;
-  value: string;
-  checked?: boolean;
-  icon?: string;
-  obj?: KupObj;
-}
 /**
  * Types of the f-chip component.
  * @enum {string}

package/dist/types/f-components/f-paginator/f-paginator-declarations.d.ts

@@ -0,0 +1,22 @@
+import type { FComponent } from '../../types/GenericTypes';
+/**
+ * Props of the f-paginator component.
+ */
+export interface FPaginatorProps extends FComponent {
+  currentPage?: number;
+  max?: number;
+  mode?: FPaginatorMode;
+  perPage?: number;
+  onLoadMore?: () => void;
+  onNextPage?: () => void;
+  onPageChange?: (event: CustomEvent) => void;
+  onPrevPage?: () => void;
+  onRowsChange?: (event: CustomEvent) => void;
+}
+export declare enum FPaginatorMode {
+  SIMPLE = "simple",
+  FULL = "full"
+}
+export interface KupPaginatorPageChangedEventPayload {
+  newPage: number;
+}

package/dist/types/f-components/f-paginator/f-paginator-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function pageChange(pageNumber: number, max: number, perPage: number): number;
+export declare function rowsPerPageChange(rowsNumber: number, max: number): number;

package/dist/types/f-components/f-paginator/f-paginator.d.ts

@@ -0,0 +1,3 @@
+import { FunctionalComponent } from '../../stencil-public-runtime';
+import { FPaginatorProps } from './f-paginator-declarations';
+export declare const FPaginator: FunctionalComponent<FPaginatorProps>;

package/dist/types/managers/kup-data/kup-data-cell-helper.d.ts

@@ -0,0 +1,24 @@
+import { KupDataCell, KupDataDataset, KupDataFindCellFilters } from './kup-data-declarations';
+/**
+ * Finds all the cells matching the filters criteria in the input dataset.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {KupDataFindCellFilters} filters - Filters of the research.
+ * @returns {KupDataCell[]}  Array of cells fetched after applying the filters.
+ */
+export declare function findCell(dataset: KupDataDataset, filters: KupDataFindCellFilters): KupDataCell[];
+/**
+ * Returns all the cells values of the specified columns.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {string[]} columns - Columns included in the search. When missing, searches all columns.
+ * @returns {string[]} Values of the cells.
+ */
+export declare function getCellValue(dataset: KupDataDataset, columns?: string[]): string[];
+/**
+ * Overrides the given cell attributes for the specified columns.
+ * If no columns are provided, the value will be applied to every column of the dataset.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {KupDataCell} cell - New cell.
+ * @param {string[]} columns - Columns to be handled.
+ * @returns {KupDataCell[]} Replaced cells.
+ */
+export declare function replaceCell(dataset: KupDataDataset, cell: KupDataCell, columns?: string[]): KupDataCell[];

package/dist/types/managers/kup-data/kup-data-column-helper.d.ts

@@ -0,0 +1,31 @@
+import { KupDataColumn, KupDataDataset, KupDataNewColumnOptions, KupDataNewColumnTypes } from './kup-data-declarations';
+/**
+ * Finds the columns matching the criteria specified in the filters argument.
+ * @param {KupDataDataset | Column[]} dataset - Input dataset or array of columns.
+ * @param {Partial<Column>} filters - Column interface containing the filters to match.
+ * @returns {Column[]} Columns matching the criteria.
+ */
+export declare function findColumns(dataset: KupDataDataset | KupDataColumn[], filters: Partial<KupDataColumn>): KupDataColumn[];
+/**
+ * Sets the given columns of the input dataset to be hidden.
+ * @param {KupDataDataset | Column[]} dataset - Input dataset or array of columns.
+ * @param {string[]} columns2hide - Names of columns to hide.
+ * @returns {KupDataColumn[]} Columns that were set to hidden.
+ */
+export declare function hideColumns(dataset: KupDataDataset | KupDataColumn[], columns2hide: string[]): KupDataColumn[];
+/**
+ * Creates a new column with the specified options.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {KupDataNewColumnTypes} type - Type of column creation.
+ * @param {KupDataNewColumnOptions} options - Options used by the submethods to create the column.
+ * @returns {string | Column} Returns the new column created or a string containing the error message (if something went wrong).
+ */
+export declare function newColumn(dataset: KupDataDataset, type: KupDataNewColumnTypes, options?: KupDataNewColumnOptions): string | KupDataColumn;
+/**
+ * Takes the columns to merge and creates a new column with their cells. The merged columns will then be removed.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {string[]} columns2merge - Names of columns to merge.
+ * @param {KupDataColumn} newColumn - Column created.
+ * @returns {KupDataColumn} Resulting column.
+ */
+export declare function newColumnFromMerge(dataset: KupDataDataset, columns2merge: string[], newColumn: KupDataColumn): KupDataColumn;

package/dist/types/managers/kup-data/kup-data-declarations.d.ts

@@ -0,0 +1,160 @@
+import { FCellInfo, FCellShapes } from '../../f-components/f-cell/f-cell-declarations';
+import { GenericMap, GenericObject } from '../../types/GenericTypes';
+import { KupObj } from '../kup-objects/kup-objects-declarations';
+/**
+ * Generic dataset interface.
+ */
+export interface KupDataDataset {
+  columns?: KupDataColumn[];
+  rows?: KupDataRow[];
+}
+/**
+ * Generic column interface.
+ */
+export interface KupDataColumn {
+  name: string;
+  title: string;
+  children?: KupDataColumnChild[];
+  cssClass?: string;
+  decimals?: number;
+  formula?: string;
+  hideValuesRepetitions?: boolean;
+  icon?: string;
+  isKey?: boolean;
+  mergedFrom?: string[];
+  obj?: KupObj;
+  objs?: KupObj[];
+  resultOf?: string;
+  shape?: FCellShapes;
+  size?: string;
+  valuesForFilter?: string[];
+  visible?: boolean;
+  style?: GenericMap;
+}
+export interface KupDataColumnChild {
+  name: string;
+  obj: KupObj;
+  icon?: string;
+}
+/**
+ * Generic row interface.
+ */
+export interface KupDataRow {
+  cells?: KupDataRowCells;
+  actions?: KupDataRowAction[];
+  cssClass?: string;
+  id?: string;
+  readOnly?: boolean;
+  transposedColumnName?: string;
+}
+export interface KupDataRowCells {
+  [index: string]: KupDataCell;
+}
+export interface KupDataRowAction {
+  text: string;
+  icon: string;
+}
+/**
+ * Generic cell interface.
+ */
+export interface KupDataCell {
+  value: string;
+  cardID?: number;
+  cssClass?: string;
+  data?: GenericObject;
+  displayedValue?: string;
+  icon?: string;
+  info?: FCellInfo;
+  isEditable?: boolean;
+  obj?: KupObj;
+  shape?: FCellShapes;
+  style?: GenericMap;
+  styleContent?: GenericMap;
+  title?: string;
+}
+/**
+ * Generic tree node interface.
+ */
+export interface KupDataNode extends KupDataRow {
+  value: string;
+  children?: KupDataNode[];
+  disabled?: boolean;
+  obj?: KupObj;
+  icon?: string;
+  isExpanded?: boolean;
+  title?: string;
+}
+/**
+ * Interface related to cells operations.
+ */
+export interface KupDataCellOperations {
+  find: (dataset: KupDataDataset, filters?: KupDataFindCellFilters) => KupDataCell[];
+  getValue: (dataset: KupDataDataset, columns?: string[]) => string[];
+  replace: (dataset: KupDataDataset, cell: KupDataCell, columns?: string[]) => KupDataCell[];
+}
+/**
+ * Interface related to columns operations.
+ */
+export interface KupDataColumnOperations {
+  find: (dataset: KupDataDataset, filters?: Partial<KupDataColumn>) => KupDataColumn[];
+  hide: (dataset: KupDataDataset | KupDataColumn[], columns2hide: string[]) => KupDataColumn[];
+  new: (dataset: KupDataDataset, type: KupDataNewColumnTypes, options: KupDataNewColumnOptions) => string | KupDataColumn;
+}
+/**
+ * Interface related to nodes operations.
+ */
+export interface KupDataNodeOperations {
+  remove: (nodes: KupDataNode[], node2remove: KupDataNode) => KupDataNode;
+  setProperties: (nodes: KupDataNode[], properties: Partial<KupDataNode>, recursively?: boolean, exclude?: KupDataNode[]) => KupDataNode[];
+  toStream: (nodes: KupDataNode[]) => KupDataNode[];
+}
+/**
+ * Interface related to rows operations.
+ */
+export interface KupDataRowOperations {
+  find: (dataset: KupDataDataset, filters?: KupDataFindCellFilters) => KupDataRow[];
+  toNode: (dataset: KupDataDataset) => KupDataNode[];
+}
+/**
+ * Sets the filters for the cell finder method.
+ */
+export interface KupDataFindCellFilters {
+  columns?: string[];
+  range?: KupDataFilterRange;
+  value?: string;
+}
+/**
+ * Interface of the range filter.
+ */
+export interface KupDataFilterRange {
+  min?: number | string | String;
+  max?: number | string | String;
+}
+/**
+ * Interface for the creation of a new column.
+ */
+export interface KupDataNewColumn {
+  column: KupDataColumn;
+  criteria: KupDataFindCellFilters;
+}
+/**
+ * Type to manage sort of the dataset.
+ */
+export declare type KupDataDatasetSort = 'normalDistribution';
+/**
+ * Interface containing the options related to column creation when invoking column.new.
+ */
+export interface KupDataNewColumnOptions {
+  columns?: string[];
+  newColumn?: KupDataColumn;
+  operation?: string;
+  separator?: string;
+}
+/**
+ * Types of column creation when invoking column.new.
+ */
+export declare enum KupDataNewColumnTypes {
+  CONCATENATE = "concatenate",
+  MATH = "math",
+  MERGE = "merge"
+}

package/dist/types/managers/kup-data/kup-data-node-helper.d.ts

@@ -0,0 +1,23 @@
+import { KupDataNode } from './kup-data-declarations';
+/**
+ * Removes the given node from the input array, by searching even children.
+ * @param {KupDataNode[]} nodes - Input array of nodes.
+ * @param {KupDataNode} node2remove - Node to remove.
+ * @returns {KupDataNode} Copy of the removed node.
+ */
+export declare function removeNode(nodes: KupDataNode[], node2remove: KupDataNode): KupDataNode;
+/**
+ * Sets the values specified in the properties to every node of the input array.
+ * @param {KupDataNode[]} nodes - Input array of nodes.
+ * @param {Partial<KupDataNode>} properties - New properties values to set.
+ * @param {boolean} recursively - Sets values to every child node.
+ * @param {KupDataNode[]} exclude - Nodes to exclude (they won't be updated).
+ * @returns {KupDataNode[]} Array of the updated nodes.
+ */
+export declare function setPropertiesNode(nodes: KupDataNode[], properties: Partial<KupDataNode>, recursively?: boolean, exclude?: KupDataNode[]): KupDataNode[];
+/**
+ * Streamlines an array of nodes by recursively fetching every child node.
+ * @param {KupDataNode[]} nodes - Input array of nodes.
+ * @returns {KupDataNode[]} Streamlined array of every node and their children.
+ */
+export declare function toStreamNode(nodes: KupDataNode[]): KupDataNode[];

package/dist/types/managers/kup-data/kup-data-row-helper.d.ts

@@ -0,0 +1,14 @@
+import { KupDataDataset, KupDataFindCellFilters, KupDataNode, KupDataRow } from './kup-data-declarations';
+/**
+ * Finds all the rows containing cells matching the filters criteria in the input dataset.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @param {KupDataFindCellFilters} filters - Filters of the research.
+ * @returns {KupDataRow[]} Array of rows fetched after applying the filters.
+ */
+export declare function findRow(dataset: KupDataDataset, filters: KupDataFindCellFilters): KupDataRow[];
+/**
+ * Converts the rows of the input dataset to tree nodes.
+ * @param {KupDataDataset} dataset - Input dataset.
+ * @returns {KupDataNode[]} Array of tree nodes.
+ */
+export declare function toNode(dataset: KupDataDataset): KupDataNode[];

package/dist/types/managers/kup-data/kup-data.d.ts

@@ -0,0 +1,77 @@
+import { KupDataCell, KupDataColumn, KupDataDataset, KupDataDatasetSort, KupDataFindCellFilters, KupDataNewColumn, KupDataNewColumnOptions, KupDataNewColumnTypes, KupDataNode, KupDataRow } from './kup-data-declarations';
+/**
+ * Handles data operations.
+ * @module KupData
+ */
+export declare class KupData {
+  cell: {
+    find(dataset: KupDataDataset, filters: KupDataFindCellFilters): KupDataCell[];
+    getValue(dataset: KupDataDataset, columns?: string[]): string[];
+    replace(dataset: KupDataDataset, cell: KupDataCell, columns?: string[]): KupDataCell[];
+  };
+  column: {
+    find(dataset: KupDataDataset | KupDataColumn[], filters: Partial<KupDataColumn>): KupDataColumn[];
+    hide(dataset: KupDataDataset | KupDataColumn[], columns2hide: string[]): KupDataColumn[];
+    new(dataset: KupDataDataset, type: KupDataNewColumnTypes, options?: KupDataNewColumnOptions): string | KupDataColumn;
+  };
+  node: {
+    remove(nodes: KupDataNode[], node2remove: KupDataNode): KupDataNode;
+    setProperties(nodes: KupDataNode[], properties: Partial<KupDataNode>, recursively?: boolean, exclude?: KupDataNode[]): KupDataNode[];
+    toStream(nodes: KupDataNode[]): KupDataNode[];
+  };
+  row: {
+    find(dataset: KupDataDataset, filters: KupDataFindCellFilters): KupDataRow[];
+    toNode(dataset: KupDataDataset): KupDataNode[];
+  };
+  /**
+   * Utility used by findRow and findCell.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {KupDataFindCellFilters} filters - Filters of the research.
+   * @returns {{cells: KupDataCell[], rows: KupDataRow[]}}  Object containing rows and cells.
+   */
+  finder(dataset: KupDataDataset, filters: KupDataFindCellFilters): {
+    cells: KupDataCell[];
+    rows: KupDataRow[];
+  };
+  /**
+   * Creates a new dataset with an amount of cells equal to a distinct calculation applied to the given columns.
+   * The original value of cells will be stored in the title property of the new cells.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {string[]} columns - Column names to manage. When missing, defaults to all columns.
+   * @param {KupDataColumn} valuesColumn - When present, this column will be included in the final dataset containing the original values of the cells.
+   * @returns {KupDataDataset} New dataset with processed data.
+   */
+  distinct(dataset: KupDataDataset, columns?: string[], valuesColumn?: KupDataColumn): KupDataDataset;
+  /**
+   * Creates a new dataset from the input one.
+   * The new columns are to be specified in the columns argument along with their creation criteria.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {KupDataNewColumn[]} newColumns - Array containing the specifics of the new columns to be created.
+   * @returns {KupDataDataset} Resulting dataset.
+   */
+  new(dataset: KupDataDataset, newColumns: KupDataNewColumn[]): KupDataDataset;
+  /**
+   * Performs a distinct/count after previously grouping columns by ranges.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {KupDataNewColumn[]} rangeColumns - A list of columns coupled with their criteria for creation. These are used to define ranges.
+   * @param {KupDataColumn} resultingColumn - The resulting column.
+   * @param {KupDataColumn} valuesColumn - When present, this column will be included in the final dataset containing the original values of the cells.
+   * @returns {KupDataDataset} New dataset with processed data.
+   */
+  rangedDistinct(dataset: KupDataDataset, rangeColumns: KupDataNewColumn[], resultingColumn: KupDataColumn, valuesColumn?: KupDataColumn): KupDataDataset;
+  /**
+   * Creates a new dataset with sorted elements.
+   * @param {KupDataDataset} dataset Input dataset.
+   * @param {KupDataDatasetSort} sortType Type of sort to apply.
+   * @param {string} headerColumn The column used for sorting.
+   * @returns {KupDataDataset} Sorted dataset.
+   */
+  sort(dataset: KupDataDataset, sortType: KupDataDatasetSort, headerColumn: string): KupDataDataset;
+  /**
+   * Creates a new dataset with transposed columns and rows.
+   * @param {KupDataDataset} dataset - Input dataset.
+   * @param {string} headerColumn - When specified, it will be the column used as header. When missing, the header will be a series of progressive numbers.
+   * @returns {KupDataDataset} Transposed dataset.
+   */
+  transpose(dataset: KupDataDataset, headerColumn?: string): KupDataDataset;
+}

package/dist/types/{utils → managers}/kup-dates/kup-dates.d.ts

@@ -5,6 +5,7 @@ import 'dayjs/locale/it';
 import 'dayjs/locale/pl';
 import 'dayjs/locale/ru';
 import 'dayjs/locale/zh';
+import { KupComponent } from '../../types/GenericTypes';
 import { KupDatesLocales, KupDatesNormalize } from './kup-dates-declarations';
 /**
  * Handles operations and formatting of dates.
@@ -13,6 +14,7 @@ import { KupDatesLocales, KupDatesNormalize } from './kup-dates-declarations';
 export declare class KupDates {
   dayjs: Function;
   locale: KupDatesLocales;
+  managedComponents: Set<KupComponent>;
   /**
    * Initializes KupDates.
    */
@@ -24,8 +26,7 @@ export declare class KupDates {
    */
   setLocale(locale?: KupDatesLocales): string;
   /**
-   *
-   * @returns the current locale
+   * @returns {string} The current locale.
    */
   getLocale(): string;
   /**
@@ -44,6 +45,7 @@ export declare class KupDates {
    * Validates the given date.
    * @param {dayjs.ConfigType} date - Date to be validated.
    * @param {string} format - Format of the input date.
+   * @param {boolean} strict - Strict parsing requires that the format and input match exactly, including delimiters.
    * @returns {boolean} Returns whether the argument is a valid date or not.
    */
   isValid(date: dayjs.ConfigType, format?: string, strict?: boolean): boolean;
@@ -80,6 +82,15 @@ export declare class KupDates {
    * @returns {dayjs.Dayjs} Maximum date.
    */
   max(dates: dayjs.ConfigType[]): dayjs.Dayjs;
+  /**
+   * Adds the given amount of time to the input date.
+   * @param {dayjs.ConfigType} input - Input date.
+   * @param {number} value - The value of the addition (i.e.: 7).
+   * @param {dayjs.OpUnitType} unit - The unit of the addition (i.e.: "year").
+   * @returns {dayjs.Dayjs} Computed date.
+   * @see https://day.js.org/docs/en/manipulate/add
+   */
+  add(input: dayjs.ConfigType, value: number, unit?: dayjs.OpUnitType): dayjs.Dayjs;
   /**
    * Subtracts the given amount of time from the input date.
    * @param {dayjs.ConfigType} input - Input date.
@@ -89,4 +100,15 @@ export declare class KupDates {
    * @see https://day.js.org/docs/en/manipulate/subtract
    */
   subtract(input: dayjs.ConfigType, value: number, unit?: dayjs.OpUnitType): dayjs.Dayjs;
+  /**
+   * Registers a KupComponent in KupDates, in order to be properly handled whenever the locale changes.
+   * @param {any} component - The Ketchup component to be registered.
+   */
+  register(component: any): void;
+  /**
+   * Unregisters a KupComponent, so it won't be refreshed when the locale changes.
+   *
+   * @param {any} component - The component calling this function.
+   */
+  unregister(component: any): void;
 }

package/dist/types/{utils → managers}/kup-debug/kup-debug.d.ts

@@ -26,6 +26,12 @@ export declare class KupDebug {
    * Creates the debug widget.
    */
   private showWidget;
+  /**
+   * Listens the card events and handles the related actions.
+   * @param {CustomEvent<KupCardEventPayload>} e - kup-card-event.
+   * @param {KupDebug} kupDebug - Instance of the KupDebug class.
+   */
+  private handleEvents;
   /**
    * Closes the debug widget.
    */
@@ -52,14 +58,8 @@ export declare class KupDebug {
    * @param {boolean} value - If this argument is provided, the debug status will be forced to its value.
    */
   toggle(value?: boolean): void;
-  /**
-   * Listens the card events and handles the related actions.
-   * @param {CustomEvent} e - kup-card-event.
-   */
-  handleEvents(e: CustomEvent): void;
   /**
    * Function used to check whether the debug is active or not.
-   * If kupDebug on documentElement's type is not a boolean, it will be set to false.
    * @returns {boolean} Status of the debug.
    */
   isDebug(): boolean;
@@ -79,13 +79,6 @@ export declare class KupDebug {
    * @param {KupDebugCategory} category - The type of console message, defaults to log but warning and error can be used as well.
    */
   logMessage(comp: any, message: string, category?: KupDebugCategory): void;
-  /**
-   * Function used to format a date.
-   * Example: "Sun Mar 14 2021 13:50:56,329pm"
-   * @param {Date} date - Date to be formatted.
-   * @returns {string} Formatted
-   */
-  formatDate(date: Date): string;
   /**
    * Function used to time the loading times of a component.
    * @param {any} comp - The component calling this function or a string.

package/dist/types/{utils → managers}/kup-dynamic-position/kup-dynamic-position-declarations.d.ts

@@ -22,6 +22,7 @@ export interface KupDynamicPositionElement extends HTMLElement {
     anchor: KupDynamicPositionAnchor;
     detach: boolean;
     margin: number;
+    originalPath: HTMLElement[];
     placement: KupDynamicPositionPlacement;
     rAF: number;
   };

package/dist/types/{utils → managers}/kup-interact/kup-interact-declarations.d.ts

@@ -1,7 +1,7 @@
 import type { DropEvent, InteractEvent } from '@interactjs/types/index';
 import type { ResizeEvent } from '@interactjs/actions/resize/plugin';
 import { KupBoxRow } from '../../components/kup-box/kup-box-declarations';
-import { Cell, Column, Row } from '../../components/kup-data-table/kup-data-table-declarations';
+import { KupDataCell, KupDataColumn, KupDataRow } from '../kup-data/kup-data-declarations';
 /**
  * HTML Attribute attached to dialogs.
  * Referenced by kup-theme.css
@@ -95,6 +95,7 @@ export interface KupDropEventData {
 export declare enum KupDropEventTypes {
   BOX = "text/kup-box-drag",
   DATATABLE = "text/kup-data-table-row-drag",
+  GENERIC = "text/generic",
   MAGICBOX = "text/kup-magic-box-drag"
 }
 /**
@@ -109,19 +110,19 @@ export interface KupDropEventPayload {
  * Source of the drop event payload.
  */
 export interface KupDropEventSource {
-  cell?: Cell;
-  column?: Column;
+  cell?: KupDataCell;
+  column?: KupDataColumn;
   id?: string;
   multiple?: boolean;
-  row?: Row | KupBoxRow;
-  selectedRows?: Row[] | KupBoxRow[];
+  row?: KupDataRow | KupBoxRow;
+  selectedRows?: KupDataRow[] | KupBoxRow[];
 }
 /**
  * Target of the drop event payload.
  */
 export interface KupDropEventTarget {
   id?: string;
-  row?: Row | KupBoxRow;
-  cell?: Cell;
-  column?: Column;
+  row?: KupDataRow | KupBoxRow;
+  cell?: KupDataCell;
+  column?: KupDataColumn;
 }

package/dist/types/{utils → managers}/kup-interact/kup-interact.d.ts

@@ -50,13 +50,14 @@ export declare class KupInteract {
    * @param {Partial<ResizableOptions>} options - Options of the resize action.
    * @param {KupResizeCallbacks} callbacks - Additional callbacks to invoke.
    * @param {boolean} moveOnResize - When true, the element will be moved when resizing in order to keep its position.
+   * @param {boolean} autoResize - When true, the element will be automatically resized (usually the behavior is specified in a callback).
    * @see https://interactjs.io/docs/action-options/ For more options
    */
-  resizable(el: HTMLElement, options?: Partial<ResizableOptions>, callbacks?: KupResizeCallbacks, moveOnResize?: boolean): void;
+  resizable(el: HTMLElement, options?: Partial<ResizableOptions>, callbacks?: KupResizeCallbacks, moveOnResize?: boolean, autoResize?: boolean): void;
   /**
    * Adds a new interact.js event listener to the given argument.
    * @param {HTMLElement} el - The element on which the event listener will be added.
-   * @param {KupPointerEventTypes} event - Supported events.
+   * @param {KupPointerEventTypes} event - Name of the event.
    * @param {KupResizeCallbacks} callback - Callback to invoke when the event fires.
    */
   on(el: HTMLElement, event: KupPointerEventTypes, callback: ListenersArg): void;
@@ -68,7 +69,7 @@ export declare class KupInteract {
    */
   isInViewport(el: HTMLElement, oldTransform: string, delta: Point): boolean;
   /**
-   * This method treats the given element as a dialog, by activating moving-on-drag and, optionally, its resize.
+   * This method gives the element dialog-like features, by activating moving on drag and, optionally, the resize.
    * @param {HTMLElement} el - Dialog element.
    * @param {HTMLElement} handleEl - Element that must be dragged in order to trigger movement. When not provided, dragging anywhere on "el" will move it.
    * @param {boolean} unresizable - When true, the dialog can't be resized.
@@ -80,12 +81,12 @@ export declare class KupInteract {
     Interaction<keyof ActionMap>
   ]>): void;
   /**
-   * Removes the elements from the MoveOnDrag class watchlist.
-   * @param {HTMLElement[]} elements - Elements to remove.
+   * Removes all event listeners from the elements in the array.
+   * @param {HTMLElement[]} elements - Elements to handle.
    */
   unregister(elements: HTMLElement[]): void;
   /**
-   * Returns whether an element was previously registered or not.
+   * Checks whether an element is currently registered or not.
    * @param {HTMLElement} el - Element to test.
    * @returns {boolean} True if the element was registered.
    */