@sankhyalabs/ezui 0.0.0-bugfix-dev-KB-08202.0

package/dist/collection/components/ez-grid/controller/ag-grid/AgGridUtils.js

@@ -0,0 +1,8 @@
+export function calcFilterColumnLeftPosition(leftReference) {
+  const FIX_MARGIN = 60;
+  const FILTER_COLUMN_WIDTH = 330;
+  const screenWidth = window.innerWidth;
+  const maxLeft = screenWidth - (FILTER_COLUMN_WIDTH + FIX_MARGIN);
+  const leftInt = leftReference - FIX_MARGIN;
+  return leftInt > maxLeft ? maxLeft : leftInt;
+}

package/dist/collection/components/ez-grid/controller/ag-grid/DataSource.js

@@ -0,0 +1,101 @@
+import { Action, ObjectUtils } from "@sankhyalabs/core";
+export default class DataSource {
+  constructor(dataUnit, controller, options) {
+    this.RECORD_ARCHIVE = "__RECORD_ARCHIVE__";
+    this.duObserver = (action) => {
+      switch (action.type) {
+        case Action.METADATA_LOADED:
+          this._controller.setColumnsDef(this.buildColumnDefs());
+          break;
+        case Action.LOADING_DATA:
+          this._waitingForLoad = true;
+          this._controller.refresh();
+          break;
+        case Action.DATA_LOADED:
+          this._waitingForLoad = false;
+          this.callbackGetRows(this._lastLoadingParams);
+          if (this._options) {
+            this._options.onPaginationChange(this._dataUnit.getPaginationInfo());
+          }
+          this.updateSelection();
+          break;
+        case Action.RECORDS_REMOVED:
+        case Action.DATA_SAVED:
+        case Action.EDITION_CANCELED:
+        case Action.DATA_CHANGED:
+        case Action.DATA_RESOLVED:
+          this._controller.refresh();
+          break;
+        case Action.SELECTION_CHANGED:
+        case Action.NEXT_SELECTED:
+        case Action.PREVIOUS_SELECTED:
+          this.updateSelection();
+          break;
+      }
+    };
+    this._dataUnit = dataUnit;
+    this._controller = controller;
+    this._controller.setColumnsDef(this.buildColumnDefs());
+    this._options = options;
+    this._dataUnit.subscribe(this.duObserver);
+  }
+  updateSelection() {
+    const selectionInfo = this._dataUnit.getSelectionInfo();
+    if (selectionInfo.isAllRecords()) {
+      this._controller.selectAll(true);
+    }
+    else {
+      this._controller.selectRows(selectionInfo.recordIds, true);
+    }
+  }
+  getRows(params) {
+    if (this.needReload(params)) {
+      this._lastLoadingParams = params;
+      this._dataUnit.loadData(this.quickFilter).then(() => this.updateSelection());
+    }
+    else {
+      this._lastLoadingParams = params;
+      if (!this._waitingForLoad) {
+        this.callbackGetRows(params);
+        this.updateSelection();
+      }
+    }
+  }
+  needReload(currentLoading) {
+    if (this._lastLoadingParams) {
+      return ObjectUtils.objectToString(currentLoading.request) != ObjectUtils.objectToString(this._lastLoadingParams.request);
+    }
+    return false;
+  }
+  callbackGetRows(params) {
+    if (params) {
+      params.success({ rowData: this._dataUnit.records });
+    }
+  }
+  destroy() {
+    this._dataUnit.unsubscribe(this.duObserver);
+  }
+  buildColumnDefs() {
+    const gridConfig = this._controller.getGridConfig() || [];
+    const columnDefs = [];
+    if (this._dataUnit.metadata) {
+      this._dataUnit.metadata.fields.sort((a, b) => {
+        const indexA = gridConfig.findIndex(value => value.name === a.name);
+        const indexB = gridConfig.findIndex(value => value.name === b.name);
+        return indexA - indexB;
+      });
+      this._dataUnit.metadata.fields.forEach(f => {
+        var _a;
+        if (f.visible !== false && f.name !== this.RECORD_ARCHIVE) {
+          const props = new Map();
+          const properties = this._dataUnit.getField(f.name).properties;
+          for (const value in properties) {
+            props.set(value, properties[value]);
+          }
+          columnDefs.push({ label: f.label, name: f.name, userInterface: f.userInterface, options: (_a = this._dataUnit.getField(f.name).properties) === null || _a === void 0 ? void 0 : _a.options, props });
+        }
+      });
+    }
+    return columnDefs;
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/GridEditionManager.js

@@ -0,0 +1,230 @@
+import { UserInterface } from "@sankhyalabs/core";
+import { KeyCode } from "ag-grid-community";
+import { RecordValidationProcessor } from "../../../../utils/validators/recordvalidator/RecordValidationProcessor";
+import EzCellEditor from "./editor/EzCellEditor";
+export default class GridEditionManager {
+  constructor(dataUnit, useEnterLikeTab, recordsValidator, editionIsDisabled) {
+    this._dataUnit = dataUnit;
+    this._recordValidationProcessor = new RecordValidationProcessor(this._dataUnit, {
+      getRequiredFields: () => this.getRequiredFields(),
+      markAsInvalid: () => { },
+      getMessageForField: () => null
+    }, recordsValidator);
+    this._useEnterLikeTab = useEnterLikeTab;
+    this._editionIsDisabled = editionIsDisabled;
+  }
+  configureGrid(options) {
+    this._gridOptions = options;
+    options.readOnlyEdit = true;
+    options.onCellEditRequest = evt => this.onCellEditRequest(evt);
+    options.onCellKeyDown = evt => {
+      if (evt.event && evt["column"]) {
+        this.onCellKeyDown(evt);
+      }
+    };
+    return options;
+  }
+  proceedAutoSave() {
+    if (!this._dataUnit.isDirty()) {
+      this.saveSuccess();
+      return;
+    }
+    if (!this._isGridEdition) {
+      return;
+    }
+    const currentRercord = this._dataUnit.getSelectedRecord();
+    if (currentRercord == undefined) {
+      return;
+    }
+    this._recordValidationProcessor
+      .validate()
+      .then(() => {
+      this._dataUnit.saveData()
+        .then(() => this.saveSuccess())
+        .catch(reason => this.saveFail(reason));
+    })
+      .catch(reason => this.saveFail(reason));
+  }
+  navigateByEnterKey(keyboardEvent) {
+    const backwards = keyboardEvent.shiftKey;
+    if (this._useEnterLikeTab) {
+      if (backwards) {
+        this._gridOptions.api.tabToPreviousCell(keyboardEvent);
+      }
+      else {
+        this._gridOptions.api.tabToNextCell(keyboardEvent);
+      }
+    }
+    else {
+      const editionCell = this._gridOptions.api.getEditingCells()[0];
+      if (editionCell) {
+        let { rowIndex } = editionCell;
+        this.nextEditionRow(rowIndex, editionCell.column, backwards);
+      }
+    }
+  }
+  getComponents() {
+    return { ezCellEditor: EzCellEditor };
+  }
+  verifyClickToEdition(api, cellClicked) {
+    if (this.isSecondClick(cellClicked)) {
+      api.startEditingCell({ rowIndex: cellClicked.rowIndex, colKey: cellClicked.column.getColId() });
+    }
+    this._lastCellClicked = cellClicked;
+  }
+  configureColumn(col) {
+    col.cellEditor = 'ezCellEditor';
+    col.editable = params => this.canEdit(params);
+    col.suppressKeyboardEvent = (params) => {
+      return params.event.key === KeyCode.ENTER;
+    };
+    return col;
+  }
+  getRequiredFields() {
+    return this._gridOptions.columnApi.getAllDisplayedColumns().filter(c => {
+      const fieldDefinition = this._dataUnit.getField(c.getColId());
+      return fieldDefinition && fieldDefinition.required;
+    }).map(c => c.getColId());
+  }
+  saveSuccess() {
+    this.focusOnCell(this._targetEditionCell);
+    this._lastCellEdited = undefined;
+    this._targetEditionCell = undefined;
+    this._isGridEdition = false;
+  }
+  saveFail(reason) {
+    this.focusOnCell(this._lastCellEdited);
+    this._isGridEdition = false;
+    if (reason) {
+      Promise.reject(reason);
+    }
+  }
+  focusOnCell(cell) {
+    if (cell == undefined) {
+      return;
+    }
+    const { rowIndex, column } = cell;
+    this._gridOptions.api.getDisplayedRowAtIndex(rowIndex).setSelected(true, true);
+    this._gridOptions.api.clearRangeSelection();
+    this._gridOptions.api.addCellRange({ rowStartIndex: rowIndex, rowEndIndex: rowIndex, columns: [column] });
+    this._gridOptions.api.startEditingCell({ colKey: column.getColId(), rowIndex });
+    this._gridOptions.api.setFocusedCell(rowIndex, column.getColId());
+    const cellEditor = this._gridOptions.api.getCellEditorInstances()[0];
+    if (cellEditor) {
+      cellEditor.focusIn();
+    }
+  }
+  onCellKeyDown(event) {
+    const keyboardEvent = event.event;
+    switch (keyboardEvent.key) {
+      case KeyCode.ENTER:
+        this.processEnterKey(keyboardEvent, event);
+        break;
+      case KeyCode.UP:
+        this.editPreviousRow(event.api);
+        break;
+      case KeyCode.DOWN:
+        this.editNextRow(event.api);
+        break;
+    }
+  }
+  processEnterKey(keyboardEvent, event) {
+    const editionCell = event.api.getEditingCells()[0];
+    if (!editionCell) {
+      event.api.startEditingCell({ colKey: event.column.getColId(), rowIndex: event.rowIndex });
+      return;
+    }
+    this.navigateByEnterKey(keyboardEvent);
+  }
+  nextEditionRow(rowIndex, column, backwards) {
+    if (backwards) {
+      rowIndex = rowIndex - 1;
+      if (rowIndex < 0) {
+        rowIndex = this._dataUnit.records.length - 1;
+      }
+    }
+    else {
+      rowIndex = rowIndex + 1;
+      if (rowIndex >= this._dataUnit.records.length) {
+        rowIndex = 0;
+      }
+    }
+    this._targetEditionCell = new TargetEdition(rowIndex, column, true);
+    this.finishEdition();
+  }
+  editPreviousRow(api) {
+    this.moveEditionVertically(api, -1);
+  }
+  editNextRow(api) {
+    this.moveEditionVertically(api, 1);
+  }
+  moveEditionVertically(api, offset) {
+    const editionCell = api.getEditingCells()[0];
+    if (!editionCell) {
+      return;
+    }
+    const rowIndex = editionCell.rowIndex + offset;
+    if (api.getDisplayedRowAtIndex(rowIndex)) {
+      this._targetEditionCell = new TargetEdition(rowIndex, editionCell.column, offset < 0);
+      this.finishEdition();
+    }
+  }
+  finishEdition() {
+    this._gridOptions.api.stopEditing();
+    setTimeout(() => {
+      //O Timeout foi inserido para permitir que o ciclo de finalização prossiga
+      //pois precisamos aguardar o fim da edição para executar o autosave.
+      this.proceedAutoSave();
+    }, 0);
+  }
+  canEdit(params) {
+    if (this._editionIsDisabled()) {
+      return false;
+    }
+    return this.isColEditable(params.colDef.field);
+  }
+  isColEditable(fieldName) {
+    const fieldDefinition = this._dataUnit.getField(fieldName);
+    if (fieldDefinition) {
+      return !fieldDefinition.readOnly;
+    }
+    return false;
+  }
+  isSecondClick(cellClicked) {
+    if (!this._lastCellClicked) {
+      return false;
+    }
+    if (this._lastCellClicked.column != cellClicked.column) {
+      return false;
+    }
+    if (this._lastCellClicked.rowIndex != cellClicked.rowIndex) {
+      return false;
+    }
+    return true;
+  }
+  onCellEditRequest(event) {
+    const fieldName = event.colDef.field;
+    const value = event.newValue;
+    if (event.oldValue != value) {
+      if (value instanceof Promise) {
+        const fieldDescriptor = this._dataUnit.getField(event.colDef.colId);
+        event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: (fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.userInterface) === UserInterface.SEARCH ? value : event.oldValue }));
+        value.then(resolved => event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: resolved })));
+      }
+      else {
+        event.node.setData(Object.assign(Object.assign({}, event.data), { [fieldName]: value }));
+      }
+      this._isGridEdition = true;
+      this._dataUnit.setFieldValue(fieldName, value, [event.data.__record__id__]);
+      this._lastCellEdited = { rowIndex: event.rowIndex, column: event.column, rowPinned: undefined };
+    }
+  }
+}
+class TargetEdition {
+  constructor(rowIndex, column, backwards) {
+    this.rowPinned = null;
+    this.rowIndex = rowIndex;
+    this.column = column;
+    this.backwards = backwards;
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/components/EzGridCustomHeader.js

@@ -0,0 +1,88 @@
+import { calcFilterColumnLeftPosition } from '../AgGridUtils';
+export class EzGridCustomHeader {
+  init(agParams) {
+    var _a;
+    this.params = agParams;
+    this.element = document.createElement('div');
+    this.element.classList.add('ag-cell-label-container');
+    this.element.setAttribute('title', (_a = this.params.tooltip) !== null && _a !== void 0 ? _a : '');
+    this.element.innerHTML = `
+          <div class='ez-flex ez-flex--justify-between'>
+            <i id='ez-grid-filter-icon' class='ez-icon-filter' style='color:#008561'></i>        
+            <i id='ez-grid-menu-icon' class='ez-icon-dots-vertical'></i>        
+          </div>
+          <div id='ez-header-container' class='ez-flex ez-flex--justify-between ag-header-cell-text'>
+            <span class='ag-header-cell-text'>${this.params.displayName}</span>
+            <i id='ez-grid-sort-icon-down' class='ez-icon-arrow_downward' style='display: none;margin-left: 4px;font-size: var(--text--medium, 14px);align-self: center;'></i>
+            <i id='ez-grid-sort-icon-up' class='ez-icon-arrow_downward' style='display: none; transform: rotate(180deg);margin-left: 4px;font-size: var(--text--medium, 14px);align-self: center;'></i>
+          </div>
+    `;
+    this.configMenuClick();
+    this.configSortClick();
+    this.configSortListener();
+    this.configFilterButton();
+  }
+  refresh(agParams) {
+    this.params = agParams;
+    this.configFilterButton();
+    this.configSortIcon();
+  }
+  configFilterButton() {
+    this.filterButton = this.element.querySelector('#ez-grid-filter-icon');
+    this.filterButton.style.display = this.params.hasFilter() ? 'flex' : 'none';
+    this.onFilterButtonClickListener = this.onClickFilter.bind(this);
+    this.filterButton.addEventListener('click', this.onFilterButtonClickListener);
+  }
+  onClickFilter() {
+    var _a;
+    const iconLeft = (_a = this.filterButton) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect().left;
+    this.params.showColumnFilter(`${calcFilterColumnLeftPosition(iconLeft)}px`, true);
+  }
+  configSortIcon() {
+    this.sortDownIcon.style.display = this.params.column.isSortDescending() ? 'flex' : 'none';
+    this.sortUpIcon.style.display = this.params.column.isSortAscending() ? 'flex' : 'none';
+  }
+  configSortListener() {
+    if (this.params.enableSorting) {
+      this.sortUpIcon = this.element.querySelector('#ez-grid-sort-icon-up');
+      this.sortDownIcon = this.element.querySelector('#ez-grid-sort-icon-down');
+      this.onSortChangedListener = this.configSortIcon.bind(this);
+      this.params.column.addEventListener('sortChanged', this.onSortChangedListener);
+      this.configSortIcon();
+    }
+  }
+  onSortClick(event) {
+    this.params.progressSort(event.shiftKey);
+  }
+  configSortClick() {
+    if (this.params.column.getColDef().sortable) {
+      this.headerContainer = this.element.querySelector('#ez-header-container');
+      this.onSortClickListener = this.onSortClick.bind(this);
+      this.headerContainer.addEventListener('click', this.onSortClickListener);
+    }
+  }
+  onMenuClick() {
+    this.params.showColumnMenu(this.menuButton);
+  }
+  configMenuClick() {
+    this.menuButton = this.element.querySelector('#ez-grid-menu-icon');
+    this.onMenuClickListener = this.onMenuClick.bind(this);
+    this.menuButton.addEventListener('click', this.onMenuClickListener);
+  }
+  getGui() {
+    return this.element;
+  }
+  destroy() {
+    if (this.onMenuClickListener) {
+      this.menuButton.removeEventListener('click', this.onMenuClickListener);
+    }
+    if (this.onSortClickListener) {
+      this.headerContainer.removeEventListener('click', this.onSortClickListener);
+    }
+    if (this.onFilterButtonClickListener) {
+      this.filterButton.removeEventListener('click', this.onFilterButtonClickListener);
+    }
+    this.params.column.removeEventListener('sortChanged', this.onSortChangedListener);
+    this.params.column.removeEventListener('applyFilterColumnOptions', this.onFilterAppliedListener);
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/components/cellRendererStatus.js

@@ -0,0 +1,43 @@
+export class CellRendererStatus {
+  constructor() {
+    this.DEFAULT_COLOR = 'transparent';
+    this._eGui = undefined;
+  }
+  init(params) {
+    this.renderStatus(params);
+  }
+  refresh(params) {
+    this.renderStatus(params);
+    return true;
+  }
+  destroy() {
+    this._eGui = undefined;
+  }
+  getGui() {
+    return this._eGui;
+  }
+  resolveColor(statusResolver, data) {
+    let color;
+    if (statusResolver instanceof Function) {
+      color = statusResolver(data);
+    }
+    else {
+      const statusKey = Object.keys(statusResolver)[0];
+      const statusValues = statusResolver[statusKey];
+      const value = data[statusKey];
+      color = statusValues != undefined && value != undefined && statusValues[value];
+    }
+    return color || this.DEFAULT_COLOR;
+  }
+  renderStatus(params) {
+    const { data, statusResolver } = params !== null && params !== void 0 ? params : {};
+    if (statusResolver == undefined) {
+      return;
+    }
+    const color = this.resolveColor(statusResolver, data);
+    this._eGui = document.createElement('div');
+    this._eGui.innerHTML = `
+            <span class="ez-grid__cell-status" style="background-color: ${color || ""};"></span>
+        `;
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/components/selectionHeader.js

@@ -0,0 +1,40 @@
+export default class SelectionHeader {
+  updateCheckbox() {
+    this.updatingValue = true;
+    try {
+      const value = this.headerCheckStatusGetter();
+      this.checkBox.indeterminate = value == undefined;
+      this.checkBox.value = value;
+    }
+    finally {
+      this.updatingValue = false;
+    }
+  }
+  init(params) {
+    params.context.selectionHeader = this;
+    const valueSetter = params.context.headerCheckStatusSetter;
+    this.headerCheckStatusGetter = params.context.headerCheckStatusGetter;
+    this.element = document.createElement('div');
+    this.element.classList.add("ag-header__selection-checkbox");
+    this.checkBox = document.createElement('ez-check');
+    this.checkBox.style.setProperty("--ez-check--focus--background-color", "transparent");
+    this.checkBox.style.setProperty("--ez-check--hover--background-color", "transparent");
+    this.element.append(this.checkBox);
+    this.updateCheckbox();
+    this.element.addEventListener('ezChange', (evt) => {
+      if (!this.updatingValue) {
+        valueSetter(evt.detail);
+      }
+    });
+  }
+  getGui() {
+    return this.element;
+  }
+  destroy() {
+    this.element.remove();
+    this.element = null;
+  }
+  refresh(_params) {
+    return false;
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/editor/EzCellEditor.js

@@ -0,0 +1,49 @@
+import { UserInterface } from "@sankhyalabs/core";
+import { buildEditorMetadata } from "./IEditorMetadata";
+import { buildTextAreaInput, buildTextInput } from "./templates/TextInput.tpl";
+import { buildDate, buildDateTime, buildTime } from "./templates/DateInput.tpl";
+import { buildDecimal, buildInteger } from "./templates/NumberInput.tpl";
+import { buildComboBox, buildSwitch } from "./templates/ComboBox.tpl";
+import { buildSearch } from "./templates/Search.tpl";
+const uiBuilders = new Map();
+uiBuilders.set(UserInterface.DATE, buildDate);
+uiBuilders.set(UserInterface.TIME, buildTime);
+uiBuilders.set(UserInterface.DATETIME, buildDateTime);
+uiBuilders.set(UserInterface.DECIMALNUMBER, buildDecimal);
+uiBuilders.set(UserInterface.INTEGERNUMBER, buildInteger);
+uiBuilders.set(UserInterface.SWITCH, buildSwitch);
+uiBuilders.set(UserInterface.CHECKBOX, buildSwitch);
+uiBuilders.set(UserInterface.OPTIONSELECTOR, buildComboBox);
+uiBuilders.set(UserInterface.LONGTEXT, buildTextAreaInput);
+uiBuilders.set(UserInterface.SEARCH, buildSearch);
+export default class EzCellEditor {
+  init(params) {
+    const fieldName = params.column.getColId();
+    const dataUnit = params.context.dataUnit;
+    const fieldMetadata = buildEditorMetadata(dataUnit.getField(fieldName), params.eGridCell, dataUnit, params.context.editionManager);
+    const builder = uiBuilders.get(fieldMetadata.userInterface) || buildTextInput;
+    this._gui = builder(fieldMetadata);
+    if (this._gui.valueSetter != undefined) {
+      this._gui.valueSetter(params.value);
+    }
+    else {
+      this._gui.value = params.value;
+    }
+  }
+  getGui() {
+    return this._gui;
+  }
+  afterGuiAttached() {
+    this.focusIn();
+  }
+  focusIn() {
+    this._gui.focus();
+    this._gui.setFocus({ selectText: true });
+  }
+  getValue() {
+    return this._gui.valueGetter != undefined ? this._gui.valueGetter() : this._gui.value;
+  }
+  isPopup() {
+    return this._gui.isPopUp;
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/editor/GridEditorUtils.js

@@ -0,0 +1,10 @@
+export function getViewPortHeight(cell) {
+  let currentElem = cell;
+  while (currentElem) {
+    const viewPort = currentElem.querySelector("[ref=eBodyViewport]");
+    if (viewPort) {
+      return viewPort.getBoundingClientRect().bottom;
+    }
+    currentElem = currentElem.parentElement;
+  }
+}

package/dist/collection/components/ez-grid/controller/ag-grid/editor/IEditorMetadata.js

@@ -0,0 +1,4 @@
+import { buildFieldMetadata } from '../../../../../utils/interfaces/AbstractFieldMetadata';
+export const buildEditorMetadata = (descriptor, eGridCell, dataUnit, editionManager) => {
+  return Object.assign(Object.assign({}, buildFieldMetadata(descriptor)), { eGridCell, dataUnit, editionManager });
+};

package/dist/collection/components/ez-grid/controller/ag-grid/editor/IUICellEditor.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/ez-grid/controller/ag-grid/editor/templates/ComboBox.tpl.js

@@ -0,0 +1,38 @@
+import { HTMLBuilder } from "@sankhyalabs/core";
+import { getViewPortHeight } from '../GridEditorUtils';
+const BOOLEAN_OPTIONS = new Map([[true, { value: "S", label: "Sim" }], [false, { value: "N", label: "Não" }]]);
+export const buildComboBox = ({ required, props, eGridCell }) => {
+  const prop = props === null || props === void 0 ? void 0 : props.options;
+  let options;
+  if (typeof prop === "string") {
+    const parsed = JSON.parse(prop);
+    options = Object.keys(parsed).map(key => { return { value: key, label: parsed[key] }; });
+  }
+  else {
+    options = prop;
+  }
+  const combo = HTMLBuilder.parseElement(`<ez-combo-box
+        class="grid_editor"
+        suppress-empty-option=${required}
+        mode="slim"
+    />`);
+  combo.options = options;
+  combo.listOptionsPosition = { verticalPosition: 29, bottomLimit: getViewPortHeight(eGridCell), hardPosition: true };
+  return combo;
+};
+export const buildSwitch = (fieldMetadata) => {
+  const combo = buildComboBox(Object.assign(Object.assign({}, fieldMetadata), { props: Object.assign(Object.assign({}, fieldMetadata.props), { options: Array.from(BOOLEAN_OPTIONS.values()) }) }));
+  combo.valueGetter = () => {
+    const value = combo.value;
+    if (value == undefined) {
+      return;
+    }
+    return value.value == "S";
+  };
+  combo.valueSetter = (value) => {
+    if (value != undefined) {
+      combo.value = BOOLEAN_OPTIONS.get(value);
+    }
+  };
+  return combo;
+};

package/dist/collection/components/ez-grid/controller/ag-grid/editor/templates/DateInput.tpl.js

@@ -0,0 +1,40 @@
+import { HTMLBuilder } from "@sankhyalabs/core";
+const LIMIT_TIME_VALUE = 2359;
+export const buildDate = () => {
+  const dateInput = HTMLBuilder.parseElement(`<ez-date-input
+            class="ez-grid grid_editor"
+            mode="slim"
+            data-is-fixed="true"
+        />`);
+  dateInput.valueGetter = () => dateInput.getValueAsync();
+  return dateInput;
+};
+export const buildTime = ({ readOnly }) => {
+  const timeInputElement = HTMLBuilder.parseElement(`<ez-time-input
+        class="ez-grid grid_editor"
+        enabled=${!readOnly}
+        mode="slim"
+    />`);
+  timeInputElement.valueGetter = () => {
+    const value = timeInputElement.value;
+    const isAllowedTime = parseInt(value) <= LIMIT_TIME_VALUE;
+    return isAllowedTime ? value : null;
+  };
+  timeInputElement.valueSetter = (value) => {
+    const isAllowedTime = parseInt(value) <= LIMIT_TIME_VALUE;
+    if (!isAllowedTime)
+      return timeInputElement.value = null;
+    return timeInputElement.value = value;
+  };
+  return timeInputElement;
+};
+export const buildDateTime = ({ readOnly }) => {
+  const dateTimeInput = HTMLBuilder.parseElement(`<ez-date-time-input
+        class="ez-grid grid_editor"
+        mode="slim"
+        enabled=${!readOnly}
+        data-is-fixed="true"
+    />`);
+  dateTimeInput.valueGetter = () => dateTimeInput.getValueAsync();
+  return dateTimeInput;
+};

package/dist/collection/components/ez-grid/controller/ag-grid/editor/templates/NumberInput.tpl.js

@@ -0,0 +1,20 @@
+import { HTMLBuilder } from "@sankhyalabs/core";
+export const buildDecimal = ({ readOnly, props }) => {
+  const precision = Number((props === null || props === void 0 ? void 0 : props.precision) || 2);
+  const prettyPrecision = Number((props === null || props === void 0 ? void 0 : props.prettyPrecision) || precision);
+  return buildNumeric(readOnly, precision, prettyPrecision);
+};
+export const buildInteger = ({ readOnly }) => {
+  return buildNumeric(readOnly, 0, 0);
+};
+function buildNumeric(readOnly, precision, prettyPrecision) {
+  const input = HTMLBuilder.parseElement(`<ez-number-input
+        class="ez-grid grid_editor"
+        enabled=${!readOnly}
+        precision=${precision}
+        pretty-precision=${prettyPrecision}
+        mode="slim"
+    />`);
+  input.valueGetter = () => input.getValueAsync();
+  return input;
+}