dtable-utils 0.0.3 → 0.0.4-beta.1

package/es/row/core.js

@@ -0,0 +1,180 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+import { getFormulaDisplayString } from '../cell-value-get/cell-value.js';
+import 'dayjs';
+import '../constants/column.js';
+import '../constants/formula.js';
+import { getColumnOptionNameById } from '../cell-value-get/option.js';
+import '../constants/group.js';
+import { getLinkCellValue } from '../link/core.js';
+import { isEmpty } from '../common.js';
+import { CellType } from '../constants/cell-type.js';
+import { CONVERT_ROW_COLUMNS_LIMIT } from '../constants/limit.js';
+
+/**
+ * Check is table rows
+ * @param {array} rows e.g. table rows: [{ _id, xxx }, ...] | view rows: [ row._id, ... ]
+ * @returns bool
+ */
+var isTableRows = function isTableRows(rows) {
+  return Array.isArray(rows) && _typeof(rows[0]) === 'object';
+};
+
+/**
+ * Convert row
+ * e.g. { '0000': 'a' } to { 'Name': 'a' }
+ * @param {object} row
+ * @param {object} value e.g. { links, ... }
+ * @param {object} table e.g. { _id, columns, ... }
+ * @param {object} view e.g. { hidden_columns, ... }
+ * @param {object} formulaResults computed value of formula, link-formula, link etc.
+ * @param {bool} convertLinkID use to convert link: get linked from formulaResults if true, otherwise get linked from links
+ * @param {func} debug use to debug if supplied
+ * @returns converted row, object
+ */
+var convertRow = function convertRow(row, value, table, view, formulaResults, convertLinkID) {
+  var _ref = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {},
+    debug = _ref.debug;
+  var result = {};
+  // eslint-disable-next-line
+  if (row.hasOwnProperty('_id')) {
+    result._id = row._id;
+  }
+  // eslint-disable-next-line
+  if (row.hasOwnProperty('_mtime')) {
+    result._mtime = row._mtime;
+  }
+  // eslint-disable-next-line
+  if (row.hasOwnProperty('_ctime')) {
+    result._ctime = row._ctime;
+  }
+  var columns = table.columns;
+  if (columns.length > CONVERT_ROW_COLUMNS_LIMIT) {
+    columns = columns.slice(0, CONVERT_ROW_COLUMNS_LIMIT);
+  }
+  var hiddenColumns = view ? view.hidden_columns : null;
+  for (var i = 0; i < columns.length; i++) {
+    var column = columns[i];
+    var key = column.key,
+      type = column.type,
+      columnName = column.name;
+    if (hiddenColumns && hiddenColumns.includes(key)) {
+      continue;
+    }
+    var cellValue = row[key];
+    switch (type) {
+      case CellType.SINGLE_SELECT:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No options found');
+            }
+            break;
+          }
+          result[columnName] = getColumnOptionNameById(column, cellValue);
+          break;
+        }
+      case CellType.MULTIPLE_SELECT:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No options found');
+            }
+            break;
+          }
+          if (!Array.isArray(cellValue)) {
+            result[columnName] = '';
+            break;
+          }
+          var optionNames = [];
+          for (var optionIndex = 0; optionIndex < cellValue.length; optionIndex++) {
+            var optionName = getColumnOptionNameById(column, cellValue[optionIndex]);
+            if (optionName) {
+              optionNames.push(optionName);
+            }
+          }
+          result[columnName] = optionNames;
+          break;
+        }
+      case CellType.LONG_TEXT:
+        {
+          result[columnName] = cellValue ? cellValue.text : '';
+          break;
+        }
+      case CellType.LINK:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No links found');
+            }
+            break;
+          }
+          // convertLinkID to display value
+          if (convertLinkID) {
+            // get values form formulaResults
+            var formulaRow = formulaResults && formulaResults[row._id];
+            var cellResult = formulaRow && formulaRow[key];
+            if (!Array.isArray(cellResult) || cellResult.length === 0) {
+              result[columnName] = null;
+              break;
+            }
+            // linked with common column:
+            // cellResult
+            // [
+            //   {row_id: '', displayValue: ''},
+            //   {row_id: '', displayValue: ''},
+            // ]
+
+            // linked with formula column and formula result is array
+            // cellResult
+            // [
+            //   {row_id: '', display_value: []},
+            //   {row_id: '', display_value: []},
+            // ]
+            result[columnName] = cellResult;
+            break;
+          }
+          var tableID = table._id;
+          var _column$data = column.data,
+            link_id = _column$data.link_id,
+            table_id = _column$data.table_id,
+            other_table_id = _column$data.other_table_id;
+          var otherTableID = tableID === table_id ? other_table_id : table_id;
+          var links = value.links;
+          result[columnName] = getLinkCellValue(links, link_id, tableID, otherTableID, row._id);
+          break;
+        }
+      case CellType.FORMULA:
+      case CellType.LINK_FORMULA:
+        {
+          if (!column.data || !formulaResults) {
+            if (debug) {
+              debug('No formula found');
+            }
+            break;
+          }
+          var _formulaRow = formulaResults[row._id] || {};
+          result[columnName] = getFormulaDisplayString(_formulaRow[key], column.data);
+          break;
+        }
+      default:
+        {
+          // text/email/url/auto-number/
+          // check/
+          // rate/duration/
+          // file/image/button/
+          // translate in dtable-events
+          // number/
+          // date/ctime/mtime/
+          // geolocation/
+          // collaborator/creator/last-modifier/
+          result[columnName] = cellValue;
+        }
+    }
+    if (isEmpty(result[columnName])) {
+      delete result[columnName];
+    }
+  }
+  return result;
+};
+
+export { convertRow, isTableRows };

package/es/sort/core.js

@@ -0,0 +1,91 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getColumnOptions } from '../column/option.js';
+import { CellType } from '../constants/cell-type.js';
+import { SORT_COLUMN_OPTIONS } 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; }
+
+/**
+ * Check is valid sort
+ * @param {object} sort e.g. { column_key, sort_type, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isValidSort = function isValidSort(sort, columns) {
+  var sortByColumn = sort && columns.find(function (column) {
+    return column.key === sort.column_key;
+  });
+  if (!sortByColumn) return false;
+  return SORT_COLUMN_OPTIONS.includes(sortByColumn.type);
+};
+
+/**
+ * Get valid sorts
+ *   1. sort column is exist or not
+ *   2. valid sort type
+ * @param {array} sorts e.g. [{ column_key, sort_type, ... }, ...]
+ * @param {array} columns
+ * @returns valid sorts, array
+ */
+var getValidSorts = function getValidSorts(sorts, columns) {
+  if (!Array.isArray(sorts) || !Array.isArray(columns)) return [];
+  return sorts.filter(function (sort) {
+    return isValidSort(sort, columns);
+  });
+};
+
+/**
+ * Get sorted option index of the "optionIds"
+ * @param {array} optionIds
+ * @param {object} option_id_index_map e.g. {[option.id]: 0, ...}
+ * @returns sorted options index, array
+ */
+var getMultipleIndexesOrderbyOptions = function getMultipleIndexesOrderbyOptions(optionIds, option_id_index_map) {
+  var indexArr = [];
+  optionIds.forEach(function (optionId) {
+    var index = option_id_index_map[optionId];
+    if (index > -1) {
+      indexArr.push(index);
+    }
+  });
+  return indexArr.sort();
+};
+
+/**
+ * Get valid and formatted sorts
+ * @param {array} sorts e.g. [{ column_key, sort_type, ... }, ...]
+ * @param {array} columns
+ * @returns valid and formatted sorts, array
+ */
+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;
+};
+
+export { deleteInvalidSort, getMultipleIndexesOrderbyOptions, getValidSorts, isValidSort };

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

@@ -0,0 +1,72 @@
+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';
+
+/**
+ * Sort by array type
+ * @param {array} leftArray
+ * @param {array} rightArray
+ * @param {string} sortType e.g. 'up' | 'down
+ * @param {object} columnData e.g. { result_type, array_type, array_data, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns number
+ */
+var sortByArrayType = function sortByArrayType(leftArray, rightArray, 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 leftNumber = leftArray;
+    var rightNumber = rightArray;
+    if (Array.isArray(leftArray)) {
+      leftNumber = leftArray[0];
+    }
+    if (Array.isArray(rightArray)) {
+      rightNumber = rightArray[0];
+    }
+    leftNumber = leftNumber || leftNumber === 0 ? leftNumber : null;
+    rightNumber = rightNumber || rightNumber === 0 ? rightNumber : null;
+    return sortNumber(leftNumber, rightNumber, sortType);
+  }
+  if (DATE_COLUMN_OPTIONS.includes(array_type)) {
+    var leftDate = Array.isArray(leftArray) ? leftArray[0] : leftArray;
+    var rightDate = Array.isArray(rightArray) ? rightArray[0] : rightArray;
+    return sortDate(leftDate, rightDate, sortType);
+  }
+  if (array_type === CellType.CHECKBOX || array_type === FORMULA_RESULT_TYPE.BOOL) {
+    var leftBool = leftArray;
+    var rightBool = rightArray;
+    if (Array.isArray(leftArray)) {
+      leftBool = leftArray[0];
+    }
+    if (Array.isArray(rightArray)) {
+      rightBool = rightArray[0];
+    }
+    leftBool = leftBool || false;
+    rightBool = rightBool || false;
+    return sortCheckbox(leftBool, rightBool, sortType);
+  }
+  if (array_type === CellType.COLLABORATOR) {
+    var collaborators = value.collaborators;
+    var leftCollaborators = Array.isArray(leftArray) ? leftArray : [leftArray];
+    var rightCollaborators = Array.isArray(rightArray) ? rightArray : [rightArray];
+    if (collaborators) {
+      leftCollaborators = getCollaboratorsNames(leftCollaborators, collaborators);
+      rightCollaborators = getCollaboratorsNames(rightCollaborators, collaborators);
+    }
+    return sortCollaborator(leftCollaborators, rightCollaborators, sortType);
+  }
+  var leftText = getFormulaDisplayString(leftArray, columnData);
+  var rightText = getFormulaDisplayString(rightArray, columnData);
+  return sortText(leftText, rightText, sortType);
+};
+
+export { sortByArrayType };

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

@@ -0,0 +1,22 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+/**
+ * Sort checkbox
+ * @param {bool} leftChecked
+ * @param {bool} rightChecked
+ * @param {string} sortType e.g. 'up' | 'down
+ * @returns number
+ */
+var sortCheckbox = function sortCheckbox(leftChecked, rightChecked, sortType) {
+  var normalizedCurrChecked = leftChecked ? 1 : -1;
+  var normalizedNextChecked = rightChecked ? 1 : -1;
+  if (normalizedCurrChecked > normalizedNextChecked) {
+    return sortType === SORT_TYPE.UP ? 1 : -1;
+  }
+  if (normalizedCurrChecked < normalizedNextChecked) {
+    return sortType === SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+export { sortCheckbox };

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

@@ -0,0 +1,16 @@
+import { sortText } from './text.js';
+
+/**
+ * Sort collaborator with email or name
+ * @param {array} leftCollaborators e.g. [ collaborator.email, ... ] | [ collaborator.name, ... ]
+ * @param {array} rightCollaborators
+ * @param {string} sortType e.g. 'up' | 'down
+ * @returns number
+ */
+var sortCollaborator = function sortCollaborator(leftCollaborators, rightCollaborators, sortType) {
+  var sLeftCollaborators = Array.isArray(leftCollaborators) && leftCollaborators.length ? leftCollaborators.join('') : null;
+  var sRightCollaborators = Array.isArray(rightCollaborators) && rightCollaborators.length ? rightCollaborators.join('') : null;
+  return sortText(sLeftCollaborators, sRightCollaborators, sortType);
+};
+
+export { sortCollaborator };

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

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

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

@@ -0,0 +1,49 @@
+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';
+
+/**
+ * Sort formula
+ * @param {any} leftComputedValue compute value from formula row
+ * @param {any} rightComputedValue
+ * @param {string} sortType e.g. 'up' | 'down
+ * @param {object} columnData e.g. { result_type, array_type, array_data, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns number
+ */
+var sortFormula = function sortFormula(leftComputedValue, rightComputedValue, 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 leftNumber = leftComputedValue || leftComputedValue === 0 ? leftComputedValue - 0 : null;
+    var rightNumber = rightComputedValue || rightComputedValue === 0 ? rightComputedValue - 0 : null;
+    return sortNumber(leftNumber, rightNumber, sortType);
+  }
+  if (DATE_COLUMN_OPTIONS.includes(result_type)) {
+    return sortDate(leftComputedValue, rightComputedValue, sortType);
+  }
+  if (result_type === FORMULA_RESULT_TYPE.BOOL) {
+    var leftBoolean = leftComputedValue || false;
+    var rightBoolean = rightComputedValue || false;
+    return sortCheckbox(leftBoolean, rightBoolean, sortType);
+  }
+  if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+    return sortByArrayType(leftComputedValue, rightComputedValue, sortType, {
+      columnData: columnData,
+      value: value
+    });
+  }
+  var leftText = getFormulaDisplayString(leftComputedValue, columnData);
+  var rightText = getFormulaDisplayString(rightComputedValue, columnData);
+  return sortText(leftText, rightText, sortType);
+};
+
+export { sortFormula };

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

@@ -0,0 +1,32 @@
+import { sortByArrayType } from './array.js';
+
+/**
+ * Sort link
+ * @param {array} leftLinkedCellValues e.g. [{ row_id, display_value }]
+ * @param {array} rightLinkedCellValues
+ * @param {string} sortType e.g. 'up' | 'down
+ * @param {object} columnData e.g. { result_type, array_type, array_data, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns number
+ */
+var sortLink = function sortLink(leftLinkedCellValues, rightLinkedCellValues, sortType, _ref) {
+  var columnData = _ref.columnData,
+    value = _ref.value;
+  var emptyLeftLinkedCellValues = !Array.isArray(leftLinkedCellValues) || leftLinkedCellValues.length === 0;
+  var emptyRightLinkedCellValues = !Array.isArray(rightLinkedCellValues) || rightLinkedCellValues.length === 0;
+  if (emptyLeftLinkedCellValues && emptyRightLinkedCellValues) return 0;
+  if (emptyLeftLinkedCellValues) return 1;
+  if (emptyRightLinkedCellValues) return -1;
+  var leftDisplayValues = leftLinkedCellValues.map(function (linked) {
+    return linked.display_value;
+  });
+  var rightDisplayValues = rightLinkedCellValues.map(function (linked) {
+    return linked.display_value;
+  });
+  return sortByArrayType(leftDisplayValues, rightDisplayValues, sortType, {
+    columnData: columnData,
+    value: value
+  });
+};
+
+export { sortLink };

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

@@ -0,0 +1,45 @@
+import { getMultipleIndexesOrderbyOptions } from '../core.js';
+export { getMultipleIndexesOrderbyOptions } from '../core.js';
+import { SORT_TYPE } from '../../constants/sort.js';
+
+/**
+ * Sort multiple-select
+ * @param {array} leftOptionIds the ids of options
+ * @param {array} rightOptionIds
+ * @param {string} sort_type e.g. 'up' | 'down'
+ * @param {object} option_id_index_map e.g. { [option.id]: 0, ... }
+ * @returns number
+ */
+var sortMultipleSelect = function sortMultipleSelect(leftOptionIds, rightOptionIds, _ref) {
+  var sort_type = _ref.sort_type,
+    option_id_index_map = _ref.option_id_index_map;
+  var emptyLeftOptionIds = !leftOptionIds || leftOptionIds.length === 0;
+  var emptyRightOptionIds = !rightOptionIds || rightOptionIds.length === 0;
+  if (emptyLeftOptionIds && emptyRightOptionIds) return 0;
+  if (emptyLeftOptionIds) return 1;
+  if (emptyRightOptionIds) return -1;
+  var leftOptionIndexes = getMultipleIndexesOrderbyOptions(leftOptionIds, option_id_index_map);
+  var rightOptionIndexes = getMultipleIndexesOrderbyOptions(rightOptionIds, option_id_index_map);
+  var leftOptionsLen = leftOptionIndexes.length;
+  var rightOptionsLen = rightOptionIndexes.length;
+
+  // current multiple select equal to next multiple select.
+  if (leftOptionsLen === rightOptionsLen && (leftOptionsLen === 0 || leftOptionIndexes.join('') === rightOptionIndexes.join(''))) {
+    return 0;
+  }
+  var len = Math.min(leftOptionsLen, rightOptionsLen);
+  for (var i = 0; i < len; i++) {
+    if (leftOptionIndexes[i] > rightOptionIndexes[i]) {
+      return sort_type === SORT_TYPE.UP ? 1 : -1;
+    }
+    if (leftOptionIndexes[i] < rightOptionIndexes[i]) {
+      return sort_type === SORT_TYPE.UP ? -1 : 1;
+    }
+  }
+  if (leftOptionsLen > rightOptionsLen) {
+    return sort_type === SORT_TYPE.UP ? 1 : -1;
+  }
+  return sort_type === SORT_TYPE.UP ? -1 : 1;
+};
+
+export { sortMultipleSelect };

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

@@ -0,0 +1,25 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+/**
+ * Sort number
+ * @param {number} leftNumber
+ * @param {number} rightNumber
+ * @param {string} sortType e.g. 'up' | 'down'
+ * @returns number
+ */
+var sortNumber = function sortNumber(leftNumber, rightNumber, sortType) {
+  var emptyLeftNumber = !leftNumber && leftNumber !== 0;
+  var emptyRightNumber = !rightNumber && rightNumber !== 0;
+  if (emptyLeftNumber && emptyRightNumber) return 0;
+  if (emptyLeftNumber) return 1;
+  if (emptyRightNumber) return -1;
+  if (leftNumber > rightNumber) {
+    return sortType === SORT_TYPE.UP ? 1 : -1;
+  }
+  if (leftNumber < rightNumber) {
+    return sortType === SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+export { sortNumber };

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

@@ -0,0 +1,30 @@
+import { SORT_TYPE } from '../../constants/sort.js';
+
+/**
+ * Sort single-select
+ * @param {string} leftOptionId the id of option
+ * @param {string} rightOptionId
+ * @param {string} sort_type e.g. 'up' | 'down'
+ * @param {object} option_id_index_map e.g. { [option.id]: 0, ... }
+ * @returns number
+ */
+var sortSingleSelect = function sortSingleSelect(leftOptionId, rightOptionId, _ref) {
+  var sort_type = _ref.sort_type,
+    option_id_index_map = _ref.option_id_index_map;
+  var currentOptionIdIndex = option_id_index_map[leftOptionId];
+  var nextOptionIdIndex = option_id_index_map[rightOptionId];
+  var emptyLeftOptionId = !currentOptionIdIndex && currentOptionIdIndex !== 0;
+  var emptyRightOptionId = !nextOptionIdIndex && nextOptionIdIndex !== 0;
+  if (emptyLeftOptionId && emptyRightOptionId) return 0;
+  if (emptyLeftOptionId) return 1;
+  if (emptyRightOptionId) 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,61 @@
+import { REG_STRING_NUMBER_PARTS, REG_NUMBER_DIGIT } from '../../constants/reg.js';
+import { SORT_TYPE } from '../../constants/sort.js';
+
+/**
+ * Compare strings
+ * @param {string} leftString
+ * @param {string} rightString
+ * @returns number
+ */
+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);
+      rightStringPart = parseInt(rightStringPart);
+      if (leftStringPart > rightStringPart) {
+        return 1;
+      }
+      if (leftStringPart < rightStringPart) {
+        return -1;
+      }
+    }
+    if (leftStringPart !== rightStringPart) {
+      return leftString.localeCompare(rightString);
+    }
+  }
+  return leftString.localeCompare(rightString);
+};
+
+/**
+ * Sort text
+ * @param {string} leftText
+ * @param {string} rightText
+ * @param {string} sortType e.g. 'up' | 'down
+ * @returns number
+ */
+var sortText = function sortText(leftText, rightText, sortType) {
+  var emptyLeftText = !leftText;
+  var emptyRightText = !rightText;
+  if (emptyLeftText && emptyRightText) return 0;
+  if (emptyLeftText) return 1;
+  if (emptyRightText) return -1;
+  if (rightText === leftText) return 0;
+  return sortType === SORT_TYPE.UP ? compareString(leftText, rightText) : -1 * compareString(leftText, rightText);
+};
+
+export { compareString, sortText };