handsontable 0.0.0-next-9ec04ce-20221121

package/cellTypes/index.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.hasCellType = exports.getRegisteredCellTypes = exports.getRegisteredCellTypeNames = exports.getCellType = void 0;
+exports.registerAllCellTypes = registerAllCellTypes;
+var _autocompleteType = require("./autocompleteType");
+exports.AutocompleteCellType = _autocompleteType.AutocompleteCellType;
+exports.AUTOCOMPLETE_TYPE = _autocompleteType.CELL_TYPE;
+var _checkboxType = require("./checkboxType");
+exports.CheckboxCellType = _checkboxType.CheckboxCellType;
+exports.CHECKBOX_TYPE = _checkboxType.CELL_TYPE;
+var _dateType = require("./dateType");
+exports.DateCellType = _dateType.DateCellType;
+exports.DATE_TYPE = _dateType.CELL_TYPE;
+var _dropdownType = require("./dropdownType");
+exports.DropdownCellType = _dropdownType.DropdownCellType;
+exports.DROPDOWN_TYPE = _dropdownType.CELL_TYPE;
+var _handsontableType = require("./handsontableType");
+exports.HandsontableCellType = _handsontableType.HandsontableCellType;
+exports.HANDSONTABLE_TYPE = _handsontableType.CELL_TYPE;
+var _numericType = require("./numericType");
+exports.NumericCellType = _numericType.NumericCellType;
+exports.NUMERIC_TYPE = _numericType.CELL_TYPE;
+var _passwordType = require("./passwordType");
+exports.PasswordCellType = _passwordType.PasswordCellType;
+exports.PASSWORD_TYPE = _passwordType.CELL_TYPE;
+var _textType = require("./textType");
+exports.TextCellType = _textType.TextCellType;
+exports.TEXT_TYPE = _textType.CELL_TYPE;
+var _timeType = require("./timeType");
+exports.TimeCellType = _timeType.TimeCellType;
+exports.TIME_TYPE = _timeType.CELL_TYPE;
+var _registry = require("./registry");
+exports.registerCellType = _registry.registerCellType;
+exports.getCellType = _registry.getCellType;
+exports.getRegisteredCellTypeNames = _registry.getRegisteredCellTypeNames;
+exports.getRegisteredCellTypes = _registry.getRegisteredCellTypes;
+exports.hasCellType = _registry.hasCellType;
+/**
+ * Registers all available cell types.
+ */
+function registerAllCellTypes() {
+  (0, _registry.registerCellType)(_autocompleteType.AutocompleteCellType);
+  (0, _registry.registerCellType)(_checkboxType.CheckboxCellType);
+  (0, _registry.registerCellType)(_dateType.DateCellType);
+  (0, _registry.registerCellType)(_dropdownType.DropdownCellType);
+  (0, _registry.registerCellType)(_handsontableType.HandsontableCellType);
+  (0, _registry.registerCellType)(_numericType.NumericCellType);
+  (0, _registry.registerCellType)(_passwordType.PasswordCellType);
+  (0, _registry.registerCellType)(_textType.TextCellType);
+  (0, _registry.registerCellType)(_timeType.TimeCellType);
+}

package/cellTypes/index.mjs

@@ -0,0 +1,26 @@
+import { AutocompleteCellType, CELL_TYPE as AUTOCOMPLETE_TYPE } from "./autocompleteType/index.mjs";
+import { CheckboxCellType, CELL_TYPE as CHECKBOX_TYPE } from "./checkboxType/index.mjs";
+import { DateCellType, CELL_TYPE as DATE_TYPE } from "./dateType/index.mjs";
+import { DropdownCellType, CELL_TYPE as DROPDOWN_TYPE } from "./dropdownType/index.mjs";
+import { HandsontableCellType, CELL_TYPE as HANDSONTABLE_TYPE } from "./handsontableType/index.mjs";
+import { NumericCellType, CELL_TYPE as NUMERIC_TYPE } from "./numericType/index.mjs";
+import { PasswordCellType, CELL_TYPE as PASSWORD_TYPE } from "./passwordType/index.mjs";
+import { TextCellType, CELL_TYPE as TEXT_TYPE } from "./textType/index.mjs";
+import { TimeCellType, CELL_TYPE as TIME_TYPE } from "./timeType/index.mjs";
+import { registerCellType } from "./registry.mjs";
+/**
+ * Registers all available cell types.
+ */
+export function registerAllCellTypes() {
+  registerCellType(AutocompleteCellType);
+  registerCellType(CheckboxCellType);
+  registerCellType(DateCellType);
+  registerCellType(DropdownCellType);
+  registerCellType(HandsontableCellType);
+  registerCellType(NumericCellType);
+  registerCellType(PasswordCellType);
+  registerCellType(TextCellType);
+  registerCellType(TimeCellType);
+}
+export { AutocompleteCellType, AUTOCOMPLETE_TYPE, CheckboxCellType, CHECKBOX_TYPE, DateCellType, DATE_TYPE, DropdownCellType, DROPDOWN_TYPE, HandsontableCellType, HANDSONTABLE_TYPE, NumericCellType, NUMERIC_TYPE, PasswordCellType, PASSWORD_TYPE, TextCellType, TEXT_TYPE, TimeCellType, TIME_TYPE };
+export { getCellType, getRegisteredCellTypeNames, getRegisteredCellTypes, hasCellType, registerCellType } from "./registry.mjs";

package/cellTypes/numericType/index.d.ts

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

package/cellTypes/numericType/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+exports.NumericCellType = exports.CELL_TYPE = void 0;
+var _numericType = require("./numericType");
+exports.CELL_TYPE = _numericType.CELL_TYPE;
+exports.NumericCellType = _numericType.NumericCellType;

package/cellTypes/numericType/index.mjs

@@ -0,0 +1 @@
+export { CELL_TYPE, NumericCellType } from "./numericType.mjs";

package/cellTypes/numericType/numericType.d.ts

@@ -0,0 +1,17 @@
+import { CellTypeObject } from '../base';
+import { NumericEditor } from '../../editors/numericEditor';
+import { numericRenderer } from '../../renderers/numericRenderer';
+import { numericValidator } from '../../validators/numericValidator';
+
+export const CELL_TYPE: 'numeric';
+export interface NumericCellType extends CellTypeObject {
+  editor: typeof NumericEditor;
+  renderer: typeof numericRenderer;
+  validator: typeof numericValidator;
+}
+
+export namespace NumericCellType {
+  export { NumericEditor as editor };
+  export { numericRenderer as renderer };
+  export { numericValidator as validator };
+}

package/cellTypes/numericType/numericType.js

@@ -0,0 +1,17 @@
+"use strict";
+
+exports.__esModule = true;
+exports.NumericCellType = exports.CELL_TYPE = void 0;
+var _numericEditor = require("../../editors/numericEditor");
+var _numericRenderer = require("../../renderers/numericRenderer");
+var _numericValidator = require("../../validators/numericValidator");
+var CELL_TYPE = 'numeric';
+exports.CELL_TYPE = CELL_TYPE;
+var NumericCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: _numericEditor.NumericEditor,
+  renderer: _numericRenderer.numericRenderer,
+  validator: _numericValidator.numericValidator,
+  dataType: 'number'
+};
+exports.NumericCellType = NumericCellType;

package/cellTypes/numericType/numericType.mjs

@@ -0,0 +1,11 @@
+import { NumericEditor } from "../../editors/numericEditor/index.mjs";
+import { numericRenderer } from "../../renderers/numericRenderer/index.mjs";
+import { numericValidator } from "../../validators/numericValidator/index.mjs";
+export var CELL_TYPE = 'numeric';
+export var NumericCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: NumericEditor,
+  renderer: numericRenderer,
+  validator: numericValidator,
+  dataType: 'number'
+};

package/cellTypes/passwordType/index.d.ts

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

package/cellTypes/passwordType/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+exports.PasswordCellType = exports.CELL_TYPE = void 0;
+var _passwordType = require("./passwordType");
+exports.CELL_TYPE = _passwordType.CELL_TYPE;
+exports.PasswordCellType = _passwordType.PasswordCellType;

package/cellTypes/passwordType/index.mjs

@@ -0,0 +1 @@
+export { CELL_TYPE, PasswordCellType } from "./passwordType.mjs";

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/passwordType/passwordType.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.PasswordCellType = exports.CELL_TYPE = void 0;
+var _passwordEditor = require("../../editors/passwordEditor");
+var _passwordRenderer = require("../../renderers/passwordRenderer");
+var CELL_TYPE = 'password';
+exports.CELL_TYPE = CELL_TYPE;
+var PasswordCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: _passwordEditor.PasswordEditor,
+  renderer: _passwordRenderer.passwordRenderer,
+  copyable: false
+};
+exports.PasswordCellType = PasswordCellType;

package/cellTypes/passwordType/passwordType.mjs

@@ -0,0 +1,9 @@
+import { PasswordEditor } from "../../editors/passwordEditor/index.mjs";
+import { passwordRenderer } from "../../renderers/passwordRenderer/index.mjs";
+export var CELL_TYPE = 'password';
+export var PasswordCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: PasswordEditor,
+  renderer: passwordRenderer,
+  copyable: false
+};

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

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getCellType = _getItem;
+exports.hasCellType = exports.getRegisteredCellTypes = exports.getRegisteredCellTypeNames = void 0;
+exports.registerCellType = _register;
+var _staticRegister2 = _interopRequireDefault(require("../utils/staticRegister"));
+var _registry = require("../editors/registry");
+var _registry2 = require("../renderers/registry");
+var _registry3 = require("../validators/registry");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _staticRegister = (0, _staticRegister2.default)('cellTypes'),
+  register = _staticRegister.register,
+  getItem = _staticRegister.getItem,
+  hasItem = _staticRegister.hasItem,
+  getNames = _staticRegister.getNames,
+  getValues = _staticRegister.getValues;
+
+/**
+ * Retrieve cell type object.
+ *
+ * @param {string} name Cell type identification.
+ * @returns {object} Returns cell type object.
+ */
+exports.getRegisteredCellTypes = getValues;
+exports.getRegisteredCellTypeNames = getNames;
+exports.hasCellType = hasItem;
+function _getItem(name) {
+  if (!hasItem(name)) {
+    throw Error("You declared cell type \"".concat(name, "\" as a string that is not mapped to a known object.\n                 Cell type must be an object or a string mapped to an object registered by\n                 \"Handsontable.cellTypes.registerCellType\" method"));
+  }
+  return getItem(name);
+}
+
+/**
+ * Register cell type under specified name.
+ *
+ * @param {string} name Cell type identification.
+ * @param {object} type An object with contains keys (eq: `editor`, `renderer`, `validator`) which describes specified behaviour of the cell.
+ */
+function _register(name, type) {
+  if (typeof name !== 'string') {
+    type = name;
+    name = type.CELL_TYPE;
+  }
+  var _type = type,
+    editor = _type.editor,
+    renderer = _type.renderer,
+    validator = _type.validator;
+  if (editor) {
+    (0, _registry.registerEditor)(name, editor);
+  }
+  if (renderer) {
+    (0, _registry2.registerRenderer)(name, renderer);
+  }
+  if (validator) {
+    (0, _registry3.registerValidator)(name, validator);
+  }
+  register(name, type);
+}

package/cellTypes/registry.mjs

@@ -0,0 +1,51 @@
+import staticRegister from "../utils/staticRegister.mjs";
+import { registerEditor } from "../editors/registry.mjs";
+import { registerRenderer } from "../renderers/registry.mjs";
+import { registerValidator } from "../validators/registry.mjs";
+var _staticRegister = staticRegister('cellTypes'),
+  register = _staticRegister.register,
+  getItem = _staticRegister.getItem,
+  hasItem = _staticRegister.hasItem,
+  getNames = _staticRegister.getNames,
+  getValues = _staticRegister.getValues;
+
+/**
+ * Retrieve cell type object.
+ *
+ * @param {string} name Cell type identification.
+ * @returns {object} Returns cell type object.
+ */
+function _getItem(name) {
+  if (!hasItem(name)) {
+    throw Error("You declared cell type \"".concat(name, "\" as a string that is not mapped to a known object.\n                 Cell type must be an object or a string mapped to an object registered by\n                 \"Handsontable.cellTypes.registerCellType\" method"));
+  }
+  return getItem(name);
+}
+
+/**
+ * Register cell type under specified name.
+ *
+ * @param {string} name Cell type identification.
+ * @param {object} type An object with contains keys (eq: `editor`, `renderer`, `validator`) which describes specified behaviour of the cell.
+ */
+function _register(name, type) {
+  if (typeof name !== 'string') {
+    type = name;
+    name = type.CELL_TYPE;
+  }
+  var _type = type,
+    editor = _type.editor,
+    renderer = _type.renderer,
+    validator = _type.validator;
+  if (editor) {
+    registerEditor(name, editor);
+  }
+  if (renderer) {
+    registerRenderer(name, renderer);
+  }
+  if (validator) {
+    registerValidator(name, validator);
+  }
+  register(name, type);
+}
+export { _register as registerCellType, _getItem as getCellType, hasItem as hasCellType, getNames as getRegisteredCellTypeNames, getValues as getRegisteredCellTypes };

package/cellTypes/textType/index.d.ts

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

package/cellTypes/textType/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+exports.TextCellType = exports.CELL_TYPE = void 0;
+var _textType = require("./textType");
+exports.CELL_TYPE = _textType.CELL_TYPE;
+exports.TextCellType = _textType.TextCellType;

package/cellTypes/textType/index.mjs

@@ -0,0 +1 @@
+export { CELL_TYPE, TextCellType } from "./textType.mjs";

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/textType/textType.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.TextCellType = exports.CELL_TYPE = void 0;
+var _textEditor = require("../../editors/textEditor");
+var _textRenderer = require("../../renderers/textRenderer");
+var CELL_TYPE = 'text';
+exports.CELL_TYPE = CELL_TYPE;
+var TextCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: _textEditor.TextEditor,
+  renderer: _textRenderer.textRenderer
+};
+exports.TextCellType = TextCellType;

package/cellTypes/textType/textType.mjs

@@ -0,0 +1,8 @@
+import { TextEditor } from "../../editors/textEditor/index.mjs";
+import { textRenderer } from "../../renderers/textRenderer/index.mjs";
+export var CELL_TYPE = 'text';
+export var TextCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: TextEditor,
+  renderer: textRenderer
+};

package/cellTypes/timeType/index.d.ts

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

package/cellTypes/timeType/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+exports.__esModule = true;
+exports.TimeCellType = exports.CELL_TYPE = void 0;
+var _timeType = require("./timeType");
+exports.CELL_TYPE = _timeType.CELL_TYPE;
+exports.TimeCellType = _timeType.TimeCellType;

package/cellTypes/timeType/index.mjs

@@ -0,0 +1 @@
+export { CELL_TYPE, TimeCellType } from "./timeType.mjs";

package/cellTypes/timeType/timeType.d.ts

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

package/cellTypes/timeType/timeType.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.__esModule = true;
+exports.TimeCellType = exports.CELL_TYPE = void 0;
+var _timeEditor = require("../../editors/timeEditor");
+var _timeRenderer = require("../../renderers/timeRenderer");
+var _timeValidator = require("../../validators/timeValidator");
+var CELL_TYPE = 'time';
+exports.CELL_TYPE = CELL_TYPE;
+var TimeCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: _timeEditor.TimeEditor,
+  renderer: _timeRenderer.timeRenderer,
+  validator: _timeValidator.timeValidator
+};
+exports.TimeCellType = TimeCellType;

package/cellTypes/timeType/timeType.mjs

@@ -0,0 +1,10 @@
+import { TimeEditor } from "../../editors/timeEditor/index.mjs";
+import { timeRenderer } from "../../renderers/timeRenderer/index.mjs";
+import { timeValidator } from "../../validators/timeValidator/index.mjs";
+export var CELL_TYPE = 'time';
+export var TimeCellType = {
+  CELL_TYPE: CELL_TYPE,
+  editor: TimeEditor,
+  renderer: timeRenderer,
+  validator: timeValidator
+};

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;
+}