@apia/table2-controller 5.0.0 → 5.0.3

package/dist/index.js

@@ -1,1301 +1,21 @@
-import { makeObservable, action, observable, computed } from 'mobx';
-import { arrayOrArray, EventEmitter, useMount, scrollParentIntoElement, disableChildrenFocus, getFocusSelector } from '@apia/util';
-import { useRef } from 'react';
-
-var __defProp$7 = Object.defineProperty;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => {
-  __defNormalProp$7(obj, key + "" , value);
-  return value;
-};
-const voidTable = {};
-class Element {
-  constructor(state) {
-    this.state = state;
-    __publicField$7(this, "table", voidTable);
-    makeObservable(this, {
-      state: observable,
-      setState: action
-    });
-  }
-  getTable() {
-    return this.table;
-  }
-  setTable(table) {
-    this.table = table || voidTable;
-    return this;
-  }
-  getState(prop) {
-    return this.state[prop];
-  }
-  setState(prop, value) {
-    if (typeof prop === "function") {
-      this.state = prop(this.state);
-    } else {
-      this.state[prop] = value;
-    }
-    return this;
-  }
-}
-
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => {
-  __defNormalProp$6(obj, key + "" , value);
-  return value;
-};
-class Cell extends Element {
-  constructor() {
-    super(...arguments);
-    __publicField$6(this, "parentRow", null);
-  }
-  getColumnName() {
-    return this.getState("colName");
-  }
-  getIndex() {
-    return this.getRow().getCellIndex(this);
-  }
-  getRow() {
-    return this.parentRow;
-  }
-  setRow(row) {
-    this.parentRow = row;
-    return this;
-  }
-  /**
-   *
-   * @param doFocus - If true, the cell will be focused after being set as the focused cell.
-   *                 If false, the cell will contain the tabIndex = 0 but will not be focused.
-   */
-  focus(doFocus = true) {
-    this.table.setFocusedCell(this, doFocus);
-  }
-  updateState(state) {
-    this.state = { ...this.state, ...state };
-  }
-}
-
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => {
-  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class Row extends Element {
-  constructor(id, properties) {
-    const { cells, isSelected, ...state } = properties || {};
-    super({ id, ...state, cells: cells || [] });
-    this.properties = properties;
-    __publicField$5(this, "container", {});
-    __publicField$5(this, "hiddenCells", /* @__PURE__ */ new Map());
-    makeObservable(this, {
-      isSelected: computed
-    });
-  }
-  addCell(cell) {
-    this.state.cells.push(cell);
-    this.attachCell(cell);
-    return this;
-  }
-  addCellAfter(anchor, newElement) {
-    const index = this.state.cells.indexOf(anchor) + 1;
-    if (index !== -1) {
-      this.attachCell(newElement);
-      this.state.cells.splice(index, 0, newElement);
-    }
-  }
-  addCellBefore(anchor, newElement) {
-    const index = this.state.cells.indexOf(anchor);
-    if (index !== -1) {
-      this.attachCell(newElement);
-      this.state.cells.splice(index, 0, newElement);
-    }
-  }
-  build(data) {
-    this.hiddenCells.clear();
-    for (let i = 0; i < data.cells.length; i++) {
-      const cell = data.cells[i];
-      const col = cell.colName ? this.table.head.getHeaderRow().getColumn(cell.colName) : this.table.head.getHeaderRow().getColumns()[i];
-      const cellInstance = new Cell({
-        ...cell,
-        colName: col?.getState("colName")
-      });
-      if (col?.isVisible()) {
-        const currentCell = this.state.cells[i - this.hiddenCells.size];
-        if (!currentCell) {
-          this.addCell(cellInstance);
-        } else {
-          currentCell.updateState({
-            ...cell,
-            colName: col?.getState("colName")
-          });
-        }
-      } else {
-        this.hiddenCells.set(col?.getColumnName(), cellInstance);
-      }
-    }
-    this.cells.splice(data.cells.length - this.hiddenCells.size);
-  }
-  get cells() {
-    const hasAdditionalColumn = !!this.table.getState("onRowExpand") || (this.table.head.getFiltersRow()?.getFiltersInTable()?.length || 0) > 0;
-    let additionalCell = null;
-    if (hasAdditionalColumn) {
-      additionalCell = new AdditionalCell();
-      additionalCell.setRow(this);
-      additionalCell.setTable(this.table);
-    }
-    return [additionalCell, ...this.state.cells].filter(
-      (f) => Boolean(f)
-    );
-  }
-  get isSelected() {
-    return this.table.isSelected(this);
-  }
-  getCellByColumnName(colName) {
-    return this.cells.find((c) => c.getState("colName") === colName);
-  }
-  getCellByIndex(index) {
-    return this.cells[index];
-  }
-  getCellIndex(cell) {
-    return this.cells.indexOf(cell);
-  }
-  getContainer() {
-    return this.container;
-  }
-  getFollowingRow() {
-    const containerRows = [...this.container.getState("rows").values()];
-    const index = containerRows.findIndex(
-      (r) => r.getState("id") === this.state.id
-    );
-    return containerRows[index + 1] || null;
-  }
-  getHiddenCell(colName) {
-    return this.hiddenCells.get(colName);
-  }
-  getIndex() {
-    return this.getContainer().getRowIndex(this);
-  }
-  getPreviousRow() {
-    const containerRows = [...this.container.getState("rows").values()];
-    const index = containerRows.findIndex(
-      (r) => r.getState("id") === this.state.id
-    );
-    return containerRows[index - 1] || null;
-  }
-  insertAfter(row) {
-    this.getContainer()?.insertAfter(this, row);
-  }
-  insertBefore(row) {
-    this.getContainer()?.insertBefore(this, row);
-  }
-  remove() {
-    this.getContainer()?.removeRow(this);
-  }
-  replaceCellOnIndex(index, newCell) {
-    const current = this.cells[index];
-    if (!current) {
-      throw new Error("IndexOutOfBounds - The provided index is out of bounds");
-    }
-    this.cells[index] = newCell;
-    this.attachCell(newCell);
-    this.detachCell(current);
-  }
-  scrollIntoView() {
-    this.table.scrollRowIntoView(this);
-  }
-  setContainer(container) {
-    this.container = container;
-    return this;
-  }
-  setTable(table) {
-    super.setTable(table);
-    this.state.cells.forEach((c) => c.setTable(table));
-    if (table && this.properties?.isSelected) {
-      table.toggleRowSelection(this, true);
-    }
-    return this;
-  }
-  swap(withRow) {
-    this.getContainer()?.swapRows(this, withRow);
-  }
-  toggleSelection(forceState) {
-    this.table.toggleRowSelection(this, forceState);
-  }
-  attachCell(cell) {
-    cell.setTable(this.table);
-    cell.setRow(this);
-  }
-  detachCell(cell) {
-    cell.setTable(null);
-    cell.setRow(null);
-  }
-}
-
-class AdditionalRow extends Row {
-  constructor(id) {
-    super(id);
-    this.setState("isSelectable", false);
-  }
-  get cells() {
-    return this.state.cells;
-  }
-}
-
-class AdditionalRowContent extends Cell {
-  constructor(content) {
-    super({
-      expanded: false,
-      colName: "__additional",
-      content
-    });
-  }
-  getState(prop) {
-    if (prop === "domProperties") {
-      return {
-        colSpan: this.table.head.getHeaderRow()?.getShownColumns().length || 0
-      };
-    }
-    return super.getState(prop);
-  }
-}
-
-class AdditionalCell extends Cell {
-  constructor() {
-    super({
-      expanded: false,
-      colName: "__additional",
-      domProperties: {
-        className: "additionalColumn",
-        style: {
-          width: "50px"
-        }
-      }
-    });
-  }
-  async onToggle() {
-    const currentIndex = this.getRow().getIndex();
-    if (!(this.getTable().body.getRowByIndex(currentIndex + 1) instanceof AdditionalRow)) {
-      const res = await this.table.onRowExpand(this.getRow());
-      if (res !== false) {
-        const newRow = new AdditionalRow(
-          `${this.getRow()?.getState("id")}__additional`
-        );
-        this.getTable().body.insertAfter(this.getRow(), newRow);
-        newRow.addCell(new AdditionalRowContent(res));
-        this.state.expanded = true;
-      }
-    } else {
-      this.getTable().body.getRowByIndex(currentIndex + 1).remove();
-      this.state.expanded = false;
-    }
-  }
-}
-
-class RowsGroup extends Element {
-  constructor(table, state) {
-    super({ ...state, rows: [] });
-    this.table = table;
-    makeObservable(this, { swapRows: action, rows: computed });
-  }
-  get rows() {
-    return this.state.rows;
-  }
-  addRow(row) {
-    this.state.rows.push(row);
-    row.setTable(this.table);
-    row.setContainer(this);
-    this.runAddRowPlugin(row);
-    return this;
-  }
-  addRows(rows) {
-    rows.forEach(this.addRow.bind(this));
-    return this;
-  }
-  clear() {
-    this.state.rows.forEach((row) => {
-      row.setContainer(null);
-      row.setTable(null);
-    });
-    return this.rows.splice(0, this.rows.length);
-  }
-  getRowById(id) {
-    return this.state.rows.find((c) => c.getState("id") === id);
-  }
-  getRowByIndex(index) {
-    return this.state.rows[index];
-  }
-  getRowIndex(row) {
-    return this.state.rows.indexOf(row);
-  }
-  insertAfter(anchor, newElement) {
-    if (anchor.getContainer() === this) {
-      const index = this.state.rows.indexOf(anchor);
-      this.state.rows.splice(index + 1, 0, newElement);
-      newElement.setTable(this.table);
-      newElement.setContainer(this);
-      this.runAddRowPlugin(newElement);
-    }
-  }
-  insertBefore(anchor, newElement) {
-    if (anchor.getContainer() === this) {
-      const index = this.state.rows.indexOf(anchor);
-      this.state.rows.splice(index, 0, newElement);
-      newElement.setTable(this.table);
-      newElement.setContainer(this);
-      this.runAddRowPlugin(newElement);
-    }
-  }
-  removeRow(row) {
-    if (row.getContainer() === this) {
-      row.setContainer(null);
-      this.state.rows = this.state.rows.filter((r) => r !== row);
-      this.table.removeRow(row);
-    }
-  }
-  swapRows(a, b) {
-    if (a?.getContainer() === this && b?.getContainer() === this) {
-      const aIndex = this.state.rows.findIndex(
-        (r) => r.getState?.("id") === a.getState?.("id")
-      );
-      const bIndex = this.state.rows.findIndex(
-        (r) => r.getState?.("id") === b.getState?.("id")
-      );
-      if (aIndex !== -1 && bIndex !== -1) {
-        this.state.rows[aIndex] = b;
-        this.state.rows[bIndex] = a;
-      }
-    }
-  }
-  runAddRowPlugin(newRow) {
-    const plugins = this.getTable().getApplicablePlugins("onAddRow");
-    plugins.forEach((c) => c(this, newRow));
-  }
-}
-
-class TableBody extends RowsGroup {
-  constructor(table) {
-    super(table, { rows: [] });
-  }
-  build(data) {
-    let i = 0;
-    for (const row of data.rows) {
-      let currentRow = this.rows[i++];
-      if (currentRow instanceof AdditionalRow) {
-        currentRow.remove();
-        currentRow = void 0;
-      }
-      const bodyRow = currentRow ?? new Row(row.id);
-      if (!currentRow) {
-        this.addRow(bodyRow);
-      }
-      bodyRow.build(row);
-    }
-    this.rows.splice(data.rows.length);
-  }
-}
-
-class Column extends Cell {
-  asAdditional() {
-    return !!this.state.asAdditional;
-  }
-  isHidden() {
-    return !!this.state.isHidden;
-  }
-  /**
-   * A visible column is that which is not additional nor hidden.
-   */
-  isVisible() {
-    return !this.asAdditional() && !this.isHidden();
-  }
-  sort(order) {
-    order = order ?? (this.getState("sortState") === "ASC" ? "DESC" : "ASC");
-    this.setState("sortState", order);
-  }
-}
-
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, key + "" , value);
-  return value;
-};
-class Columns extends Row {
-  constructor() {
-    super(...arguments);
-    __publicField$4(this, "columns", /* @__PURE__ */ new Map());
-  }
-  buildColumnsRow(columns) {
-    let i = 0;
-    for (const column of columns) {
-      if (!this.columns.has(column.colName)) {
-        this.columns.set(column.colName, new Column(column));
-      } else {
-        this.columns.get(column.colName)?.updateState(column);
-      }
-      const currentColumn = this.columns.get(column.colName);
-      if (currentColumn.isVisible()) {
-        this.state.cells[i++] = currentColumn;
-        this.attachCell(currentColumn);
-      }
-    }
-  }
-  getColumn(name) {
-    return this.getCellByColumnName(name);
-  }
-  getColumns() {
-    return Array.from(this.columns.values());
-  }
-  getAdditionalColumns() {
-    return this.getColumns().filter((c) => c.asAdditional());
-  }
-  getShownColumns() {
-    return this.cells ?? [];
-  }
-}
-
-class Filter extends Cell {
-  asAdditional() {
-    return !!this.state.asAdditional || !this.getCorrespondingColumn();
-  }
-  constructor(state) {
-    super(state);
-  }
-  clear() {
-    this.setValue("");
-  }
-  getCorrespondingColumn() {
-    return this.getRow().getContainer().getHeaderRow()?.getShownColumns().find((c) => c.getState("colName") === this.getState("colName"));
-  }
-  fire(ev) {
-    this.table.emit(ev, this);
-  }
-  getRow() {
-    return super.getRow();
-  }
-  getValue() {
-    return this.state.value;
-  }
-  hasValue() {
-    return !!this.getValue();
-  }
-  setValue(val) {
-    this.state.value = val;
-    this.table.emit("filterChange", this);
-  }
-  validate() {
-    return this.state.isRequired ? this.hasValue() : true;
-  }
-}
-
-class NullFilter extends Filter {
-  constructor(colName) {
-    super({ colName });
-  }
-  clear() {
-  }
-  fire(_) {
-  }
-  getValue() {
-    return void 0;
-  }
-  hasValue() {
-    return false;
-  }
-  setValue() {
-  }
-  validate() {
-    return true;
-  }
-}
-
-class DateFilter extends Filter {
-}
-
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, key + "" , value);
-  return value;
-};
-class Filters extends Row {
-  constructor() {
-    super(...arguments);
-    __publicField$3(this, "filters", /* @__PURE__ */ new Map());
-  }
-  buildFilterFromDefinition(def) {
-    switch (def.type) {
-      case "DATE":
-        return new DateFilter(def);
-      default:
-        return new Filter(def);
-    }
-  }
-  buildFilters(filters) {
-    let hasFiltersInRow = false;
-    const columns = arrayOrArray(
-      this.getContainer().getHeaderRow()?.getShownColumns()
-    );
-    for (const stored of this.filters.values()) {
-      if (!filters.find((c) => c.name === stored.getState("name"))) {
-        this.filters.delete(stored.getState("name"));
-      }
-    }
-    for (let i = 0; i < columns.length; i++) {
-      const column = columns[i];
-      const filter = filters.find(
-        (c) => c.columnName === column.getState("colName") && !c.asAdditional
-      );
-      if (filter) {
-        const currentFilterCell = this.getCellByIndex(i);
-        const filterCell = currentFilterCell ?? this.buildFilterFromDefinition({
-          ...filter,
-          colName: filter.columnName
-        });
-        this.filters.set(filter.name, filterCell);
-        if (!currentFilterCell) {
-          this.addCell(filterCell);
-        } else {
-          const { value, ...filterState } = filter;
-          currentFilterCell.updateState(filterState);
-        }
-        hasFiltersInRow = true;
-        filter.added = true;
-      } else {
-        if (!this.getCellByIndex(i)) {
-          this.addCell(new NullFilter(column.getColumnName()));
-        }
-      }
-    }
-    for (const filter of filters) {
-      if (!filter.added) {
-        const filterCell = this.filters.get(filter.name) ?? this.buildFilterFromDefinition({
-          ...filter,
-          colName: filter.columnName
-        });
-        filterCell.setTable(this.table);
-        this.filters.set(filter.name, filterCell);
-      }
-    }
-    return hasFiltersInRow;
-  }
-  getAdditionalFilters() {
-    return this.getFilters().filter(
-      (c) => c.getState("asAdditional") || this.getContainer().getHeaderRow()?.columns.get(c.getState("colName"))?.asAdditional()
-    );
-  }
-  getCells() {
-    return this.cells.map((c) => c);
-  }
-  getContainer() {
-    return this.container;
-  }
-  getFilter(name) {
-    return this.filters.get(name);
-  }
-  getFilters() {
-    return Array.from(this.filters.values());
-  }
-  getFiltersInTable() {
-    return this.getFilters().filter((f) => {
-      return !(f.getState("asAdditional") || this.getContainer().getHeaderRow()?.columns.get(f.getState("colName"))?.isVisible() === false);
-    });
-  }
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class TableHead extends RowsGroup {
-  constructor(table) {
-    super(table, { rows: [] });
-    __publicField$2(this, "columnsRow", null);
-    __publicField$2(this, "filtersRow", null);
-  }
-  getHeaderRow() {
-    return this.rows[0] instanceof Columns ? this.rows[0] : void 0;
-  }
-  getFiltersRow() {
-    return this.rows[1] instanceof Filters ? this.rows[1] : void 0;
-  }
-  build(data) {
-    if (data.columns.length) {
-      const currentHeaderRow = this.rows[0];
-      if (currentHeaderRow && !(currentHeaderRow instanceof Columns)) {
-        currentHeaderRow.remove();
-      }
-      this.columnsRow = currentHeaderRow ?? new Columns("header");
-      this.columnsRow.setTable(this.table);
-      this.columnsRow.setContainer(this);
-      if (!currentHeaderRow) {
-        this.addRow(this.columnsRow);
-      }
-      this.columnsRow.buildColumnsRow(data.columns);
-    }
-    if (data.filters.length) {
-      const currentFiltersRow = this.getFiltersRow();
-      this.filtersRow = currentFiltersRow ?? new Filters("filters");
-      this.filtersRow.setTable(this.table);
-      this.filtersRow.setContainer(this);
-      const hasFilter = this.filtersRow.buildFilters(data.filters);
-      if (hasFilter && !currentFiltersRow) {
-        this.addRow(this.filtersRow);
-      }
-    }
-  }
-}
-
-const defaultPlugins = () => [
-  new WaiAriaPlugin(),
-  new FocusControllerPlugin()
-];
-
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class TableController extends EventEmitter {
-  constructor(props) {
-    super();
-    __publicField$1(this, "state", {
-      allowEdition: true,
-      allowResize: true,
-      allowSelection: true,
-      editionMode: false,
-      focusedCell: null,
-      plugins: [],
-      isSelectionMultiple: true,
-      selection: /* @__PURE__ */ new Set()
-    });
-    __publicField$1(this, "body", new TableBody(this));
-    __publicField$1(this, "head", new TableHead(this));
-    Object.assign(this.state, props || {});
-    if (!props?.plugins) {
-      this.state.plugins.push(...defaultPlugins());
-    }
-    makeObservable(this, {
-      build: action,
-      clearSelection: action,
-      isEditionMode: computed,
-      setFocusedCell: action,
-      state: observable,
-      toggleRowSelection: action,
-      toggleEditionMode: action
-    });
-  }
-  /**
-   * Clears all data in the table, except for the events
-   * listeners and recreates the structure based on the passed data.
-   */
-  build(data) {
-    this.head.build(data);
-    this.body.build(data);
-    this.restoreFocus();
-  }
-  fromGenericTable(table) {
-    this.setState("allowEdition", table.behavior.allowEdition);
-    this.setState("allowSelection", table.behavior.allowSelection);
-    this.setState("isSelectionMultiple", table.behavior.isMultipleSelection);
-    const columns = arrayOrArray(table.columns);
-    this.build({
-      columns: columns.map((c) => {
-        return {
-          colName: c.name,
-          asAdditional: c.showAsAdditional,
-          sortable: c.isSortable,
-          isHidden: c.isHidden,
-          properties: c,
-          content: c.title,
-          className: c.className,
-          sortState: c.sortType
-        };
-      }),
-      filters: arrayOrArray(table.filters).map((f) => {
-        return {
-          name: f.name,
-          title: f.title,
-          tooltip: "no tooltip",
-          type: f.type,
-          isRequired: f.isRequired,
-          properties: f,
-          runAutomatically: f.runAutomatically,
-          columnName: f.columnName,
-          value: f.initialValue,
-          asAdditional: f.asAdditional
-        };
-      }),
-      rows: arrayOrArray(table.rows).map((row) => {
-        const returnValue = {
-          id: row.id,
-          cells: arrayOrArray(row.cells).map((cell) => {
-            const returnValue2 = {
-              content: cell.text
-            };
-            return returnValue2;
-          }),
-          isExpandible: false,
-          isSelectable: !row.isDisabled,
-          isSelected: row.isSelected,
-          domProperties: {},
-          properties: row
-        };
-        return returnValue;
-      })
-    });
-  }
-  getColumn(name) {
-    return this.head.getHeaderRow()?.getColumn(name);
-  }
-  getColumns() {
-    return this.head.getHeaderRow()?.getColumns() || [];
-  }
-  getFilter(name) {
-    return this.head.getFiltersRow()?.getFilter(name);
-  }
-  getFilters() {
-    return this.head.getFiltersRow()?.getFilters() || [];
-  }
-  getRowById(id) {
-    return this.head.getRowById(id) || this.body.getRowById(id);
-  }
-  hasAdditionalContent() {
-    return !!this.head.getHeaderRow()?.getColumns().find((c) => c.asAdditional()) || this.getState("onRowExpand");
-  }
-  onRowExpand(row) {
-    return this.getState("onRowExpand")?.(row) || this.head.getHeaderRow()?.getAdditionalColumns().map(
-      (column) => `${column.getState("content")}: ${row.getHiddenCell(column.getColumnName())?.getState("content")}`
-    ).join(", ");
-  }
-  /**
-   * EDITION MODE
-   */
-  get isEditionMode() {
-    return this.state.editionMode;
-  }
-  toggleEditionMode(force) {
-    if (this.state.allowEdition) {
-      this.state.editionMode = force ?? !this.state.editionMode;
-      this.emit("editionMode", this.state.editionMode);
-    }
-  }
-  /**
-   * SELECTION
-   */
-  clearSelection() {
-    this.state.selection.clear();
-  }
-  /**
-   * Returns the selected rows.
-   */
-  getSelectedRows() {
-    return [...this.state.selection];
-  }
-  isSelected(row) {
-    return this.state.selection.has(row);
-  }
-  toggleColumnVisibility(colName, isVisible) {
-    isVisible = isVisible ?? this.head.getHeaderRow()?.getColumn(colName).getState("isHidden");
-    if (this.head.getHeaderRow()) {
-      this.head.getHeaderRow()?.getColumn(colName).setState("isHidden", isVisible);
-    } else {
-      this.head.rows[0]?.cells?.find((c) => c.getState("colName") === colName)?.setState("isHidden", !isVisible);
-    }
-  }
-  toggleFiltersRowVisibility() {
-    this.head.getFiltersRow()?.setState("isHidden", !this.head.getFiltersRow()?.getState("isHidden"));
-  }
-  /**
-   * Toggles the selection state of a given row.
-   *
-   * If the `isSelected` parameter is provided, it explicitly sets the selection
-   * state of the row to the given value (`true` for selected, `false` for deselected).
-   * If `isSelected` is not provided, the method will toggle the current selection state
-   * of the row (i.e., select it if it's currently not selected, or deselect it if it is).
-   *
-   * @param row - The row to toggle selection for.
-   * @param isSelected - Optional. A boolean indicating whether the row should be selected (`true`)
-   *                     or deselected (`false`). If not provided, the selection state will be toggled.
-   */
-  toggleRowSelection(row, isSelected) {
-    if (this.state.allowSelection) {
-      isSelected = isSelected ?? !this.state.selection.has(row);
-      if (isSelected) {
-        if (row.getState("isSelectable") !== false) {
-          this.state.selection.add(row);
-        }
-      } else {
-        this.state.selection.delete(row);
-      }
-      this.emit("selectionChange", [...this.state.selection.values()]);
-    }
-  }
-  restoreFocus() {
-    if (!this.state.focusedCell || this.state.focusedCell.getTable() !== this) {
-      this.state.focusedCell = this.body.getState("rows").values().next().value?.cells[0] || this.head.getState("rows").values().next().value?.cells[0] || null;
-    }
-    if (this.state.focusedCell) {
-      this.emit("cellFocus", { cell: this.state.focusedCell, doFocus: false });
-    }
-  }
-  removeRow(row) {
-    if (row.getTable() === this) {
-      row.setTable(null);
-      this.head.removeRow(row);
-      this.body.removeRow(row);
-      if (this.state.selection.has(row)) {
-        this.state.selection.delete(row);
-        this.emit("selectionChange", [...this.state.selection.values()]);
-      }
-      if (this.state.focusedCell?.getRow() === row) {
-        this.restoreFocus();
-      }
-    }
-  }
-  /**
-   * FOCUS
-   */
-  /**
-   * @returns The currently focused cell in the table.
-   */
-  getFocusedCell() {
-    return this.state.focusedCell;
-  }
-  setFocusedCell(cell, doFocus = true) {
-    this.state.focusedCell = cell;
-    this.emit("cellFocus", { cell, doFocus });
-  }
-  setSelection(indices) {
-    this.clearSelection();
-    indices.forEach((index) => {
-      const row = this.body.getRowByIndex(index);
-      if (row) {
-        this.toggleRowSelection(row, true);
-      }
-    });
-  }
-  scrollRowIntoView(row) {
-    this.emit("scrollIntoRow", row);
-  }
-  /**
-   * STATE
-   */
-  /**
-   * Returns the current state of the `TableController` instance.
-   *
-   * @param prop - The property of the state to retrieve.
-   */
-  getState(prop) {
-    return this.state[prop];
-  }
-  setState(prop, value) {
-    if (typeof prop === "function") {
-      this.state = prop(this.state);
-    } else {
-      this.state[prop] = value;
-    }
-    return this;
-  }
-  sortColumn(col, sortState) {
-    this.getColumns().forEach((c) => {
-      if (c.getColumnName() !== col.getColumnName()) {
-        c.sort("NONE");
-      }
-    });
-    col.sort(sortState);
-    this.emit("columnSort", col);
-  }
-  /**
-   * PLUGINS
-   */
-  getPluginOfType(clazz) {
-    return this.state.plugins.find((plugin) => plugin instanceof clazz);
-  }
-  /**
-   * Sets the plugins for the table.
-   */
-  setPlugins(cb) {
-    this.state.plugins = cb(this.state.plugins);
-  }
-  getApplicablePlugins(method) {
-    return this.state.plugins.filter((c) => c[method] !== void 0).map((c) => c[method].bind(c, this));
-  }
-}
-
-function getRow(controller, rowElement) {
-  const rowId = rowElement.dataset.rowid;
-  const row = controller.getRowById(rowId);
-  return row;
-}
-function selectBetweenRows(controller, rowA, rowB) {
-  const relativePosition = rowA.compareDocumentPosition(rowB);
-  let finished = false;
-  if (relativePosition & Node.DOCUMENT_POSITION_FOLLOWING) {
-    let current = rowA;
-    if (rowA.closest("thead") && !rowB.closest("thead")) {
-      current = rowA.closest("table")?.querySelector("tbody")?.firstElementChild;
-    }
-    while (!finished) {
-      if (current) {
-        getRow(controller, current)?.toggleSelection(true);
-        finished = current === rowB;
-        current = current.nextElementSibling;
-      } else {
-        finished = true;
-      }
-    }
-  } else if (relativePosition & Node.DOCUMENT_POSITION_PRECEDING) {
-    let current = rowA;
-    while (!finished) {
-      if (current) {
-        getRow(controller, current)?.toggleSelection(true);
-        finished = current === rowB;
-        current = current.previousElementSibling;
-      } else {
-        finished = true;
-      }
-    }
-  }
-}
-function useFocusByClick(controller) {
-  const lastRow = useRef(null);
-  return (ev) => {
-    const { target } = ev;
-    if (target instanceof HTMLElement) {
-      const cellElement = target.closest("td[data-colname],th[data-colname]");
-      const rowElement = target.closest("tr[data-rowid]");
-      if (rowElement instanceof HTMLTableRowElement) {
-        const row = getRow(controller, rowElement);
-        if (row) {
-          if (ev.shiftKey) {
-            if (lastRow.current) {
-              selectBetweenRows(controller, lastRow.current, rowElement);
-            }
-          } else if (ev.ctrlKey) {
-            row?.toggleSelection();
-          } else {
-            controller.clearSelection();
-            row?.toggleSelection(true);
-          }
-          lastRow.current = rowElement;
-          if (cellElement instanceof HTMLTableCellElement) {
-            const colName = cellElement.dataset.colname;
-            const cell = row?.getCellByColumnName(colName);
-            if (cell) {
-              if (target.closest("thead")) {
-                controller.emit("columnClick", cell);
-              }
-              cell?.focus(true);
-            }
-          }
-        }
-      }
-    }
-  };
-}
-
-const pageSize = 6;
-function handleArrowKey(controller, ev) {
-  const { target } = ev;
-  if (target instanceof HTMLElement) {
-    const cellElement = target.closest("td[data-colname],th[data-colname]");
-    const rowElement = target.closest("tr[data-rowid]");
-    if (rowElement instanceof HTMLTableRowElement) {
-      if (cellElement instanceof HTMLTableCellElement) {
-        const colName = cellElement.dataset.colname;
-        let nextFocusedRow = rowElement;
-        let nextFocusedCell = cellElement;
-        switch (ev.code) {
-          case "ArrowUp": {
-            const test = rowElement?.previousElementSibling;
-            if (test) {
-              nextFocusedRow = test;
-            } else if (nextFocusedRow.closest("tbody")) {
-              const thead = nextFocusedRow.closest("table").querySelector("thead");
-              nextFocusedRow = thead.lastElementChild;
-            }
-            break;
-          }
-          case "ArrowDown": {
-            const test = rowElement?.nextElementSibling;
-            if (test) {
-              nextFocusedRow = test;
-            } else if (nextFocusedRow.closest("thead")) {
-              const tbody = nextFocusedRow.closest("table").querySelector("tbody");
-              nextFocusedRow = tbody.firstElementChild;
-            }
-            break;
-          }
-          case "ArrowLeft":
-            nextFocusedCell = cellElement.previousElementSibling;
-            break;
-          case "ArrowRight":
-            nextFocusedCell = cellElement.nextElementSibling;
-            break;
-          case "PageUp": {
-            let i = 0;
-            do {
-              const test = nextFocusedRow.previousElementSibling;
-              if (!test && nextFocusedRow.closest("tbody")) {
-                const thead = nextFocusedRow.closest("table").querySelector("thead");
-                nextFocusedRow = thead.lastElementChild;
-              } else if (test) {
-                nextFocusedRow = test;
-              }
-            } while (nextFocusedRow instanceof HTMLTableRowElement && ++i < pageSize);
-            break;
-          }
-          case "PageDown": {
-            let i = 0;
-            do {
-              const test = nextFocusedRow.nextElementSibling;
-              if (!test && nextFocusedRow.closest("thead")) {
-                const tbody = nextFocusedRow.closest("table").querySelector("tbody");
-                nextFocusedRow = tbody.firstElementChild;
-              } else if (test) {
-                nextFocusedRow = test;
-              }
-            } while (nextFocusedRow instanceof HTMLTableRowElement && ++i < pageSize);
-            break;
-          }
-          case "Home": {
-            if (ev.ctrlKey) {
-              nextFocusedRow = rowElement.closest("table")?.querySelector("thead tr");
-            } else {
-              nextFocusedCell = rowElement.firstElementChild;
-            }
-            break;
-          }
-          case "End":
-            if (ev.ctrlKey) {
-              nextFocusedRow = rowElement.closest("table").querySelector("tbody").lastElementChild;
-            } else {
-              nextFocusedCell = rowElement.lastChild;
-            }
-        }
-        if (nextFocusedCell !== cellElement && nextFocusedCell) {
-          getRow(controller, rowElement).getCellByColumnName(nextFocusedCell.dataset.colname).focus();
-        } else if (nextFocusedRow !== rowElement && nextFocusedRow) {
-          if (ev.shiftKey) {
-            selectBetweenRows(controller, rowElement, nextFocusedRow);
-          } else {
-            controller.clearSelection();
-            getRow(controller, nextFocusedRow)?.toggleSelection(true);
-          }
-          const cell = getRow(controller, nextFocusedRow).getCellByColumnName(colName) || getRow(controller, nextFocusedRow).getCellByIndex(0);
-          cell?.focus();
-        }
-      }
-    }
-  }
-}
-function useFocusByKey(controller) {
-  return (ev) => {
-    if (controller.isEditionMode) {
-      if (["Enter", "Escape"].includes(ev.code)) {
-        ev.preventDefault();
-      }
-      switch (ev.code) {
-        case "Enter":
-          controller.emit("keyEnter", null);
-          break;
-        case "Escape":
-          controller.toggleEditionMode(false);
-      }
-    } else {
-      if ([
-        "Escape",
-        "ArrowUp",
-        "ArrowDown",
-        "ArrowLeft",
-        "ArrowRight",
-        "PageUp",
-        "PageDown",
-        "Home",
-        "End"
-      ].includes(ev.code) || ev.code === "Enter" && controller.getState("allowEdition") || ev.code === "Space" && ev.ctrlKey) {
-        ev.preventDefault();
-      }
-      switch (ev.code) {
-        case "Enter":
-          controller.emit("keyEnter", null);
-          controller.toggleEditionMode();
-          break;
-        case "Space":
-          {
-            if (ev.ctrlKey) {
-              const row = ev.target?.closest("tr");
-              if (row instanceof HTMLElement) {
-                getRow(controller, row).toggleSelection();
-              }
-            }
-          }
-          break;
-        case "ArrowUp":
-        case "ArrowDown":
-        case "ArrowLeft":
-        case "ArrowRight":
-        case "Home":
-        case "End":
-        case "PageUp":
-        case "PageDown":
-          handleArrowKey(controller, ev);
-          break;
-      }
-    }
-  };
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, key + "" , value);
-  return value;
-};
-function getCellElement(focusControllerRef, cell) {
-  return focusControllerRef.querySelector(
-    `tr[data-rowid="${cell.getRow().getState("id")}"] td[data-colname="${cell.getState("colName")}"], tr[data-rowid="${cell.getRow().getState("id")}"] th[data-colname="${cell.getState("colName")}"]`
-  );
-}
-function isVisible(el) {
-  if (!(el instanceof HTMLElement))
-    return false;
-  while (el) {
-    const style = getComputedStyle(el);
-    if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
-      return false;
-    }
-    el = el.parentElement;
-  }
-  return true;
-}
-function scrollIntoRow(row) {
-  if (row) {
-    scrollParentIntoElement(row, 150, 0, 0);
-  }
-}
-function restoreFocus(controller, tableElement, doFocus) {
-  const cell = controller.getFocusedCell();
-  if (cell) {
-    const cellElement = getCellElement(tableElement, cell);
-    if (cellElement) {
-      disableChildrenFocus(tableElement);
-      const widgets = cellElement.querySelectorAll(getFocusSelector());
-      const widget = [...widgets].find((c) => isVisible(c));
-      const focusableElement = widget || cellElement;
-      focusableElement.setAttribute("tabindex", "0");
-      restoreEditionMode(tableElement, cell.getTable().isEditionMode);
-      if (doFocus) {
-        focusableElement.focus();
-      }
-    }
-  }
-}
-function restoreEditionMode(focusController, editionMode) {
-  const focusable = focusController?.querySelector(
-    '[tabindex="0"]'
-  );
-  const cell = focusable?.closest("td, th");
-  if (cell instanceof HTMLElement) {
-    const widgets = cell.querySelectorAll(getFocusSelector());
-    widgets.forEach((widget) => {
-      widget.setAttribute("tabindex", editionMode ? "0" : "-1");
-    });
-    const firstFocusable = [...widgets].find((c) => isVisible(c)) || cell;
-    firstFocusable.setAttribute("tabindex", "0");
-  }
-}
-class FocusControllerPlugin {
-  constructor() {
-    __publicField(this, "rootElement", null);
-  }
-  scrollIntoView(rowId) {
-    const row = this.rootElement?.querySelector(
-      `tr[data-rowid="${rowId}"]`
-    );
-    if (row) {
-      scrollIntoRow(row);
-    }
-  }
-  useElementDomProps(controller, element, _context) {
-    if (element instanceof TableController) {
-      const disconnect = useRef(() => {
-      });
-      useMount(() => {
-        const uns1 = controller.on("cellFocus", (ev) => {
-          if (this.rootElement) {
-            restoreFocus(controller, this.rootElement, ev.doFocus);
-          }
-        });
-        const uns2 = controller.on("editionMode", (editionMode) => {
-          if (this.rootElement) {
-            restoreEditionMode(this.rootElement, editionMode);
-          }
-        });
-        const uns3 = controller.on("scrollIntoRow", (row) => {
-          this.scrollIntoView(row.getState("id"));
-        });
-        return () => {
-          uns1();
-          uns2();
-          uns3();
-        };
-      });
-      return {
-        className: "table__focus_controller",
-        onClick: useFocusByClick(controller),
-        onKeyDown: useFocusByKey(controller),
-        onBlur: (ev) => {
-          if (ev.relatedTarget instanceof HTMLElement && ev.relatedTarget.closest(".table__focus_controller") !== this.rootElement) {
-            controller.toggleEditionMode(false);
-          }
-        },
-        ref: (el) => {
-          this.rootElement = el;
-          if (el) {
-            const observer = new MutationObserver(() => {
-              restoreFocus(controller, this.rootElement, false);
-            });
-            disconnect.current?.();
-            observer.observe(el, { subtree: true, childList: true });
-            disconnect.current = () => {
-              observer.disconnect();
-            };
-          }
-        }
-      };
-    }
-    return {};
-  }
-}
-
-class WaiAriaPlugin {
-  useElementDomProps(controller, element, context) {
-    if (element instanceof Row) {
-      const base = element.getContainer() === controller.head ? 0 : controller.head.rows.length;
-      return {
-        "aria-selected": element.isSelected,
-        "aria-rowindex": context + base + 1
-      };
-    } else if (element instanceof Cell) {
-      return {
-        "aria-colindex": context + 1
-      };
-    } else if (element instanceof TableController) {
-      return {
-        role: "treegrid",
-        "aria-multiselectable": controller.getState("allowSelection") && controller.getState("isSelectionMultiple") ? true : void 0,
-        "aria-colcount": controller.head.rows[0]?.cells.length || 0,
-        "aria-rowcount": controller.head.rows.length + controller.body.rows.length
-      };
-    }
-    return {};
-  }
-}
-
-export { AdditionalCell, AdditionalRow, Cell, Column, Columns, DateFilter, Element, Filter, Filters, FocusControllerPlugin, Row, RowsGroup, TableBody, TableController, TableHead, WaiAriaPlugin, defaultPlugins };
+export { AdditionalCell } from './data/primitive/AdditionalCell.js';
+export { AdditionalRow } from './data/primitive/AdditionalRow.js';
+export { Cell } from './data/primitive/Cell.js';
+export { Row } from './data/primitive/Row.js';
+export { TableController } from './data/TableController.js';
+export { TableBody } from './data/body/TableBody.js';
+export { defaultPlugins } from './data/plugins/TablePlugin.js';
+export { FocusControllerPlugin } from './data/plugins/FocusControllerPlugin/index.js';
+export { WaiAriaPlugin } from './data/plugins/WaiAriaPlugin.js';
+export { Element } from './data/primitive/Element.js';
+export { RowsGroup } from './data/primitive/RowsGroup.js';
+export { Filter } from './data/filter/Filter.js';
+export { DateFilter } from './data/filter/DateFilter.js';
+export { TableHead } from './data/head/TableHead.js';
+export { Column } from './data/head/Column.js';
+export { Columns } from './data/head/Columns.js';
+export { Filters } from './data/head/Filters.js';
+export { DateRangeFilter } from './data/filter/DateRangeFilter.js';
+export { DateTimeRangeFilter } from './data/filter/DateTimeRangeFilter.js';
+export { ComboFilter } from './data/filter/ComboFilter.js';
 //# sourceMappingURL=index.js.map