handsontable 9.0.2 → 11.1.0

package/cellTypes/passwordType/passwordType.d.ts

@@ -0,0 +1,14 @@
+import { CellTypeObject } from '../base';
+import { PasswordEditor } from '../../editors/passwordEditor';
+import { passwordRenderer } from '../../renderers/passwordRenderer';
+
+export const CELL_TYPE: 'password';
+export interface PasswordCellType extends CellTypeObject {
+  editor: typeof PasswordEditor;
+  renderer: typeof passwordRenderer;
+}
+
+export namespace PasswordCellType {
+  export { PasswordEditor as editor };
+  export { passwordRenderer as renderer };
+}

package/cellTypes/registry.d.ts

@@ -0,0 +1,18 @@
+import { CellTypes } from './index';
+import { CellTypeObject } from './base';
+
+declare function _register(type: CellTypeObject): void;
+declare function _register(name: string, type: CellTypeObject): void;
+declare function _getItem<T extends keyof CellTypes>(name: T): CellTypes[T];
+declare function _getItem(name: string): CellTypeObject;
+declare function hasItem(name: string): boolean;
+declare function getNames(): string[];
+declare function getValues(): CellTypeObject[];
+
+export {
+  _register as registerCellType,
+  _getItem as getCellType,
+  hasItem as hasCellType,
+  getNames as getRegisteredCellTypeNames,
+  getValues as getRegisteredCellTypes
+};

package/cellTypes/registry.js

@@ -1,9 +1,9 @@
 "use strict";
 
 exports.__esModule = true;
-exports.registerCellType = _register;
 exports.getCellType = _getItem;
-exports.getRegisteredCellTypes = exports.getRegisteredCellTypeNames = exports.hasCellType = void 0;
+exports.hasCellType = exports.getRegisteredCellTypes = exports.getRegisteredCellTypeNames = void 0;
+exports.registerCellType = _register;
 
 var _staticRegister2 = _interopRequireDefault(require("../utils/staticRegister"));
 

package/cellTypes/textType/index.d.ts

@@ -0,0 +1 @@
+export * from './textType';

package/cellTypes/textType/textType.d.ts

@@ -0,0 +1,14 @@
+import { CellTypeObject } from '../base';
+import { TextEditor } from '../../editors/textEditor';
+import { textRenderer } from '../../renderers/textRenderer';
+
+export const CELL_TYPE: 'text';
+export interface TextCellType extends CellTypeObject {
+  editor: typeof TextEditor;
+  renderer: typeof textRenderer;
+}
+
+export namespace TextCellType {
+  export { TextEditor as editor };
+  export { textRenderer as renderer };
+}

package/cellTypes/timeType/index.d.ts

@@ -0,0 +1 @@
+export * from './timeType';

package/cellTypes/timeType/timeType.d.ts

@@ -0,0 +1,17 @@
+import { CellTypeObject } from '../base';
+import { TextEditor } from '../../editors/textEditor';
+import { textRenderer } from '../../renderers/textRenderer';
+import { timeValidator } from '../../validators/timeValidator';
+
+export const CELL_TYPE: 'time';
+export interface TimeCellType extends CellTypeObject {
+  editor: typeof TextEditor;
+  renderer: typeof textRenderer;
+  validator: typeof timeValidator;
+}
+
+export namespace TimeCellType {
+  export { TextEditor as editor };
+  export { textRenderer as renderer };
+  export { timeValidator as validator };
+}

package/common.d.ts

@@ -0,0 +1,74 @@
+import numbro from 'numbro';
+
+// These types represent default known values, but users can extend with their own, leading to the need for assertions.
+// Using type arguments (ex `_GridSettings<CellValue, CellType, SourceData>`) would solve this and provide very strict
+// type-checking, but adds a lot of noise for no benefit in the most common use cases.
+
+/**
+ * A cell value, which can be anything to support custom cell data types, but by default is `string | number | boolean | undefined`.
+ */
+export type CellValue = any;
+
+/**
+ * A cell change represented by `[row, column, prevValue, nextValue]`.
+ */
+export type CellChange = [number, string | number, CellValue, CellValue];
+
+/**
+ * A row object, one of the two ways to supply data to the table, the alternative being an array of values.
+ * Row objects can have any data assigned to them, not just column data, and can define a `__children` array for nested rows.
+ */
+export interface RowObject {
+  [prop: string]: any;
+}
+
+/**
+ * An object containing possible options to use in SelectEditor.
+ */
+export interface SelectOptionsObject {
+  [prop: string]: string;
+}
+
+/**
+ * A single row of source data, which can be represented as an array of values, or an object with key/value pairs.
+ */
+export type SourceRowData = RowObject | CellValue[];
+
+export interface SimpleCellCoords {
+  row: number;
+  col: number;
+}
+
+export interface RangeType {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
+/**
+ * The default sources for which the table triggers hooks.
+ */
+export type ChangeSource = 'auto' | 'edit' | 'loadData' | 'populateFromArray' | 'spliceCol' |
+                           'spliceRow' | 'timeValidate' | 'dateValidate' | 'validateCells' |
+                           'Autofill.fill' | 'ContextMenu.clearColumns' | 'ContextMenu.columnLeft' |
+                           'ContextMenu.columnRight' | 'ContextMenu.removeColumn' |
+                           'ContextMenu.removeRow' | 'ContextMenu.rowAbove' | 'ContextMenu.rowBelow' |
+                           'CopyPaste.paste' | 'UndoRedo.redo' | 'UndoRedo.undo' | 'ColumnSummary.set' |
+                           'ColumnSummary.reset';
+
+export interface LabelOptions {
+  property?: string;
+  position?: 'before' | 'after';
+  value?: string | (() => string);
+}
+
+export interface NumericFormatOptions {
+  pattern: string | numbro.Format;
+  culture?: string;
+}
+
+export interface ColumnDataGetterSetterFunction {
+  (row: RowObject | CellValue[]): CellValue;
+  (row: RowObject | CellValue[], value: CellValue): void;
+}

package/core.d.ts

@@ -0,0 +1,160 @@
+import { IndexMapper } from './translations';
+import { Events } from './pluginHooks';
+import {
+  CellValue,
+  RowObject,
+} from './common';
+import {
+  GridSettings,
+  CellMeta,
+  CellProperties,
+} from './settings';
+import CellCoords from './3rdparty/walkontable/src/cell/coords';
+import CellRange from './3rdparty/walkontable/src/cell/range';
+import { BaseEditor } from './editors/baseEditor';
+import { BaseRenderer } from './renderers/base';
+import { BaseValidator } from './validators/base';
+import { Plugins } from './plugins';
+import { CellType } from './cellTypes';
+
+export default class Core {
+  addHook<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>): void;
+  addHookOnce<K extends keyof Events>(key: K, callback: Events[K] | Array<Events[K]>): void;
+  alter(action: 'insert_row' | 'insert_col' | 'remove_row' | 'remove_col', index?: number | Array<[number, number]>, amount?: number, source?: string, keepEmptyRows?: boolean): void;
+  batch<R>(wrappedOperations: () => R): R;
+  batchExecution<R>(wrappedOperations: () => R, forceFlushChanges: boolean): R;
+  batchRender<R>(wrappedOperations: () => R): R;
+  clear(): void;
+  clearUndo(): void;
+  colOffset(): number;
+  colToProp(col: number): string | number;
+  columnIndexMapper: IndexMapper;
+  constructor(element: Element, options: GridSettings);
+  container: HTMLElement;
+  countCols(): number;
+  countEmptyCols(ending?: boolean): number;
+  countEmptyRows(ending?: boolean): number;
+  countRenderedCols(): number;
+  countRenderedRows(): number;
+  countRows(): number;
+  countSourceCols(): number;
+  countSourceRows(): number;
+  countVisibleCols(): number;
+  countVisibleRows(): number;
+  deselectCell(): void;
+  destroy(): void;
+  destroyEditor(revertOriginal?: boolean, prepareEditorIfNeeded?: boolean): void;
+  emptySelectedCells(): void;
+  forceFullRender: boolean;
+  getActiveEditor(): BaseEditor | undefined;
+  getCell(row: number, col: number, topmost?: boolean): HTMLTableCellElement | null;
+  getCellEditor(cellMeta: CellMeta): BaseEditor;
+  getCellEditor(row: number, col: number): BaseEditor;
+  getCellMeta(row: number, col: number): CellProperties;
+  getCellMetaAtRow(row: number): CellProperties[];
+  getCellRenderer(cellMeta: CellMeta): BaseRenderer;
+  getCellRenderer(row: number, col: number): BaseRenderer;
+  getCellsMeta(): CellProperties[];
+  getCellValidator(cellMeta: CellMeta): BaseValidator | RegExp | undefined;
+  getCellValidator(row: number, col: number): BaseValidator | RegExp | undefined;
+  getColHeader(): Array<number | string>;
+  getColHeader(col: number): number | string;
+  getColWidth(col: number): number;
+  getCoords(elem: Element | null): CellCoords;
+  getCopyableData(row: number, column: number): string;
+  getCopyableText(startRow: number, startCol: number, endRow: number, endCol: number): string;
+  getData(row?: number, column?: number, row2?: number, column2?: number): CellValue[];
+  getDataAtCell(row: number, column: number): CellValue;
+  getDataAtCol(column: number): CellValue[];
+  getDataAtProp(prop: string | number): CellValue[];
+  getDataAtRow(row: number): CellValue[];
+  getDataAtRowProp(row: number, prop: string): CellValue;
+  getDataType(rowFrom: number, columnFrom: number, rowTo: number, columnTo: number): CellType | 'mixed';
+  getInstance(): Core;
+  getPlugin<T extends keyof Plugins>(pluginName: T): Plugins[T];
+  getPlugin(pluginName: string): Plugins['basePlugin'];
+  getRowHeader(): Array<string | number>;
+  getRowHeader(row: number): string | number;
+  getRowHeight(row: number): number;
+  getSchema(): RowObject;
+  getSelected(): Array<[number, number, number, number]> | undefined;
+  getSelectedLast(): number[] | undefined;
+  getSelectedRange(): CellRange[] | undefined;
+  getSelectedRangeLast(): CellRange | undefined;
+  getSettings(): GridSettings;
+  getSourceData(row?: number, column?: number, row2?: number, column2?: number): CellValue[][] | RowObject[];
+  getSourceDataArray(row?: number, column?: number, row2?: number, ccolumn2?: number): CellValue[][];
+  getSourceDataAtCell(row: number, column: number): CellValue;
+  getSourceDataAtCol(column: number): CellValue[];
+  getSourceDataAtRow(row: number): CellValue[] | RowObject;
+  getTranslatedPhrase(dictionaryKey: string, extraArguments: any): string | null;
+  getValue(): CellValue;
+  hasColHeaders(): boolean;
+  hasHook(key: keyof Events): boolean;
+  hasRowHeaders(): boolean;
+  init(): () => void;
+  isColumnModificationAllowed(): boolean;
+  isDestroyed: boolean;
+  isEmptyCol(col: number): boolean;
+  isEmptyRow(row: number): boolean;
+  isExecutionSuspended(): boolean;
+  isListening(): boolean;
+  isRedoAvailable(): boolean;
+  isRenderSuspended(): boolean;
+  isUndoAvailable(): boolean;
+  listen(): void;
+  loadData(data: CellValue[][] | RowObject[], source?: string): void;
+  populateFromArray(row: number, col: number, input: CellValue[][], endRow?: number,
+    endCol?: number, source?: string, method?: 'shift_down' | 'shift_right' | 'overwrite',
+    direction?: 'left' | 'right' | 'up' | 'down', deltas?: any[]): void;
+  propToCol(prop: string | number): number;
+  redo(): void;
+  refreshDimensions(): void;
+  removeCellMeta(row: number, col: number, key: (keyof CellMeta) | string): void;
+  removeHook<K extends keyof Events>(key: K, callback: Events[K]): void;
+  render(): void;
+  renderCall: boolean;
+  resumeExecution(): void;
+  resumeRender(): void;
+  rootDocument: Document;
+  rootElement: HTMLElement;
+  rootWindow: Window;
+  rowIndexMapper: IndexMapper;
+  rowOffset(): number;
+  runHooks(key: keyof Events, p1?: any, p2?: any, p3?: any, p4?: any, p5?: any, p6?: any): any;
+  scrollViewportTo(row?: number, column?: number, snapToBottom?: boolean, snapToRight?: boolean, considerHiddenIndexes?: boolean): boolean;
+  selectAll(): void;
+  selectCell(row: number, col: number, endRow?: number, endCol?: number, scrollToCell?: boolean, changeListener?: boolean): boolean;
+  selectCellByProp(row: number, prop: string, endRow?: number, endProp?: string, scrollToCell?: boolean): boolean;
+  selectCells(coords: Array<[number, number | string, number, number | string]> | CellRange[], scrollToCell?: boolean, changeListener?: boolean): boolean;
+  selectColumns(startColumn: number | string, endColumn?: number | string): boolean;
+  selectRows(startRow: number, endRow?: number): boolean;
+  setCellMeta(row: number, col: number, key: string, val: any): void;
+  setCellMeta<K extends keyof CellMeta>(row: number, col: number, key: K, val: CellMeta[K]): void;
+  setCellMetaObject(row: number, col: number, prop: CellMeta): void;
+  setDataAtCell(changes: Array<[number, number, CellValue]>, source?: string): void;
+  setDataAtCell(row: number, col: number, value: CellValue, source?: string): void;
+  setDataAtRowProp(changes: Array<[number, string | number, CellValue]>, source?: string): void;
+  setDataAtRowProp(row: number, prop: string, value: CellValue, source?: string): void;
+  setSourceDataAtCell(changes: Array<[number, string | number, CellValue]>): void;
+  setSourceDataAtCell(row: number, column: number | string, value: CellValue, source?: string): void;
+  spliceCol(col: number, index: number, amount: number, ...elements: CellValue[]): void;
+  spliceRow(row: number, index: number, amount: number, ...elements: CellValue[]): void;
+  suspendExecution(): void;
+  suspendRender(): void;
+  table: HTMLTableElement;
+  toHTML(): string;
+  toPhysicalColumn(column: number): number;
+  toPhysicalRow(row: number): number;
+  toTableElement(): HTMLTableElement;
+  toVisualColumn(column: number): number;
+  toVisualRow(row: number): number;
+  undo(): void;
+  unlisten(): void;
+  updateData(data: CellValue[][] | RowObject[], source?: string): void;
+  updateSettings(settings: GridSettings, init?: boolean): void;
+  validateCell(value: any, cellProperties: CellProperties, callback: (valid: boolean) => void, source: string): void;
+  validateCells(callback?: (valid: boolean) => void): void;
+  validateColumns(columns: number[], callback?: (valid: boolean) => void): void;
+  validateRows(rows: number[], callback?: (valid: boolean) => void): void;
+}