@handsontable/vue3 11.0.0-rc.1

package/commonjs/vue-handsontable.js

@@ -0,0 +1,399 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var Handsontable = require('handsontable/base');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var Handsontable__default = /*#__PURE__*/_interopDefaultLegacy(Handsontable);
+
+var unassignedPropSymbol = Symbol('unassigned');
+/**
+ * Message for the warning thrown if the Handsontable instance has been destroyed.
+ */
+
+var HOT_DESTROYED_WARNING = 'The Handsontable instance bound to this component was destroyed and cannot be' + ' used properly.';
+/**
+ * Check if at specified `key` there is any value for `object`.
+ *
+ * @param {object} object Object to search value at specyfic key.
+ * @param {string} key String key to check.
+ * @returns {boolean}
+ */
+
+function hasOwnProperty(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+/**
+ * Generate an object containing all the available Handsontable properties and plugin hooks.
+ *
+ * @param {string} source Source for the factory (either 'HotTable' or 'HotColumn').
+ * @returns {object}
+ */
+
+function propFactory(source) {
+  var registeredHooks = Handsontable__default["default"].hooks.getRegistered();
+  var propSchema = {};
+  Object.assign(propSchema, Handsontable__default["default"].DefaultSettings); // eslint-disable-next-line no-restricted-syntax, guard-for-in
+
+  for (var prop in propSchema) {
+    propSchema[prop] = {
+      "default": unassignedPropSymbol
+    };
+  }
+
+  for (var i = 0; i < registeredHooks.length; i++) {
+    propSchema[registeredHooks[i]] = {
+      "default": unassignedPropSymbol
+    };
+  }
+
+  propSchema.settings = {
+    "default": unassignedPropSymbol
+  };
+
+  if (source === 'HotTable') {
+    propSchema.id = {
+      type: String,
+      "default": "hot-".concat(Math.random().toString(36).substring(5))
+    };
+  }
+
+  return propSchema;
+}
+/**
+ * Filter out all of the unassigned props, and return only the one passed to the component.
+ *
+ * @param {object} props Object containing all the possible props.
+ * @returns {object} Object containing only used props.
+ */
+
+function filterPassedProps(props) {
+  var filteredProps = {};
+  var columnSettingsProp = props.settings;
+
+  if (columnSettingsProp !== unassignedPropSymbol) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (var propName in columnSettingsProp) {
+      if (hasOwnProperty(columnSettingsProp, propName) && columnSettingsProp[propName] !== unassignedPropSymbol) {
+        filteredProps[propName] = columnSettingsProp[propName];
+      }
+    }
+  } // eslint-disable-next-line no-restricted-syntax
+
+
+  for (var _propName in props) {
+    if (hasOwnProperty(props, _propName) && _propName !== 'settings' && props[_propName] !== unassignedPropSymbol) {
+      filteredProps[_propName] = props[_propName];
+    }
+  }
+
+  return filteredProps;
+}
+/**
+ * Prepare the settings object to be used as the settings for Handsontable, based on the props provided to the component.
+ *
+ * @param {HotTableProps} props The props passed to the component.
+ * @param {Handsontable.GridSettings} currentSettings The current Handsontable settings.
+ * @returns {Handsontable.GridSettings} An object containing the properties, ready to be used within Handsontable.
+ */
+
+function prepareSettings(props, currentSettings) {
+  var assignedProps = filterPassedProps(props);
+  var hotSettingsInProps = props.settings ? props.settings : assignedProps;
+  var additionalHotSettingsInProps = props.settings ? assignedProps : null;
+  var newSettings = {}; // eslint-disable-next-line no-restricted-syntax
+
+  for (var key in hotSettingsInProps) {
+    if (hasOwnProperty(hotSettingsInProps, key) && hotSettingsInProps[key] !== void 0 && (currentSettings && key !== 'data' ? !simpleEqual(currentSettings[key], hotSettingsInProps[key]) : true)) {
+      newSettings[key] = hotSettingsInProps[key];
+    }
+  } // eslint-disable-next-line no-restricted-syntax
+
+
+  for (var _key in additionalHotSettingsInProps) {
+    if (hasOwnProperty(additionalHotSettingsInProps, _key) && _key !== 'id' && _key !== 'settings' && additionalHotSettingsInProps[_key] !== void 0 && (currentSettings && _key !== 'data' ? !simpleEqual(currentSettings[_key], additionalHotSettingsInProps[_key]) : true)) {
+      newSettings[_key] = additionalHotSettingsInProps[_key];
+    }
+  }
+
+  return newSettings;
+}
+/**
+ * Compare two objects using `JSON.stringify`.
+ * *Note: * As it's using the stringify function to compare objects, the property order in both objects is
+ * important. It will return `false` for the same objects, if they're defined in a different order.
+ *
+ * @param {object} objectA First object to compare.
+ * @param {object} objectB Second object to compare.
+ * @returns {boolean} `true` if they're the same, `false` otherwise.
+ */
+
+function simpleEqual(objectA, objectB) {
+  return JSON.stringify(objectA) === JSON.stringify(objectB);
+}
+
+var version="11.0.0-rc.1";
+
+var HotTable = vue.defineComponent({
+  name: 'HotTable',
+  props: propFactory('HotTable'),
+  provide: function provide() {
+    return {
+      columnsCache: this.columnsCache
+    };
+  },
+  watch: {
+    $props: {
+      handler: function handler(props) {
+        var settings = prepareSettings(props, this.hotInstance ? this.hotInstance.getSettings() : void 0);
+
+        if (!this.hotInstance || settings === void 0) {
+          return;
+        }
+
+        if (settings.data) {
+          if (this.hotInstance.isColumnModificationAllowed() || !this.hotInstance.isColumnModificationAllowed() && this.hotInstance.countSourceCols() === this.miscCache.currentSourceColumns) {
+            // If the dataset dimensions change, update the index mappers.
+            this.matchHotMappersSize(); // Data is automatically synchronized by reference.
+
+            delete settings.data;
+          }
+        } // If there are another options changed, update the HOT settings, render the table otherwise.
+
+
+        if (Object.keys(settings).length) {
+          this.hotInstance.updateSettings(settings);
+        } else {
+          this.hotInstance.render();
+        }
+
+        this.miscCache.currentSourceColumns = this.hotInstance.countSourceCols();
+      },
+      deep: true,
+      immediate: true
+    }
+  },
+  data: function data() {
+    return {
+      /* eslint-disable vue/no-reserved-keys */
+      __hotInstance: null,
+
+      /* eslint-enable vue/no-reserved-keys */
+      miscCache: {
+        currentSourceColumns: null
+      },
+      columnSettings: null,
+      columnsCache: new Map(),
+
+      get hotInstance() {
+        if (!this.__hotInstance || this.__hotInstance && !this.__hotInstance.isDestroyed) {
+          // Will return the Handsontable instance or `null` if it's not yet been created.
+          return this.__hotInstance;
+        } else {
+          /* eslint-disable-next-line no-console */
+          console.warn(HOT_DESTROYED_WARNING);
+          return null;
+        }
+      },
+
+      set hotInstance(hotInstance) {
+        this.__hotInstance = hotInstance;
+      }
+
+    };
+  },
+  methods: {
+    /**
+     * Initialize Handsontable.
+     */
+    hotInit: function hotInit() {
+      var newSettings = prepareSettings(this.$props);
+      newSettings.columns = this.columnSettings ? this.columnSettings : newSettings.columns;
+      this.hotInstance = vue.markRaw(new Handsontable__default["default"].Core(this.$el, newSettings));
+      this.hotInstance.init();
+      this.miscCache.currentSourceColumns = this.hotInstance.countSourceCols();
+    },
+    matchHotMappersSize: function matchHotMappersSize() {
+      var _this = this;
+
+      if (!this.hotInstance) {
+        return;
+      }
+
+      var data = this.hotInstance.getSourceData();
+      var rowsToRemove = [];
+      var columnsToRemove = [];
+      var indexMapperRowCount = this.hotInstance.rowIndexMapper.getNumberOfIndexes();
+      var isColumnModificationAllowed = this.hotInstance.isColumnModificationAllowed();
+      var indexMapperColumnCount = 0;
+
+      if (data && data.length !== indexMapperRowCount) {
+        if (data.length < indexMapperRowCount) {
+          for (var r = data.length; r < indexMapperRowCount; r++) {
+            rowsToRemove.push(r);
+          }
+        }
+      }
+
+      if (isColumnModificationAllowed) {
+        var _data$;
+
+        indexMapperColumnCount = this.hotInstance.columnIndexMapper.getNumberOfIndexes();
+
+        if (data && data[0] && ((_data$ = data[0]) === null || _data$ === void 0 ? void 0 : _data$.length) !== indexMapperColumnCount) {
+          if (data[0].length < indexMapperColumnCount) {
+            for (var c = data[0].length; c < indexMapperColumnCount; c++) {
+              columnsToRemove.push(c);
+            }
+          }
+        }
+      }
+
+      this.hotInstance.batch(function () {
+        if (rowsToRemove.length > 0) {
+          _this.hotInstance.rowIndexMapper.removeIndexes(rowsToRemove);
+        } else {
+          _this.hotInstance.rowIndexMapper.insertIndexes(indexMapperRowCount - 1, data.length - indexMapperRowCount);
+        }
+
+        if (isColumnModificationAllowed && data.length !== 0) {
+          if (columnsToRemove.length > 0) {
+            _this.hotInstance.columnIndexMapper.removeIndexes(columnsToRemove);
+          } else {
+            _this.hotInstance.columnIndexMapper.insertIndexes(indexMapperColumnCount - 1, data[0].length - indexMapperColumnCount);
+          }
+        }
+      });
+    },
+
+    /**
+     * Get settings for the columns provided in the `hot-column` components.
+     *
+     * @returns {HotTableProps[] | undefined}
+     */
+    getColumnSettings: function getColumnSettings() {
+      var columnSettings = Array.from(this.columnsCache.values());
+      return columnSettings.length ? columnSettings : void 0;
+    }
+  },
+  mounted: function mounted() {
+    this.columnSettings = this.getColumnSettings();
+    this.hotInit();
+  },
+  beforeUnmount: function beforeUnmount() {
+    if (this.hotInstance) {
+      this.hotInstance.destroy();
+    }
+  },
+  version: version
+});
+
+var _hoisted_1 = ["id"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("div", {
+    id: _ctx.id
+  }, [vue.renderSlot(_ctx.$slots, "default")], 8
+  /* PROPS */
+  , _hoisted_1);
+}
+
+HotTable.render = render;
+HotTable.__file = "src/HotTable.vue";
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+var HotColumn = vue.defineComponent({
+  name: 'HotColumn',
+  props: propFactory('HotColumn'),
+  inject: ['columnsCache'],
+  methods: {
+    /**
+     * Create the column settings based on the data provided to the `hot-column`
+     * component and it's child components.
+     */
+    createColumnSettings: function createColumnSettings() {
+      var assignedProps = filterPassedProps(this.$props);
+
+      var columnSettings = _objectSpread2({}, assignedProps);
+
+      if (assignedProps.renderer) {
+        columnSettings.renderer = assignedProps.renderer;
+      }
+
+      if (assignedProps.editor) {
+        columnSettings.editor = assignedProps.editor;
+      }
+
+      this.columnsCache.set(this, columnSettings);
+    }
+  },
+  mounted: function mounted() {
+    this.createColumnSettings();
+  },
+  unmounted: function unmounted() {
+    this.columnsCache["delete"](this);
+  },
+  render: function render() {
+    return null;
+  }
+});
+
+HotColumn.__file = "src/HotColumn.vue";
+
+exports.HotColumn = HotColumn;
+exports.HotTable = HotTable;
+exports["default"] = HotTable;

package/dist/HotColumn.vue.d.ts

@@ -0,0 +1,321 @@
+declare const HotColumn: import("vue").DefineComponent<import("./types").VueProps<import("./types").HotTableProps>, unknown, unknown, {}, {
+    /**
+     * Create the column settings based on the data provided to the `hot-column`
+     * component and it's child components.
+     */
+    createColumnSettings(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    [x: string]: unknown;
+    id?: unknown;
+    settings?: unknown;
+    activeHeaderClassName?: unknown;
+    allowEmpty?: unknown;
+    allowHtml?: unknown;
+    allowInsertColumn?: unknown;
+    allowInsertRow?: unknown;
+    allowInvalid?: unknown;
+    allowRemoveColumn?: unknown;
+    allowRemoveRow?: unknown;
+    autoColumnSize?: unknown;
+    autoRowSize?: unknown;
+    autoWrapCol?: unknown;
+    autoWrapRow?: unknown;
+    bindRowsWithHeaders?: unknown;
+    cell?: unknown;
+    cells?: unknown;
+    checkedTemplate?: unknown;
+    className?: unknown;
+    colHeaders?: unknown;
+    collapsibleColumns?: unknown;
+    columnHeaderHeight?: unknown;
+    columns?: unknown;
+    columnSorting?: unknown;
+    columnSummary?: unknown;
+    colWidths?: unknown;
+    commentedCellClassName?: unknown;
+    comments?: unknown;
+    contextMenu?: unknown;
+    copyable?: unknown;
+    copyPaste?: unknown;
+    correctFormat?: unknown;
+    currentColClassName?: unknown;
+    currentHeaderClassName?: unknown;
+    currentRowClassName?: unknown;
+    customBorders?: unknown;
+    data?: unknown;
+    dataSchema?: unknown;
+    dateFormat?: unknown;
+    datePickerConfig?: unknown;
+    defaultDate?: unknown;
+    disableVisualSelection?: unknown;
+    dragToScroll?: unknown;
+    dropdownMenu?: unknown;
+    editor?: unknown;
+    enterBeginsEditing?: unknown;
+    enterMoves?: unknown;
+    fillHandle?: unknown;
+    filter?: unknown;
+    filteringCaseSensitive?: unknown;
+    filters?: unknown;
+    fixedColumnsLeft?: unknown;
+    fixedRowsBottom?: unknown;
+    fixedRowsTop?: unknown;
+    formulas?: unknown;
+    fragmentSelection?: unknown;
+    height?: unknown;
+    hiddenColumns?: unknown;
+    hiddenRows?: unknown;
+    invalidCellClassName?: unknown;
+    isEmptyCol?: unknown;
+    isEmptyRow?: unknown;
+    label?: unknown;
+    language?: unknown;
+    licenseKey?: unknown;
+    manualColumnFreeze?: unknown;
+    manualColumnMove?: unknown;
+    manualColumnResize?: unknown;
+    manualRowMove?: unknown;
+    manualRowResize?: unknown;
+    maxCols?: unknown;
+    maxRows?: unknown;
+    mergeCells?: unknown;
+    minCols?: unknown;
+    minRows?: unknown;
+    minSpareCols?: unknown;
+    minSpareRows?: unknown;
+    multiColumnSorting?: unknown;
+    nestedHeaders?: unknown;
+    nestedRows?: unknown;
+    noWordWrapClassName?: unknown;
+    numericFormat?: unknown;
+    observeDOMVisibility?: unknown;
+    outsideClickDeselects?: unknown;
+    persistentState?: unknown;
+    placeholder?: unknown;
+    placeholderCellClassName?: unknown;
+    preventOverflow?: unknown;
+    preventWheel?: unknown;
+    readOnly?: unknown;
+    readOnlyCellClassName?: unknown;
+    renderAllRows?: unknown;
+    renderer?: unknown;
+    rowHeaders?: unknown;
+    rowHeaderWidth?: unknown;
+    rowHeights?: unknown;
+    search?: unknown;
+    selectionMode?: unknown;
+    selectOptions?: unknown;
+    skipColumnOnPaste?: unknown;
+    skipRowOnPaste?: unknown;
+    sortByRelevance?: unknown;
+    source?: unknown;
+    startCols?: unknown;
+    startRows?: unknown;
+    stretchH?: unknown;
+    strict?: unknown;
+    tableClassName?: unknown;
+    tabMoves?: unknown;
+    title?: unknown;
+    trimDropdown?: unknown;
+    trimRows?: unknown;
+    trimWhitespace?: unknown;
+    type?: unknown;
+    uncheckedTemplate?: unknown;
+    undo?: unknown;
+    validator?: unknown;
+    viewportColumnRenderingOffset?: unknown;
+    viewportRowRenderingOffset?: unknown;
+    visibleRows?: unknown;
+    width?: unknown;
+    wordWrap?: unknown;
+    afterAddChild?: unknown;
+    afterAutofill?: unknown;
+    afterBeginEditing?: unknown;
+    afterCellMetaReset?: unknown;
+    afterChange?: unknown;
+    afterChangesObserved?: unknown;
+    afterColumnCollapse?: unknown;
+    afterColumnExpand?: unknown;
+    afterColumnMove?: unknown;
+    afterColumnResize?: unknown;
+    afterColumnSort?: unknown;
+    afterContextMenuDefaultOptions?: unknown;
+    afterContextMenuHide?: unknown;
+    afterContextMenuShow?: unknown;
+    afterCopy?: unknown;
+    afterCopyLimit?: unknown;
+    afterCreateCol?: unknown;
+    afterCreateRow?: unknown;
+    afterCut?: unknown;
+    afterDeselect?: unknown;
+    afterDestroy?: unknown;
+    afterDetachChild?: unknown;
+    afterDocumentKeyDown?: unknown;
+    afterDrawSelection?: unknown;
+    afterDropdownMenuDefaultOptions?: unknown;
+    afterDropdownMenuHide?: unknown;
+    afterDropdownMenuShow?: unknown;
+    afterFilter?: unknown;
+    afterFormulasValuesUpdate?: unknown;
+    afterGetCellMeta?: unknown;
+    afterGetColHeader?: unknown;
+    afterGetColumnHeaderRenderers?: unknown;
+    afterGetRowHeader?: unknown;
+    afterGetRowHeaderRenderers?: unknown;
+    afterHideColumns?: unknown;
+    afterHideRows?: unknown;
+    afterInit?: unknown;
+    afterLanguageChange?: unknown;
+    afterListen?: unknown;
+    afterLoadData?: unknown;
+    afterMergeCells?: unknown;
+    afterModifyTransformEnd?: unknown;
+    afterModifyTransformStart?: unknown;
+    afterMomentumScroll?: unknown;
+    afterNamedExpressionAdded?: unknown;
+    afterNamedExpressionRemoved?: unknown;
+    afterOnCellContextMenu?: unknown;
+    afterOnCellCornerDblClick?: unknown;
+    afterOnCellCornerMouseDown?: unknown;
+    afterOnCellMouseDown?: unknown;
+    afterOnCellMouseOver?: unknown;
+    afterOnCellMouseOut?: unknown;
+    afterOnCellMouseUp?: unknown;
+    afterPaste?: unknown;
+    afterPluginsInitialized?: unknown;
+    afterRedo?: unknown;
+    afterRedoStackChange?: unknown;
+    afterRefreshDimensions?: unknown;
+    afterRemoveCellMeta?: unknown;
+    afterRemoveCol?: unknown;
+    afterRemoveRow?: unknown;
+    afterRender?: unknown;
+    afterRenderer?: unknown;
+    afterRowMove?: unknown;
+    afterRowResize?: unknown;
+    afterScrollHorizontally?: unknown;
+    afterScrollVertically?: unknown;
+    afterSelection?: unknown;
+    afterSelectionByProp?: unknown;
+    afterSelectionEnd?: unknown;
+    afterSelectionEndByProp?: unknown;
+    afterSetCellMeta?: unknown;
+    afterSetData?: unknown;
+    afterSetDataAtCell?: unknown;
+    afterSetDataAtRowProp?: unknown;
+    afterSetSourceDataAtCell?: unknown;
+    afterSheetAdded?: unknown;
+    afterSheetRemoved?: unknown;
+    afterSheetRenamed?: unknown;
+    afterTrimRow?: unknown;
+    afterUndo?: unknown;
+    afterUndoStackChange?: unknown;
+    afterUnhideColumns?: unknown;
+    afterUnhideRows?: unknown;
+    afterUnlisten?: unknown;
+    afterUnmergeCells?: unknown;
+    afterUntrimRow?: unknown;
+    afterUpdateData?: unknown;
+    afterUpdateSettings?: unknown;
+    afterValidate?: unknown;
+    afterViewportColumnCalculatorOverride?: unknown;
+    afterViewportRowCalculatorOverride?: unknown;
+    afterViewRender?: unknown;
+    beforeAddChild?: unknown;
+    beforeAutofill?: unknown;
+    beforeAutofillInsidePopulate?: unknown;
+    beforeCellAlignment?: unknown;
+    beforeChange?: unknown;
+    beforeChangeRender?: unknown;
+    beforeColumnCollapse?: unknown;
+    beforeColumnExpand?: unknown;
+    beforeColumnMove?: unknown;
+    beforeColumnResize?: unknown;
+    beforeColumnSort?: unknown;
+    beforeContextMenuSetItems?: unknown;
+    beforeContextMenuShow?: unknown;
+    beforeCopy?: unknown;
+    beforeCreateCol?: unknown;
+    beforeCreateRow?: unknown;
+    beforeCut?: unknown;
+    beforeDetachChild?: unknown;
+    beforeDrawBorders?: unknown;
+    beforeDropdownMenuSetItems?: unknown;
+    beforeDropdownMenuShow?: unknown;
+    beforeFilter?: unknown;
+    beforeGetCellMeta?: unknown;
+    beforeHideColumns?: unknown;
+    beforeHideRows?: unknown;
+    beforeHighlightingColumnHeader?: unknown;
+    beforeHighlightingRowHeader?: unknown;
+    beforeInit?: unknown;
+    beforeInitWalkontable?: unknown;
+    beforeKeyDown?: unknown;
+    beforeLanguageChange?: unknown;
+    beforeLoadData?: unknown;
+    beforeMergeCells?: unknown;
+    beforeOnCellContextMenu?: unknown;
+    beforeOnCellMouseDown?: unknown;
+    beforeOnCellMouseOut?: unknown;
+    beforeOnCellMouseOver?: unknown;
+    beforeOnCellMouseUp?: unknown;
+    beforePaste?: unknown;
+    beforeRedo?: unknown;
+    beforeRedoStackChange?: unknown;
+    beforeRefreshDimensions?: unknown;
+    beforeRemoveCellClassNames?: unknown;
+    beforeRemoveCellMeta?: unknown;
+    beforeRemoveCol?: unknown;
+    beforeRemoveRow?: unknown;
+    beforeRender?: unknown;
+    beforeRenderer?: unknown;
+    beforeRowMove?: unknown;
+    beforeRowResize?: unknown;
+    beforeSetCellMeta?: unknown;
+    beforeSetData?: unknown;
+    beforeSetRangeEnd?: unknown;
+    beforeSetRangeStart?: unknown;
+    beforeSetRangeStartOnly?: unknown;
+    beforeStretchingColumnWidth?: unknown;
+    beforeTouchScroll?: unknown;
+    beforeTrimRow?: unknown;
+    beforeUndo?: unknown;
+    beforeUndoStackChange?: unknown;
+    beforeUnhideColumns?: unknown;
+    beforeUnhideRows?: unknown;
+    beforeUnmergeCells?: unknown;
+    beforeUntrimRow?: unknown;
+    beforeUpdateData?: unknown;
+    beforeValidate?: unknown;
+    beforeValueRender?: unknown;
+    beforeViewRender?: unknown;
+    construct?: unknown;
+    init?: unknown;
+    modifyAutoColumnSizeSeed?: unknown;
+    modifyAutofillRange?: unknown;
+    modifyColHeader?: unknown;
+    modifyColumnHeaderHeight?: unknown;
+    modifyColWidth?: unknown;
+    modifyCopyableRange?: unknown;
+    modifyData?: unknown;
+    modifyGetCellCoords?: unknown;
+    modifyRowData?: unknown;
+    modifyRowHeader?: unknown;
+    modifyRowHeaderWidth?: unknown;
+    modifyRowHeight?: unknown;
+    modifyRowSourceData?: unknown;
+    modifySourceData?: unknown;
+    modifyTransformEnd?: unknown;
+    modifyTransformStart?: unknown;
+    persistentStateLoad?: unknown;
+    persistentStateReset?: unknown;
+    persistentStateSave?: unknown;
+} & {
+    [x: string]: any;
+} & {
+    [x: number]: any;
+}>, {
+    [x: string]: any;
+}>;
+export default HotColumn;
+export { HotColumn };