dtable-utils 0.0.2 → 0.0.3-beta.1

package/es/sort/sort-column/array.js

@@ -0,0 +1,63 @@
+import { getCollaboratorsNames } from '../../cell-value-get/collaborator.js';
+import { getFormulaDisplayString } from '../../cell-value-get/cell-value.js';
+import { sortCheckbox } from './checkbox.js';
+import { sortCollaborator } from './collaborator.js';
+import { sortDate } from './date.js';
+import { sortNumber } from './number.js';
+import { sortText } from './text.js';
+import { CellType } from '../../constants/cell-type.js';
+import { NUMERIC_COLUMNS_TYPES, DATE_COLUMN_OPTIONS } from '../../constants/column.js';
+import { FORMULA_RESULT_TYPE } from '../../constants/formula.js';
+
+var sortByArrayType = function sortByArrayType(currCellVal, nextCellVal, sortType, _ref) {
+  var columnData = _ref.columnData,
+    value = _ref.value;
+  var _ref2 = columnData || {},
+    array_type = _ref2.array_type;
+  if (NUMERIC_COLUMNS_TYPES.includes(array_type)) {
+    var currNumber = currCellVal;
+    var nextNumber = nextCellVal;
+    if (Array.isArray(currCellVal)) {
+      currNumber = currCellVal[0];
+    }
+    if (Array.isArray(nextCellVal)) {
+      nextNumber = nextCellVal[0];
+    }
+    currNumber = currNumber || currNumber === 0 ? currNumber : null;
+    nextNumber = nextNumber || nextNumber === 0 ? nextNumber : null;
+    return sortNumber(currNumber, nextNumber, sortType);
+  }
+  if (DATE_COLUMN_OPTIONS.includes(array_type)) {
+    var currDate = Array.isArray(currCellVal) ? currCellVal[0] : currCellVal;
+    var nextDate = Array.isArray(nextCellVal) ? nextCellVal[0] : nextCellVal;
+    return sortDate(currDate, nextDate, sortType);
+  }
+  if (array_type === CellType.CHECKBOX || array_type === FORMULA_RESULT_TYPE.BOOL) {
+    var currBoolean = currCellVal;
+    var nextBoolean = nextCellVal;
+    if (Array.isArray(currCellVal)) {
+      currBoolean = currCellVal[0];
+    }
+    if (Array.isArray(nextCellVal)) {
+      nextBoolean = nextCellVal[0];
+    }
+    currBoolean = currBoolean || false;
+    nextBoolean = nextBoolean || false;
+    return sortCheckbox(currBoolean, nextBoolean, sortType);
+  }
+  if (array_type === CellType.COLLABORATOR) {
+    var collaborators = value.collaborators;
+    var currCollaborators = Array.isArray(currCellVal) ? currCellVal : [currCellVal];
+    var nextCollaborators = Array.isArray(nextCellVal) ? nextCellVal : [nextCellVal];
+    if (collaborators) {
+      currCollaborators = getCollaboratorsNames(currCollaborators, collaborators);
+      nextCollaborators = getCollaboratorsNames(nextCollaborators, collaborators);
+    }
+    return sortCollaborator(currCollaborators, nextCollaborators, sortType);
+  }
+  var currText = getFormulaDisplayString(currCellVal, columnData);
+  var nextText = getFormulaDisplayString(nextCellVal, columnData);
+  return sortText(currText, nextText, sortType);
+};
+
+export { sortByArrayType };

package/es/sort/sort-column/checkbox.js

@@ -0,0 +1,15 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+var sortCheckbox = function sortCheckbox(currCellVal, nextCellVal, sortType) {
+  var currCellValPart = currCellVal ? 1 : -1;
+  var nextCellValPart = nextCellVal ? 1 : -1;
+  if (currCellValPart > nextCellValPart) {
+    return sortType === SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currCellValPart < nextCellValPart) {
+    return sortType === SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+export { sortCheckbox };

package/es/sort/sort-column/collaborator.js

@@ -0,0 +1,9 @@
+import { sortText } from './text.js';
+
+var sortCollaborator = function sortCollaborator(currCellVal, nextCellVal, sortType) {
+  var currCellValString = Array.isArray(currCellVal) && currCellVal.length ? currCellVal.join('') : null;
+  var nextCellValString = Array.isArray(currCellVal) && currCellVal.length ? nextCellVal.join('') : null;
+  return sortText(currCellValString, nextCellValString, sortType);
+};
+
+export { sortCollaborator };

package/es/sort/sort-column/date.js

@@ -0,0 +1,25 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+/**
+ * compare date
+ * @param {string} currDate date string, e.g. '2023-07-31'
+ * @param {string} nextDate date string
+ * @param {string} sortType e.g. 'up' | 'down'
+ * @returns number, e.g. 1 | -1 | 0
+ */
+var sortDate = function sortDate(currDate, nextDate, sortType) {
+  var emptyCurrDate = !currDate;
+  var emptyNextDate = !nextDate;
+  if (emptyCurrDate && emptyNextDate) return 0;
+  if (emptyCurrDate) return 1;
+  if (emptyNextDate) return -1;
+  if (currDate > nextDate) {
+    return sortType === SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currDate < nextDate) {
+    return sortType === SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+export { sortDate };

package/es/sort/sort-column/formula.js

@@ -0,0 +1,40 @@
+import { getFormulaDisplayString } from '../../cell-value-get/cell-value.js';
+import { sortByArrayType } from './array.js';
+import { sortCheckbox } from './checkbox.js';
+import { sortDate } from './date.js';
+import { sortNumber } from './number.js';
+import { sortText } from './text.js';
+import { DATE_COLUMN_OPTIONS } from '../../constants/column.js';
+import { FORMULA_RESULT_TYPE } from '../../constants/formula.js';
+import { NUMBER_SORTER_COLUMN_TYPES } from '../../constants/sort.js';
+
+var sortFormula = function sortFormula(currCellVal, nextCellVal, sortType, _ref) {
+  var columnData = _ref.columnData,
+    value = _ref.value;
+  var _ref2 = columnData || {},
+    result_type = _ref2.result_type;
+  if (NUMBER_SORTER_COLUMN_TYPES.includes(result_type)) {
+    var currNumber = currCellVal || currCellVal === 0 ? currCellVal - 0 : null;
+    var nextNumber = nextCellVal || nextCellVal === 0 ? nextCellVal - 0 : null;
+    return sortNumber(currNumber, nextNumber, sortType);
+  }
+  if (DATE_COLUMN_OPTIONS.includes(result_type)) {
+    return sortDate(currCellVal, nextCellVal, sortType);
+  }
+  if (result_type === FORMULA_RESULT_TYPE.BOOL) {
+    var currBoolean = currCellVal || false;
+    var nextBoolean = nextCellVal || false;
+    return sortCheckbox(currBoolean, nextBoolean);
+  }
+  if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+    return sortByArrayType(currCellVal, nextCellVal, sortType, {
+      columnData: columnData,
+      value: value
+    });
+  }
+  var currText = getFormulaDisplayString(currCellVal, columnData);
+  var nextText = getFormulaDisplayString(nextCellVal, columnData);
+  return sortText(currText, nextText, sortType);
+};
+
+export { sortFormula };

package/es/sort/sort-column/link.js

@@ -0,0 +1,23 @@
+import { sortByArrayType } from './array.js';
+
+var sortLink = function sortLink(currCellVal, nextCellVal, sortType, _ref) {
+  var columnData = _ref.columnData,
+    value = _ref.value;
+  var emptyCurrCellVal = !Array.isArray(currCellVal) || currCellVal.length === 0;
+  var emptyNextCellVal = !Array.isArray(nextCellVal) || nextCellVal.length === 0;
+  if (emptyCurrCellVal && emptyNextCellVal) return 0;
+  if (emptyCurrCellVal) return 1;
+  if (emptyNextCellVal) return -1;
+  var currDisplayValues = currCellVal.map(function (linked) {
+    return linked.display_value;
+  });
+  var nextDisplayValues = nextCellVal.map(function (linked) {
+    return linked.display_value;
+  });
+  return sortByArrayType(currDisplayValues, nextDisplayValues, sortType, {
+    columnData: columnData,
+    value: value
+  });
+};
+
+export { sortLink };

package/es/sort/sort-column/multiple-select.js

@@ -0,0 +1,45 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+var getMultipleIndexesOrderbyOptions = function getMultipleIndexesOrderbyOptions(cellValue, option_id_index_map) {
+  var indexArr = [];
+  cellValue.forEach(function (optionId) {
+    var index = option_id_index_map[optionId];
+    if (index > -1) {
+      indexArr.push(index);
+    }
+  });
+  return indexArr.sort();
+};
+var sortMultipleSelect = function sortMultipleSelect(currCellVal, nextCellVal, _ref) {
+  var sort_type = _ref.sort_type,
+    option_id_index_map = _ref.option_id_index_map;
+  var emptyCurrCellVal = !currCellVal || currCellVal.length === 0;
+  var emptyNextCellVal = !nextCellVal || nextCellVal.length === 0;
+  if (emptyCurrCellVal && emptyNextCellVal) return 0;
+  if (emptyCurrCellVal) return 1;
+  if (emptyNextCellVal) return -1;
+  var currCellValIndexes = getMultipleIndexesOrderbyOptions(currCellVal, option_id_index_map);
+  var nextCellValIndexes = getMultipleIndexesOrderbyOptions(nextCellVal, option_id_index_map);
+  var currLen = currCellValIndexes.length;
+  var nextLen = nextCellValIndexes.length;
+
+  // current multiple select equal to next multiple select.
+  if (currLen === nextLen && (currLen === 0 || currCellValIndexes.join('') === nextCellValIndexes.join(''))) {
+    return 0;
+  }
+  var len = Math.min(currLen, nextLen);
+  for (var i = 0; i < len; i++) {
+    if (currCellValIndexes[i] > nextCellValIndexes[i]) {
+      return sort_type === SORT_TYPE.UP ? 1 : -1;
+    }
+    if (currCellValIndexes[i] < nextCellValIndexes[i]) {
+      return sort_type === SORT_TYPE.UP ? -1 : 1;
+    }
+  }
+  if (currLen > nextLen) {
+    return sort_type === SORT_TYPE.UP ? 1 : -1;
+  }
+  return sort_type === SORT_TYPE.UP ? -1 : 1;
+};
+
+export { getMultipleIndexesOrderbyOptions, sortMultipleSelect };

package/es/sort/sort-column/number.js

@@ -0,0 +1,18 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+var sortNumber = function sortNumber(currNum, nextNum, sortType) {
+  var emptyCurrNum = !currNum && currNum !== 0;
+  var emptyNextNum = !nextNum && nextNum !== 0;
+  if (emptyCurrNum && emptyNextNum) return 0;
+  if (emptyCurrNum) return 1;
+  if (emptyNextNum) return -1;
+  if (currNum > nextNum) {
+    return sortType === SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currNum < nextNum) {
+    return sortType === SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+export { sortNumber };

package/es/sort/sort-column/single-select.js

@@ -0,0 +1,22 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+var sortSingleSelect = function sortSingleSelect(currCellVal, nextCellVal, _ref) {
+  var sort_type = _ref.sort_type,
+    option_id_index_map = _ref.option_id_index_map;
+  var currentOptionIdIndex = option_id_index_map[currCellVal];
+  var nextOptionIdIndex = option_id_index_map[nextCellVal];
+  var emptyCurrCellVal = !currentOptionIdIndex && currentOptionIdIndex !== 0;
+  var emptyNextCellVal = !nextOptionIdIndex && nextOptionIdIndex !== 0;
+  if (emptyCurrCellVal && emptyNextCellVal) return 0;
+  if (emptyCurrCellVal) return 1;
+  if (emptyNextCellVal) return -1;
+  if (currentOptionIdIndex > nextOptionIdIndex) {
+    return sort_type === SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currentOptionIdIndex < nextOptionIdIndex) {
+    return sort_type === SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+export { sortSingleSelect };

package/es/sort/sort-column/text.js

@@ -0,0 +1,47 @@
+import { REG_STRING_NUMBER_PARTS, REG_NUMBER_DIGIT } from '../../constants/reg.js';
+import { SORT_TYPE } from '../../constants/sort.js';
+
+var compareString = function compareString(leftString, rightString) {
+  if (!leftString && !rightString) return 0;
+  if (!leftString) return -1;
+  if (!rightString) return 1;
+  if (typeof leftString !== 'string' || typeof rightString !== 'string') return 0;
+  var leftStringParts = leftString.match(REG_STRING_NUMBER_PARTS);
+  var rightStringParts = rightString.match(REG_STRING_NUMBER_PARTS);
+  var len = Math.min(leftStringParts.length, rightStringParts.length);
+  var isDigitPart;
+  var leftStringPart;
+  var rightStringPart;
+
+  // Loop through each substring part to canCompare the overall strings.
+  for (var i = 0; i < len; i++) {
+    leftStringPart = leftStringParts[i];
+    rightStringPart = rightStringParts[i];
+    isDigitPart = REG_NUMBER_DIGIT.test(leftStringPart) && REG_NUMBER_DIGIT.test(rightStringPart);
+    if (isDigitPart) {
+      leftStringPart = parseInt(leftStringPart, 10);
+      rightStringPart = parseInt(rightStringPart, 10);
+      if (leftStringPart > rightStringPart) {
+        return 1;
+      }
+      if (leftStringPart < rightStringPart) {
+        return -1;
+      }
+    }
+    if (leftStringPart !== rightStringPart) {
+      return leftString.localeCompare(rightString);
+    }
+  }
+  return leftString.localeCompare(rightString);
+};
+var sortText = function sortText(currCellVal, nextCellVal, sortType) {
+  var emptyCurrCellVal = !currCellVal;
+  var emptyNextCellVal = !nextCellVal;
+  if (emptyCurrCellVal && emptyNextCellVal) return 0;
+  if (emptyCurrCellVal) return 1;
+  if (emptyNextCellVal) return -1;
+  if (nextCellVal === currCellVal) return 0;
+  return sortType === SORT_TYPE.UP ? compareString(currCellVal, nextCellVal) : -1 * compareString(currCellVal, nextCellVal);
+};
+
+export { compareString, sortText };

package/es/sort/sort-row.js

@@ -0,0 +1,126 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getValidSorts } from './core.js';
+import { sortCheckbox } from './sort-column/checkbox.js';
+import { sortCollaborator } from './sort-column/collaborator.js';
+import { sortDate } from './sort-column/date.js';
+import { getCollaboratorsNames } from '../cell-value-get/collaborator.js';
+import '../cell-value-get/cell-value.js';
+import { sortNumber } from './sort-column/number.js';
+import { sortText } from './sort-column/text.js';
+import { CellType } from '../constants/cell-type.js';
+import { DATE_COLUMN_OPTIONS } from '../constants/column.js';
+import { FORMULA_COLUMN_TYPES_MAP } from '../constants/formula.js';
+import { sortFormula } from './sort-column/formula.js';
+import { sortLink } from './sort-column/link.js';
+import { sortMultipleSelect } from './sort-column/multiple-select.js';
+import { sortSingleSelect } from './sort-column/single-select.js';
+import { getColumnOptions } from '../column/option.js';
+import { NUMBER_SORTER_COLUMN_TYPES } from '../constants/sort.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var deleteInvalidSort = function deleteInvalidSort(sorts, columns) {
+  var validSorts = getValidSorts(sorts, columns);
+  var cleanSorts = [];
+  validSorts.forEach(function (sort) {
+    var column_key = sort.column_key;
+    var sortColumn = columns.find(function (column) {
+      return column.key === column_key;
+    });
+    var columnType = sortColumn.type;
+    var newSort = _objectSpread(_objectSpread({}, sort), {}, {
+      column: sortColumn
+    });
+    switch (columnType) {
+      case CellType.SINGLE_SELECT:
+      case CellType.MULTIPLE_SELECT:
+        {
+          var options = getColumnOptions(sortColumn);
+          var option_id_index_map = {};
+          options.forEach(function (option, index) {
+            option_id_index_map[option.id] = index;
+          });
+          newSort.option_id_index_map = option_id_index_map;
+          break;
+        }
+    }
+    cleanSorts.push(newSort);
+  });
+  return cleanSorts;
+};
+var sortRowsWithMultiSorts = function sortRowsWithMultiSorts(sortRows, sorts, _ref) {
+  var _ref$formulaRows = _ref.formulaRows,
+    formulaRows = _ref$formulaRows === void 0 ? {} : _ref$formulaRows,
+    value = _ref.value;
+  sortRows.sort(function (currentRow, nextRow) {
+    var initValue = 0;
+    sorts.forEach(function (sort) {
+      var column_key = sort.column_key,
+        sort_type = sort.sort_type,
+        column = sort.column;
+      var columnType = column.type,
+        columnData = column.data;
+      var currCellVal = currentRow[column_key];
+      var nextCellVal = nextRow[column_key];
+      if (DATE_COLUMN_OPTIONS.includes(columnType)) {
+        initValue = initValue || sortDate(currCellVal, nextCellVal, sort_type);
+      } else if (columnType === CellType.SINGLE_SELECT) {
+        initValue = initValue || sortSingleSelect(currCellVal, nextCellVal, sort);
+      } else if (NUMBER_SORTER_COLUMN_TYPES.includes(columnType)) {
+        initValue = initValue || sortNumber(currCellVal, nextCellVal, sort_type);
+      } else if (FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var currentFormulaRow = formulaRows[currentRow._id] || {};
+        var nextFormulaRow = formulaRows[nextRow._id] || {};
+        currCellVal = currentFormulaRow[column_key];
+        nextCellVal = nextFormulaRow[column_key];
+        initValue = initValue || sortFormula(currCellVal, nextCellVal, sort_type, {
+          columnData: columnData,
+          value: value
+        });
+      } else if (columnType === CellType.COLLABORATOR) {
+        var collaborators = value.collaborators;
+        var currValidCollaborators = currCellVal;
+        var nextValidCollaborators = nextCellVal;
+        if (collaborators) {
+          currValidCollaborators = getCollaboratorsNames(currCellVal, collaborators);
+          nextValidCollaborators = getCollaboratorsNames(nextCellVal, collaborators);
+        }
+        initValue = initValue || sortCollaborator(currValidCollaborators, nextValidCollaborators, sort_type);
+      } else if (columnType === CellType.CHECKBOX) {
+        initValue = initValue || sortCheckbox(currCellVal, nextCellVal, sort_type);
+      } else if (columnType === CellType.MULTIPLE_SELECT) {
+        initValue = initValue || sortMultipleSelect(currCellVal, nextCellVal, sort);
+      } else if (columnType === CellType.LINK) {
+        var _currentFormulaRow = formulaRows[currentRow._id] || {};
+        var _nextFormulaRow = formulaRows[nextRow._id] || {};
+        currCellVal = _currentFormulaRow[column_key];
+        nextCellVal = _nextFormulaRow[column_key];
+        initValue = initValue || sortLink(currCellVal, nextCellVal, sort_type, {
+          columnData: columnData,
+          value: value
+        });
+      } else {
+        initValue = initValue || sortText(currCellVal, nextCellVal, sort_type);
+      }
+    });
+    return initValue;
+  });
+};
+var sortTableRows = function sortTableRows(sorts, rows, columns) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    formulaRows = _ref2.formulaRows,
+    value = _ref2.value;
+  if (!Array.isArray(rows)) return [];
+  var sortRows = rows.slice(0);
+  var validSorts = deleteInvalidSort(sorts, columns);
+  var normalizedFormulaRows = formulaRows || {};
+  sortRowsWithMultiSorts(sortRows, validSorts, {
+    formulaRows: normalizedFormulaRows,
+    value: value
+  });
+  return sortRows.map(function (row) {
+    return row._id;
+  });
+};
+
+export { deleteInvalidSort, sortRowsWithMultiSorts, sortTableRows };

package/es/table/column.js

@@ -0,0 +1,27 @@
+/**
+ * get column by key from table
+ * @param {object} table
+ * @param {string} columnKey
+ * @returns column, object
+ */
+var getTableColumnByKey = function getTableColumnByKey(table, columnKey) {
+  if (!table || !Array.isArray(table.columns) || !columnKey) return null;
+  return table.columns.find(function (column) {
+    return column.key === columnKey;
+  });
+};
+
+/**
+ * get column by name from table
+ * @param {object} table
+ * @param {string} columnName
+ * @returns column, object
+ */
+var getTableColumnByName = function getTableColumnByName(table, columnName) {
+  if (!table || !Array.isArray(table.columns) || !columnName) return null;
+  return table.columns.find(function (column) {
+    return column.name === columnName;
+  });
+};
+
+export { getTableColumnByKey, getTableColumnByName };

package/es/table/core.js

@@ -0,0 +1,14 @@
+/**
+ * get table by id
+ * @param {array} tables
+ * @param {string} tableId
+ * @returns object
+ */
+var getTableById = function getTableById(tables, tableId) {
+  if (!Array.isArray(tables) || !tableId) return null;
+  return tables.find(function (table) {
+    return table._id === tableId;
+  });
+};
+
+export { getTableById };

package/es/table/index.js

@@ -0,0 +1,14 @@
+/**
+ * get table by id
+ * @param {array} tables
+ * @param {string} tableId
+ * @returns table, object
+ */
+var getTableById = function getTableById(tables, tableId) {
+  if (!Array.isArray(tables) || !tableId) return null;
+  return tables.find(function (table) {
+    return table._id === tableId;
+  });
+};
+
+export { getTableById };

package/es/table/row.js

@@ -0,0 +1,25 @@
+/**
+ * get row by id from table
+ * @param {object} table
+ * @param {string} rowId the id of row
+ * @returns object
+ */
+var getRowById = function getRowById(table, rowId) {
+  if (!table || !table.id_row_map || !rowId) return null;
+  return table.id_row_map[rowId];
+};
+
+/**
+ * get rows by ids from table
+ * @param {object} table { id_row_map, ... }
+ * @param {array} rowsIds [ row._id, ... ]
+ * @returns array, rows: [ row, ... ]
+ */
+var getRowsByIds = function getRowsByIds(table, rowsIds) {
+  if (!table || !table.id_row_map || !Array.isArray(rowsIds)) return [];
+  return rowsIds.map(function (rowId) {
+    return table.id_row_map[rowId];
+  }).filter(Boolean);
+};
+
+export { getRowById, getRowsByIds };

package/es/validate/filter.js

@@ -5,7 +5,7 @@ import { CellType } from '../constants/cell-type.js';
 import { COLLABORATOR_COLUMN_TYPES } from '../constants/column.js';
 import { FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from '../constants/formula.js';
 import { FILTER_ERR_MSG } from '../constants/filter/index.js';
-import { getColumnOptions } from '../column/common.js';
+import { getColumnOptions } from '../column/option.js';
 import { isDateColumn } from '../column/date.js';
 import { FILTER_PREDICATE_TYPE } from '../constants/filter/filter-predicate.js';
 import { FILTER_TERM_MODIFIER_TYPE } from '../constants/filter/filter-modifier.js';

package/es/validate/geolocation.js

@@ -0,0 +1,5 @@
+var isValidPosition = function isValidPosition(lng, lat) {
+  return (lng || lng === 0) && (lat || lat === 0);
+};
+
+export { isValidPosition };