handsontable 0.0.0-next-9ec04ce-20221121

package/selection/utils.mjs

@@ -0,0 +1,242 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.regexp.exec.js";
+import { CellRange } from "./../3rdparty/walkontable/src/index.mjs";
+import { arrayEach, arrayReduce } from "./../helpers/array.mjs";
+import { isUndefined } from "./../helpers/mixed.mjs";
+export var SELECTION_TYPE_UNRECOGNIZED = 0;
+export var SELECTION_TYPE_EMPTY = 1;
+export var SELECTION_TYPE_ARRAY = 2;
+export var SELECTION_TYPE_OBJECT = 3;
+export var SELECTION_TYPES = [SELECTION_TYPE_OBJECT, SELECTION_TYPE_ARRAY];
+var ARRAY_TYPE_PATTERN = [['number'], ['number', 'string'], ['number', 'undefined'], ['number', 'string', 'undefined']];
+var rootCall = Symbol('root');
+var childCall = Symbol('child');
+
+/**
+ * Detect selection schema structure.
+ *
+ * @param {*} selectionRanges The selected range or and array of selected ranges. This type of data is produced by
+ * `hot.getSelected()`, `hot.getSelectedLast()`, `hot.getSelectedRange()`
+ * and `hot.getSelectedRangeLast()` methods.
+ * @param {symbol} _callSymbol The symbol object which indicates source of the helper invocation.
+ * @returns {number} Returns a number that specifies the type of detected selection schema. If selection schema type
+ * is unrecognized than it returns `0`.
+ */
+export function detectSelectionType(selectionRanges) {
+  var _callSymbol = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : rootCall;
+  if (_callSymbol !== rootCall && _callSymbol !== childCall) {
+    throw new Error('The second argument is used internally only and cannot be overwritten.');
+  }
+  var isArray = Array.isArray(selectionRanges);
+  var isRootCall = _callSymbol === rootCall;
+  var result = SELECTION_TYPE_UNRECOGNIZED;
+  if (isArray) {
+    var firstItem = selectionRanges[0];
+    if (selectionRanges.length === 0) {
+      result = SELECTION_TYPE_EMPTY;
+    } else if (isRootCall && firstItem instanceof CellRange) {
+      result = SELECTION_TYPE_OBJECT;
+    } else if (isRootCall && Array.isArray(firstItem)) {
+      result = detectSelectionType(firstItem, childCall);
+    } else if (selectionRanges.length >= 2 && selectionRanges.length <= 4) {
+      var isArrayType = !selectionRanges.some(function (value, index) {
+        return !ARRAY_TYPE_PATTERN[index].includes(_typeof(value));
+      });
+      if (isArrayType) {
+        result = SELECTION_TYPE_ARRAY;
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Factory function designed for normalization data schema from different data structures of the selection ranges.
+ *
+ * @param {number} type Selection type which will be processed.
+ * @param {object} [options] The normalization options.
+ * @param {boolean} [options.keepDirection=false] If `true`, the coordinates which contain the direction of the
+ *                                                selected cells won't be changed. Otherwise, the selection will be
+ *                                                normalized to values starting from top-left to bottom-right.
+ * @param {Function} [options.propToCol] Pass the converting function (usually `datamap.propToCol`) if the column
+ *                                       defined as props should be normalized to the numeric values.
+ * @returns {number[]} Returns normalized data about selected range as an array (`[rowStart, columnStart, rowEnd, columnEnd]`).
+ */
+export function normalizeSelectionFactory(type) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$keepDirection = _ref.keepDirection,
+    keepDirection = _ref$keepDirection === void 0 ? false : _ref$keepDirection,
+    propToCol = _ref.propToCol;
+  if (!SELECTION_TYPES.includes(type)) {
+    throw new Error('Unsupported selection ranges schema type was provided.');
+  }
+  return function (selection) {
+    var isObjectType = type === SELECTION_TYPE_OBJECT;
+    var rowStart = isObjectType ? selection.from.row : selection[0];
+    var columnStart = isObjectType ? selection.from.col : selection[1];
+    var rowEnd = isObjectType ? selection.to.row : selection[2];
+    var columnEnd = isObjectType ? selection.to.col : selection[3];
+    if (typeof propToCol === 'function') {
+      if (typeof columnStart === 'string') {
+        columnStart = propToCol(columnStart);
+      }
+      if (typeof columnEnd === 'string') {
+        columnEnd = propToCol(columnEnd);
+      }
+    }
+    if (isUndefined(rowEnd)) {
+      rowEnd = rowStart;
+    }
+    if (isUndefined(columnEnd)) {
+      columnEnd = columnStart;
+    }
+    if (!keepDirection) {
+      var origRowStart = rowStart;
+      var origColumnStart = columnStart;
+      var origRowEnd = rowEnd;
+      var origColumnEnd = columnEnd;
+      rowStart = Math.min(origRowStart, origRowEnd);
+      columnStart = Math.min(origColumnStart, origColumnEnd);
+      rowEnd = Math.max(origRowStart, origRowEnd);
+      columnEnd = Math.max(origColumnStart, origColumnEnd);
+    }
+    return [rowStart, columnStart, rowEnd, columnEnd];
+  };
+}
+
+/**
+ * Function transform selection ranges (produced by `hot.getSelected()` and `hot.getSelectedRange()`) to normalized
+ * data structure. It merges repeated ranges into consecutive coordinates. The returned structure
+ * contains an array of arrays. The single item contains at index 0 visual column index from the selection was
+ * started and at index 1 distance as a count of selected columns.
+ *
+ * @param {Array[]|CellRange[]} selectionRanges Selection ranges produced by Handsontable.
+ * @returns {Array[]} Returns an array of arrays with ranges defines in that schema:
+ *                   `[[visualColumnStart, distance], [visualColumnStart, distance], ...]`.
+ *                   The column distances are always created starting from the left (zero index) to the
+ *                   right (the latest column index).
+ */
+export function transformSelectionToColumnDistance(selectionRanges) {
+  var selectionType = detectSelectionType(selectionRanges);
+  if (selectionType === SELECTION_TYPE_UNRECOGNIZED || selectionType === SELECTION_TYPE_EMPTY) {
+    return [];
+  }
+  var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType);
+  var unorderedIndexes = new Set();
+
+  // Iterate through all ranges and collect all column indexes which are not saved yet.
+  arrayEach(selectionRanges, function (selection) {
+    var _selectionSchemaNorma = selectionSchemaNormalizer(selection),
+      _selectionSchemaNorma2 = _slicedToArray(_selectionSchemaNorma, 4),
+      columnStart = _selectionSchemaNorma2[1],
+      columnEnd = _selectionSchemaNorma2[3];
+    var columnNonHeaderStart = Math.max(columnStart, 0);
+    var amount = columnEnd - columnNonHeaderStart + 1;
+    arrayEach(Array.from(new Array(amount), function (_, i) {
+      return columnNonHeaderStart + i;
+    }), function (index) {
+      if (!unorderedIndexes.has(index)) {
+        unorderedIndexes.add(index);
+      }
+    });
+  });
+
+  // Sort indexes in ascending order to easily detecting non-consecutive columns.
+  var orderedIndexes = Array.from(unorderedIndexes).sort(function (a, b) {
+    return a - b;
+  });
+  var normalizedColumnRanges = arrayReduce(orderedIndexes, function (acc, visualColumnIndex, index, array) {
+    if (index !== 0 && visualColumnIndex === array[index - 1] + 1) {
+      acc[acc.length - 1][1] += 1;
+    } else {
+      acc.push([visualColumnIndex, 1]);
+    }
+    return acc;
+  }, []);
+  return normalizedColumnRanges;
+}
+
+/**
+ * Function transform selection ranges (produced by `hot.getSelected()` and `hot.getSelectedRange()`) to normalized
+ * data structure. It merges repeated ranges into consecutive coordinates. The returned structure
+ * contains an array of arrays. The single item contains at index 0 visual column index from the selection was
+ * started and at index 1 distance as a count of selected columns.
+ *
+ * @param {Array[]|CellRange[]} selectionRanges Selection ranges produced by Handsontable.
+ * @returns {Array[]} Returns an array of arrays with ranges defines in that schema:
+ *                   `[[visualColumnStart, distance], [visualColumnStart, distance], ...]`.
+ *                   The column distances are always created starting from the left (zero index) to the
+ *                   right (the latest column index).
+ */
+export function transformSelectionToRowDistance(selectionRanges) {
+  var selectionType = detectSelectionType(selectionRanges);
+  if (selectionType === SELECTION_TYPE_UNRECOGNIZED || selectionType === SELECTION_TYPE_EMPTY) {
+    return [];
+  }
+  var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType);
+  var unorderedIndexes = new Set();
+
+  // Iterate through all ranges and collect all column indexes which are not saved yet.
+  arrayEach(selectionRanges, function (selection) {
+    var _selectionSchemaNorma3 = selectionSchemaNormalizer(selection),
+      _selectionSchemaNorma4 = _slicedToArray(_selectionSchemaNorma3, 3),
+      rowStart = _selectionSchemaNorma4[0],
+      rowEnd = _selectionSchemaNorma4[2];
+    var rowNonHeaderStart = Math.max(rowStart, 0);
+    var amount = rowEnd - rowNonHeaderStart + 1;
+    arrayEach(Array.from(new Array(amount), function (_, i) {
+      return rowNonHeaderStart + i;
+    }), function (index) {
+      if (!unorderedIndexes.has(index)) {
+        unorderedIndexes.add(index);
+      }
+    });
+  });
+
+  // Sort indexes in ascending order to easily detecting non-consecutive columns.
+  var orderedIndexes = Array.from(unorderedIndexes).sort(function (a, b) {
+    return a - b;
+  });
+  var normalizedRowRanges = arrayReduce(orderedIndexes, function (acc, rowIndex, index, array) {
+    if (index !== 0 && rowIndex === array[index - 1] + 1) {
+      acc[acc.length - 1][1] += 1;
+    } else {
+      acc.push([rowIndex, 1]);
+    }
+    return acc;
+  }, []);
+  return normalizedRowRanges;
+}
+
+/**
+ * Check if passed value can be treated as valid cell coordinate. The second argument is
+ * used to check if the value doesn't exceed the defined max table rows/columns count.
+ *
+ * @param {number} coord The coordinate to validate (row index or column index).
+ * @param {number} maxTableItemsCount The value that declares the maximum coordinate that is still validatable.
+ * @returns {boolean}
+ */
+export function isValidCoord(coord) {
+  var maxTableItemsCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
+  return typeof coord === 'number' && coord >= 0 && coord < maxTableItemsCount;
+}

package/settings.d.ts

@@ -0,0 +1,210 @@
+import { PikadayOptions } from 'pikaday';
+import Core from './core';
+import { Events } from './pluginHooks';
+import {
+  CellValue,
+  ColumnDataGetterSetterFunction,
+  LabelOptions,
+  NumericFormatOptions,
+  RowObject,
+  SelectOptionsObject,
+  SimpleCellCoords,
+} from './common';
+import CellCoords from './3rdparty/walkontable/src/cell/coords';
+import { Settings as AutoColumnSizeSettings } from './plugins/autoColumnSize';
+import { Settings as AutofillSettings } from './plugins/autofill';
+import { Settings as AutoRowSizeSettings } from './plugins/autoRowSize';
+import { Settings as CollapsibleColumnsSettings } from './plugins/collapsibleColumns';
+import { Settings as ColumnSortingSettings } from './plugins/columnSorting';
+import { Settings as ColumnSummarySettings } from './plugins/columnSummary';
+import { Settings as CommentsSettings, CommentObject } from './plugins/comments';
+import { Settings as ContextMenuSettings } from './plugins/contextMenu';
+import { Settings as CopyPasteSettings } from './plugins/copyPaste';
+import { Settings as CustomBordersSettings } from './plugins/customBorders';
+import { Settings as DropdownMenuSettings } from './plugins/dropdownMenu';
+import { Settings as FormulasSettings } from './plugins/formulas';
+import { Settings as HiddenColumnsSettings } from './plugins/hiddenColumns';
+import { Settings as HiddenRowsSettings } from './plugins/hiddenRows';
+import { Settings as MergeCellsSettings } from './plugins/mergeCells';
+import { Settings as MultiColumnSortingSettings } from './plugins/multiColumnSorting';
+import { Settings as NestedHeadersSettings } from './plugins/nestedHeaders';
+import { Settings as SearchSettings } from './plugins/search';
+import { EditorType, BaseEditor } from './editors';
+import { RendererType } from './renderers';
+import { BaseRenderer } from './renderers/base';
+import { ValidatorType } from './validators';
+import { BaseValidator } from './validators/base';
+import { CellType } from './cellTypes';
+
+/**
+ * Additional cell-specific meta data.
+ */
+export interface CellMeta extends ColumnSettings {
+  valid?: boolean;
+  comment?: CommentObject;
+  isSearchResult?: boolean;
+  hidden?: boolean;
+  skipRowOnPaste?: boolean;
+}
+
+/**
+ * A rendered cell object with computed properties.
+ */
+export interface CellProperties extends CellMeta {
+  row: number;
+  col: number;
+  instance: Core;
+  visualRow: number;
+  visualCol: number;
+  prop: string | number;
+}
+
+/**
+ * @package
+ * Omit properties K from T
+ */
+export type Omit<T, K extends keyof T> = Pick<T, ({ [P in keyof T]: P } & { [P in K]: never } & { [x: string]: never, [x: number]: never })[keyof T]>;
+
+/**
+ * Column settings inherit grid settings but overload the meaning of `data` to be specific to each column.
+ */
+export interface ColumnSettings extends Omit<GridSettings, "data"> {
+  data?: string | number | ColumnDataGetterSetterFunction;
+  /**
+   * Column and cell meta data is extensible, developers can add any properties they want.
+   */
+  [key: string]: any;
+}
+
+export interface CellSettings extends CellMeta {
+  row: number;
+  col: number;
+}
+
+/**
+ * Base table settings that will cascade to columns and cells.
+ */
+export interface GridSettings extends Events {
+  activeHeaderClassName?: string;
+  allowEmpty?: boolean;
+  allowHtml?: boolean;
+  allowInsertColumn?: boolean;
+  allowInsertRow?: boolean;
+  allowInvalid?: boolean;
+  allowRemoveColumn?: boolean;
+  allowRemoveRow?: boolean;
+  autoColumnSize?: AutoColumnSizeSettings;
+  autoRowSize?: AutoRowSizeSettings;
+  autoWrapCol?: boolean;
+  autoWrapRow?: boolean;
+  bindRowsWithHeaders?: boolean | 'loose' | 'strict';
+  cell?: CellSettings[];
+  cells?: (this: CellProperties, row: number, column: number, prop: string | number) => CellMeta;
+  checkedTemplate?: boolean | string | number;
+  className?: string | string[];
+  colHeaders?: boolean | string[] | ((index: number) => string);
+  collapsibleColumns?: CollapsibleColumnsSettings;
+  columnHeaderHeight?: number | Array<number | undefined>;
+  columns?: ColumnSettings[] | ((index: number) => ColumnSettings);
+  columnSorting?: ColumnSortingSettings;
+  columnSummary?: ColumnSummarySettings;
+  colWidths?: number | string | number[] | string[] | undefined[] | Array<number | string | undefined> | ((index: number) => string | number | undefined);
+  commentedCellClassName?: string;
+  comments?: CommentsSettings;
+  contextMenu?: ContextMenuSettings;
+  copyable?: boolean;
+  copyPaste?: CopyPasteSettings;
+  correctFormat?: boolean;
+  currentColClassName?: string;
+  currentHeaderClassName?: string;
+  currentRowClassName?: string;
+  customBorders?: CustomBordersSettings;
+  data?: CellValue[][] | RowObject[];
+  dataSchema?: RowObject | CellValue[] | ((row: number) => RowObject | CellValue[]);
+  dateFormat?: string;
+  datePickerConfig?: PikadayOptions;
+  defaultDate?: string;
+  disableVisualSelection?: boolean | 'current' | 'area' | 'header' | Array<'current' | 'area' | 'header'>;
+  dragToScroll?: boolean;
+  dropdownMenu?: DropdownMenuSettings;
+  editor?: EditorType | typeof BaseEditor | boolean | string;
+  enterBeginsEditing?: boolean;
+  enterMoves?: CellCoords | SimpleCellCoords | ((event: KeyboardEvent) => CellCoords | SimpleCellCoords);
+  fillHandle?: AutofillSettings;
+  filter?: boolean;
+  filteringCaseSensitive?: boolean;
+  filters?: boolean;
+  fixedColumnsLeft?: number;
+  fixedColumnsStart?: number;
+  fixedRowsBottom?: number;
+  fixedRowsTop?: number;
+  formulas?: FormulasSettings;
+  fragmentSelection?: boolean | 'cell';
+  height?: number | string | (() => number | string);
+  hiddenColumns?: HiddenColumnsSettings;
+  hiddenRows?: HiddenRowsSettings;
+  invalidCellClassName?: string;
+  isEmptyCol?: (this: Core, col: number) => boolean;
+  isEmptyRow?: (this: Core, row: number) => boolean;
+  label?: LabelOptions;
+  language?: string;
+  layoutDirection?: 'ltr' | 'rtl' | 'inherit';
+  licenseKey?: string | 'non-commercial-and-evaluation';
+  manualColumnFreeze?: boolean;
+  manualColumnMove?: boolean | number[];
+  manualColumnResize?: boolean | number[];
+  manualRowMove?: boolean | number[];
+  manualRowResize?: boolean | number[];
+  maxCols?: number;
+  maxRows?: number;
+  mergeCells?: MergeCellsSettings;
+  minCols?: number;
+  minRows?: number;
+  minSpareCols?: number;
+  minSpareRows?: number;
+  multiColumnSorting?: MultiColumnSortingSettings;
+  nestedHeaders?: NestedHeadersSettings;
+  nestedRows?: boolean;
+  noWordWrapClassName?: string;
+  numericFormat?: NumericFormatOptions;
+  observeDOMVisibility?: boolean;
+  outsideClickDeselects?: boolean | ((target: HTMLElement) => boolean);
+  persistentState?: boolean;
+  placeholder?: string;
+  placeholderCellClassName?: string;
+  preventOverflow?: boolean | 'vertical' | 'horizontal';
+  preventWheel?: boolean;
+  readOnly?: boolean;
+  readOnlyCellClassName?: string;
+  renderAllRows?: boolean;
+  renderer?: RendererType | string | BaseRenderer;
+  rowHeaders?: boolean | string[] | ((index: number) => string);
+  rowHeaderWidth?: number | number[];
+  rowHeights?: number | string | number[] | string[] | undefined[] | Array<number | string | undefined> | ((index: number) => string | number | undefined);
+  search?: SearchSettings;
+  selectionMode?: 'single' | 'range' | 'multiple';
+  selectOptions?: string[] | SelectOptionsObject | ((visualRow: number, visualColumn: number, prop: string | number) => string[] | SelectOptionsObject);
+  skipColumnOnPaste?: boolean;
+  skipRowOnPaste?: boolean;
+  sortByRelevance?: boolean;
+  source?: string[] | number[] | ((this: CellProperties, query: string, callback: (items: string[]) => void) => void);
+  startCols?: number;
+  startRows?: number;
+  stretchH?: 'none' | 'all' | 'last';
+  strict?: boolean;
+  tableClassName?: string | string[];
+  tabMoves?: CellCoords | SimpleCellCoords | ((event: KeyboardEvent) => CellCoords | SimpleCellCoords);
+  title?: string;
+  trimDropdown?: boolean;
+  trimRows?: boolean | number[];
+  trimWhitespace?: boolean;
+  type?: CellType | string;
+  uncheckedTemplate?: boolean | string | number;
+  undo?: boolean;
+  validator?: BaseValidator | RegExp | ValidatorType | string;
+  viewportColumnRenderingOffset?: number | 'auto';
+  viewportRowRenderingOffset?: number | 'auto';
+  visibleRows?: number;
+  width?: number | string | (() => number | string);
+  wordWrap?: boolean;
+}

package/shortcuts/context.d.ts

@@ -0,0 +1,20 @@
+interface Shortcut {
+  keys: string[][];
+  callback: (event: Event) => boolean | void;
+  group: string;
+  runOnlyIf?: () => boolean;
+  captureCtrl?: boolean;
+  preventDefault?: boolean;
+  stopPropagation?: boolean;
+  relativeToGroup?: string;
+  position?: 'before' | 'after';
+}
+
+export interface Context {
+  addShortcut(shortcut: Shortcut): void;
+  addShortcuts(shortcuts: Shortcut[]): void;
+  getShortcuts(): Shortcut[];
+  hasShortcut(keys: string[]): boolean;
+  removeShortcutsByKeys(keys: string[]): void;
+  removeShortcutsByGroup(group: string): void;
+}