handsontable 17.1.0 → 18.0.0-rc2

package/dataMap/metaManager/mods/dynamicCellMeta.d.mts

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

package/dataMap/metaManager/mods/dynamicCellMeta.d.ts

@@ -0,0 +1,57 @@
+import type { default as MetaManagerInstance } from '..';
+/**
+ * @class DynamicCellMetaMod
+ *
+ * The `DynamicCellMetaMod` modifier allows for extending cell meta objects
+ * (returned by `getCellMeta()` from `MetaManager`)
+ * by user-specific properties.
+ *
+ * The user-specific properties can be added and changed dynamically,
+ * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+ * or by Handsontable's `cells` option.
+ *
+ * The `getCellMeta()` method is used widely throughout the source code.
+ * To boost the method's execution time,
+ * the logic is triggered only once per one Handsontable slow render cycle.
+ */
+type MetaManagerWithHot = MetaManagerInstance & {
+    hot: {
+        colToProp: (column: number) => string | number;
+        runHooks: (...args: unknown[]) => unknown;
+        [key: string]: unknown;
+    };
+    addLocalHook: (hookName: string, callback: (...args: unknown[]) => void) => void;
+    updateCellMeta: (...args: unknown[]) => void;
+    [key: string]: unknown;
+};
+/**
+ * Modifier that extends cell meta objects dynamically through Handsontable hooks and the `cells` option,
+ * memoizing results per render cycle to avoid redundant work.
+ */
+export declare class DynamicCellMetaMod {
+    /**
+     * @type {MetaManager}
+     */
+    metaManager: MetaManagerWithHot;
+    /**
+     * @type {Map}
+     */
+    metaSyncMemo: Map<any, any>;
+    /**
+     * Initializes the modifier, registers the `afterGetCellMeta` local hook, and subscribes to `beforeRender` to clear the memo on full renders.
+     */
+    constructor(metaManager: MetaManagerWithHot);
+    /**
+     * Extends the cell meta object by user-specific properties.
+     *
+     * The cell meta object can be extended dynamically,
+     * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
+     * or by Handsontable's `cells` option.
+     *
+     * To boost performance, the extending process is triggered only once per one slow Handsontable render cycle.
+     *
+     * @param {object} cellMeta The cell meta object.
+     */
+    extendCellMeta(cellMeta: Record<string, unknown>): void;
+}
+export {};

package/dataMap/metaManager/mods/dynamicCellMeta.js

@@ -23,11 +23,13 @@ class DynamicCellMetaMod {
    *
    * @param {object} cellMeta The cell meta object.
    */ extendCellMeta(cellMeta) {
-        const { row: physicalRow, col: physicalColumn } = cellMeta;
+        const physicalRow = cellMeta.row;
+        const physicalColumn = cellMeta.col;
         if (this.metaSyncMemo.get(physicalRow)?.has(physicalColumn)) {
             return;
         }
-        const { visualRow, visualCol } = cellMeta;
+        const visualRow = cellMeta.visualRow;
+        const visualCol = cellMeta.visualCol;
         const hot = this.metaManager.hot;
         const prop = hot.colToProp(visualCol);
         cellMeta.prop = prop;
@@ -53,12 +55,16 @@ class DynamicCellMetaMod {
         }
         this.metaSyncMemo.get(physicalRow).add(physicalColumn);
     }
-    constructor(metaManager){
+    /**
+   * Initializes the modifier, registers the `afterGetCellMeta` local hook, and subscribes to `beforeRender` to clear the memo on full renders.
+   */ constructor(metaManager){
         /**
    * @type {Map}
    */ this.metaSyncMemo = new Map();
         this.metaManager = metaManager;
-        metaManager.addLocalHook('afterGetCellMeta', (...args)=>this.extendCellMeta(...args));
+        metaManager.addLocalHook('afterGetCellMeta', (...args)=>{
+            this.extendCellMeta(args[0]);
+        });
         _hooks.Hooks.getSingleton().add('beforeRender', (forceFullRender)=>{
             if (forceFullRender) {
                 this.metaSyncMemo.clear();

package/dataMap/metaManager/mods/dynamicCellMeta.mjs

@@ -2,19 +2,8 @@ import { Hooks } from '../../../core/hooks/index.mjs';
 import { hasOwnProperty } from '../../../helpers/object.mjs';
 import { isFunction } from '../../../helpers/function.mjs';
 /**
- * @class DynamicCellMetaMod
- *
- * The `DynamicCellMetaMod` modifier allows for extending cell meta objects
- * (returned by `getCellMeta()` from `MetaManager`)
- * by user-specific properties.
- *
- * The user-specific properties can be added and changed dynamically,
- * either by Handsontable's hooks (`beforeGetCellMeta` and`afterGetCellMeta`),
- * or by Handsontable's `cells` option.
- *
- * The `getCellMeta()` method is used widely throughout the source code.
- * To boost the method's execution time,
- * the logic is triggered only once per one Handsontable slow render cycle.
+ * Modifier that extends cell meta objects dynamically through Handsontable hooks and the `cells` option,
+ * memoizing results per render cycle to avoid redundant work.
  */ export class DynamicCellMetaMod {
     /**
    * Extends the cell meta object by user-specific properties.
@@ -27,11 +16,13 @@ import { isFunction } from '../../../helpers/function.mjs';
    *
    * @param {object} cellMeta The cell meta object.
    */ extendCellMeta(cellMeta) {
-        const { row: physicalRow, col: physicalColumn } = cellMeta;
+        const physicalRow = cellMeta.row;
+        const physicalColumn = cellMeta.col;
         if (this.metaSyncMemo.get(physicalRow)?.has(physicalColumn)) {
             return;
         }
-        const { visualRow, visualCol } = cellMeta;
+        const visualRow = cellMeta.visualRow;
+        const visualCol = cellMeta.visualCol;
         const hot = this.metaManager.hot;
         const prop = hot.colToProp(visualCol);
         cellMeta.prop = prop;
@@ -57,12 +48,16 @@ import { isFunction } from '../../../helpers/function.mjs';
         }
         this.metaSyncMemo.get(physicalRow).add(physicalColumn);
     }
-    constructor(metaManager){
+    /**
+   * Initializes the modifier, registers the `afterGetCellMeta` local hook, and subscribes to `beforeRender` to clear the memo on full renders.
+   */ constructor(metaManager){
         /**
    * @type {Map}
    */ this.metaSyncMemo = new Map();
         this.metaManager = metaManager;
-        metaManager.addLocalHook('afterGetCellMeta', (...args)=>this.extendCellMeta(...args));
+        metaManager.addLocalHook('afterGetCellMeta', (...args)=>{
+            this.extendCellMeta(args[0]);
+        });
         Hooks.getSingleton().add('beforeRender', (forceFullRender)=>{
             if (forceFullRender) {
                 this.metaSyncMemo.clear();

package/dataMap/metaManager/mods/extendMetaProperties.d.mts

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

package/dataMap/metaManager/mods/extendMetaProperties.d.ts

@@ -0,0 +1,56 @@
+import type { default as MetaManagerInstance } from '..';
+/**
+ * @class ExtendMetaPropertiesMod
+ */
+export declare class ExtendMetaPropertiesMod {
+    #private;
+    /**
+     * @type {MetaManager}
+     */
+    metaManager: MetaManagerInstance & {
+        hot: {
+            isRtl: () => boolean;
+            [key: string]: unknown;
+        };
+        globalMeta: {
+            meta: Record<string, unknown>;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    /**
+     * @type {Set}
+     */
+    usageTracker: Set<unknown>;
+    /**
+     * @type {Map}
+     */
+    propDescriptors: Map<string, Record<string, unknown>>;
+    /**
+     * Initializes the modifier with a reference to the MetaManager and immediately extends the global meta with calculated property values.
+     */
+    constructor(metaManager: MetaManagerInstance & {
+        hot: {
+            isRtl: () => boolean;
+            [key: string]: unknown;
+        };
+        globalMeta: {
+            meta: Record<string, unknown>;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    });
+    /**
+     * Extends the meta options based on the object descriptors from the `propDescriptors` list.
+     */
+    extendMetaProps(): void;
+    /**
+     * Installs the property watcher to the `propName` option and forwards getter and setter to
+     * the new one.
+     *
+     * @param {string} propName The property to watch.
+     * @param {string} origProp The property from/to the value is forwarded.
+     * @param {Function} onChange The callback.
+     */
+    installPropWatcher(propName: string, origProp: string, onChange: (this: unknown, changedPropName: string, value: unknown, isInitialChange: boolean) => void): void;
+}

package/dataMap/metaManager/mods/extendMetaProperties.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "ExtendMetaPropertiesMod", {
         return ExtendMetaPropertiesMod;
     }
 });
-const _console = require("../../../helpers/console");
 const _errors = require("../../../helpers/errors");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
@@ -50,8 +49,6 @@ function _class_private_field_set(receiver, privateMap, value) {
     _class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
-const correctFormatDeprecatedMessageShown = new WeakSet();
-const datePickerConfigDeprecatedMessageShown = new WeakSet();
 var /**
    * Callback called when the prop is marked as `initOnly`.
    *
@@ -91,22 +88,25 @@ class ExtendMetaPropertiesMod {
    * @param {string} origProp The property from/to the value is forwarded.
    * @param {Function} onChange The callback.
    */ installPropWatcher(propName, origProp, onChange) {
-        const self = this;
+        const { usageTracker } = this;
+        const boundOnChange = onChange.bind(this);
         Object.defineProperty(this.metaManager.globalMeta.meta, propName, {
             get () {
                 return this[origProp];
             },
             set (value) {
-                const isInitialChange = !self.usageTracker.has(propName);
-                self.usageTracker.add(propName);
-                onChange.call(self, propName, value, isInitialChange);
+                const isInitialChange = !usageTracker.has(propName);
+                usageTracker.add(propName);
+                boundOnChange(propName, value, isInitialChange);
                 this[origProp] = value;
             },
             enumerable: true,
             configurable: true
         });
     }
-    constructor(metaManager){
+    /**
+   * Initializes the modifier with a reference to the MetaManager and immediately extends the global meta with calculated property values.
+   */ constructor(metaManager){
         _class_private_field_init(this, _initOnlyCallback, {
             writable: true,
             value: void 0
@@ -138,28 +138,6 @@ class ExtendMetaPropertiesMod {
                     }
                 }
             ],
-            [
-                'correctFormat',
-                {
-                    onChange () {
-                        if (!correctFormatDeprecatedMessageShown.has(this.metaManager.hot)) {
-                            correctFormatDeprecatedMessageShown.add(this.metaManager.hot);
-                            (0, _console.deprecatedWarn)('The `correctFormat` option is deprecated and will be removed in the next major release.\n\n' + 'Migration guide: https://handsontable.com/docs/migration-from-16.2-to-17.0/');
-                        }
-                    }
-                }
-            ],
-            [
-                'datePickerConfig',
-                {
-                    onChange () {
-                        if (!datePickerConfigDeprecatedMessageShown.has(this.metaManager.hot)) {
-                            datePickerConfigDeprecatedMessageShown.add(this.metaManager.hot);
-                            (0, _console.deprecatedWarn)('The `datePickerConfig` option is deprecated and will be removed in the next major release.\n\n' + 'Migration guide: https://handsontable.com/docs/migration-from-16.2-to-17.0/');
-                        }
-                    }
-                }
-            ],
             [
                 'layoutDirection',
                 {

package/dataMap/metaManager/mods/extendMetaProperties.mjs

@@ -38,10 +38,7 @@ function _class_private_field_set(receiver, privateMap, value) {
     _class_apply_descriptor_set(receiver, descriptor, value);
     return value;
 }
-import { deprecatedWarn } from '../../../helpers/console.mjs';
 import { throwWithCause } from '../../../helpers/errors.mjs';
-const correctFormatDeprecatedMessageShown = new WeakSet();
-const datePickerConfigDeprecatedMessageShown = new WeakSet();
 var /**
    * Callback called when the prop is marked as `initOnly`.
    *
@@ -83,22 +80,25 @@ var /**
    * @param {string} origProp The property from/to the value is forwarded.
    * @param {Function} onChange The callback.
    */ installPropWatcher(propName, origProp, onChange) {
-        const self = this;
+        const { usageTracker } = this;
+        const boundOnChange = onChange.bind(this);
         Object.defineProperty(this.metaManager.globalMeta.meta, propName, {
             get () {
                 return this[origProp];
             },
             set (value) {
-                const isInitialChange = !self.usageTracker.has(propName);
-                self.usageTracker.add(propName);
-                onChange.call(self, propName, value, isInitialChange);
+                const isInitialChange = !usageTracker.has(propName);
+                usageTracker.add(propName);
+                boundOnChange(propName, value, isInitialChange);
                 this[origProp] = value;
             },
             enumerable: true,
             configurable: true
         });
     }
-    constructor(metaManager){
+    /**
+   * Initializes the modifier with a reference to the MetaManager and immediately extends the global meta with calculated property values.
+   */ constructor(metaManager){
         _class_private_field_init(this, _initOnlyCallback, {
             writable: true,
             value: void 0
@@ -130,28 +130,6 @@ var /**
                     }
                 }
             ],
-            [
-                'correctFormat',
-                {
-                    onChange () {
-                        if (!correctFormatDeprecatedMessageShown.has(this.metaManager.hot)) {
-                            correctFormatDeprecatedMessageShown.add(this.metaManager.hot);
-                            deprecatedWarn('The `correctFormat` option is deprecated and will be removed in the next major release.\n\n' + 'Migration guide: https://handsontable.com/docs/migration-from-16.2-to-17.0/');
-                        }
-                    }
-                }
-            ],
-            [
-                'datePickerConfig',
-                {
-                    onChange () {
-                        if (!datePickerConfigDeprecatedMessageShown.has(this.metaManager.hot)) {
-                            datePickerConfigDeprecatedMessageShown.add(this.metaManager.hot);
-                            deprecatedWarn('The `datePickerConfig` option is deprecated and will be removed in the next major release.\n\n' + 'Migration guide: https://handsontable.com/docs/migration-from-16.2-to-17.0/');
-                        }
-                    }
-                }
-            ],
             [
                 'layoutDirection',
                 {

package/dataMap/metaManager/utils.d.mts

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

package/dataMap/metaManager/utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Expands "type" property of the meta object to single values. For example `type: 'numeric'` sets
+ * "renderer", "editor", "validator" properties to specific functions designed for numeric values.
+ * If "type" is passed as an object that object will be returned, excluding properties that
+ * already exist in the "metaObject".
+ *
+ * The function utilizes `_automaticallyAssignedMetaProps` meta property that allows tracking what
+ * properties are changed by the "type" expanding feature. That properties can be always overwritten by
+ * the user.
+ *
+ * @param {object} metaObject The meta object.
+ * @param {object} settings The settings object with the "type" setting.
+ * @param {object} settingsToCompareWith The object to compare which properties need to be updated.
+ */
+export declare function extendByMetaType(metaObject: Record<string, unknown>, settings: Record<string, unknown>, settingsToCompareWith?: Record<string, unknown>): void;
+/**
+ * Creates new class which extends properties from TableMeta layer class.
+ *
+ * @param {TableMeta} TableMeta The TableMeta which the new ColumnMeta is created from.
+ * @param {string[]} [conflictList] List of the properties which are conflicted with the column meta layer.
+ *                                  Conflicted properties are overwritten by `undefined` value, to separate them
+ *                                  from the TableMeta layer.
+ * @returns {ColumnMeta} Returns constructor ready to initialize with `new` operator.
+ */
+export declare function columnFactory(TableMeta: Function, conflictList?: string[]): () => void;
+/**
+ * Function which makes assertion by custom condition. Function throws an error when assertion doesn't meet the spec.
+ *
+ * @param {Function} condition Function with custom logic. The condition has to return boolean values.
+ * @param {string} errorMessage String which describes assertion error.
+ */
+export declare function assert(condition: () => boolean, errorMessage: string): void;
+/**
+ * Check if given variable is null or undefined.
+ *
+ * @param {*} variable Variable to check.
+ * @returns {boolean}
+ */
+export declare function isNullish(variable: unknown): variable is null | undefined;

package/dataMap/metaManager/utils.js

@@ -40,7 +40,9 @@ const _registry = require("../../cellTypes/registry");
 function extendByMetaType(metaObject, settings, settingsToCompareWith = metaObject) {
     const validType = typeof settings.type === 'string' ? (0, _registry.getCellType)(settings.type) : settings.type;
     if (metaObject._automaticallyAssignedMetaProps) {
-        (0, _object.objectEach)(settings, (value, key)=>void metaObject._automaticallyAssignedMetaProps.delete(key));
+        (0, _object.objectEach)(settings, (_value, key)=>{
+            metaObject._automaticallyAssignedMetaProps.delete(key);
+        });
     }
     if (!(0, _object.isObject)(validType)) {
         return;

package/dataMap/metaManager/utils.mjs

@@ -29,7 +29,9 @@ import { getCellType } from '../../cellTypes/registry.mjs';
  */ export function extendByMetaType(metaObject, settings, settingsToCompareWith = metaObject) {
     const validType = typeof settings.type === 'string' ? getCellType(settings.type) : settings.type;
     if (metaObject._automaticallyAssignedMetaProps) {
-        objectEach(settings, (value, key)=>void metaObject._automaticallyAssignedMetaProps.delete(key));
+        objectEach(settings, (_value, key)=>{
+            metaObject._automaticallyAssignedMetaProps.delete(key);
+        });
     }
     if (!isObject(validType)) {
         return;

package/dataMap/replaceData.d.mts

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

package/dataMap/replaceData.d.ts

@@ -0,0 +1,42 @@
+import type { HotInstance } from '../core/types';
+import type { default as DataSourceInstance } from './dataSource';
+import type { default as MetaManagerInstance } from './metaManager';
+import DataMap from './dataMap';
+/**
+ * Configuration for the replaceData function.
+ */
+interface ReplaceDataConfig {
+    hotInstance: HotInstance;
+    dataMap: DataMap | {
+        destroy(): void;
+        [key: string]: unknown;
+    } | null;
+    dataSource: DataSourceInstance;
+    internalSource: string;
+    source: string;
+    metaManager: MetaManagerInstance;
+    firstRun: boolean | [null, string];
+}
+/**
+ * Loads new data to Handsontable.
+ *
+ * @private
+ * @param {Array} data Array of arrays or array of objects containing data.
+ * @param {Function} setDataMapFunction Function that updates the datamap instance.
+ * @param {Function} callbackFunction Function that takes care of updating Handsontable to the new dataset. Called
+ * right before the `after-` hooks.
+ * @param {object} config The configuration object containing all the needed dependency references and information.
+ * @param {Handsontable.Core} config.hotInstance The Handsontable instance.
+ * @param {DataMap} config.dataMap The current `dataMap` instance.
+ * @param {DataSource} config.dataSource The current `dataSource` instance.
+ * @param {string} config.internalSource The immediate internal source of the `replaceData` call.
+ * @param {string} config.source The source of the call.
+ * @param {boolean} config.firstRun `true` if it's a first call in the Handsontable lifecycle, `false` otherwise.
+ * @fires Hooks#beforeLoadData
+ * @fires Hooks#beforeUpdateData
+ * @fires Hooks#afterLoadData
+ * @fires Hooks#afterUpdateData
+ * @fires Hooks#afterChange
+ */
+declare function replaceData(data: unknown[], setDataMapFunction: (dataMap: DataMap) => void, callbackFunction: (dataMap: DataMap) => void, config: ReplaceDataConfig): void;
+export { replaceData };

package/dataMap/replaceData.js

@@ -21,6 +21,32 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+/**
+ * Builds the initial empty dataset rows when `data` is `null`.
+ *
+ * @param {HotInstance} hotInstance The Handsontable instance.
+ * @param {DataMap} newDataMap The newly created DataMap instance.
+ * @param {object} tableMeta The current table settings.
+ * @returns {unknown[]} The generated data array.
+ */ function buildNullData(hotInstance, newDataMap, tableMeta) {
+    const dataSchema = newDataMap.getSchema();
+    const data = [];
+    for(let r = 0, rlen = tableMeta.startRows; r < rlen; r++){
+        let row;
+        if ((hotInstance.dataType === 'object' || hotInstance.dataType === 'function') && tableMeta.dataSchema) {
+            row = (0, _object.deepClone)(dataSchema);
+        } else if (hotInstance.dataType === 'array') {
+            row = (0, _object.deepClone)(dataSchema[0]);
+        } else {
+            row = [];
+            for(let c = 0, clen = tableMeta.startCols; c < clen; c++){
+                row.push(null);
+            }
+        }
+        data.push(row);
+    }
+    return data;
+}
 /**
  * Loads new data to Handsontable.
  *
@@ -69,27 +95,8 @@ function _interop_require_default(obj) {
             ];
         }
     } else if (data === null) {
-        const dataSchema = newDataMap.getSchema();
         // eslint-disable-next-line no-param-reassign
-        data = [];
-        let row;
-        let r = 0;
-        let rlen = 0;
-        for(r = 0, rlen = tableMeta.startRows; r < rlen; r++){
-            if ((hotInstance.dataType === 'object' || hotInstance.dataType === 'function') && tableMeta.dataSchema) {
-                row = (0, _object.deepClone)(dataSchema);
-                data.push(row);
-            } else if (hotInstance.dataType === 'array') {
-                row = (0, _object.deepClone)(dataSchema[0]);
-                data.push(row);
-            } else {
-                row = [];
-                for(let c = 0, clen = tableMeta.startCols; c < clen; c++){
-                    row.push(null);
-                }
-                data.push(row);
-            }
-        }
+        data = buildNullData(hotInstance, newDataMap, tableMeta);
     } else {
         (0, _errors.throwWithCause)(`${internalSource} only accepts array of objects or array of arrays (${typeof data} given)`);
     }
@@ -100,8 +107,8 @@ function _interop_require_default(obj) {
     newDataMap.dataSource = data;
     dataSource.data = data;
     dataSource.dataType = hotInstance.dataType;
-    dataSource.colToProp = newDataMap.colToProp.bind(newDataMap);
-    dataSource.propToCol = newDataMap.propToCol.bind(newDataMap);
+    dataSource.colToProp = (column)=>newDataMap.colToProp(column);
+    dataSource.propToCol = (prop)=>newDataMap.propToCol(prop);
     dataSource.countCachedColumns = newDataMap.countCachedColumns.bind(newDataMap);
     // Run the logic for reassuring that the table structure fits the new dataset.
     callbackFunction(newDataMap);

package/dataMap/replaceData.mjs

@@ -6,6 +6,32 @@ import { setAttribute } from '../helpers/dom/element.mjs';
 import { A11Y_COLCOUNT, A11Y_ROWCOUNT } from '../helpers/a11y.mjs';
 import { runSourceDataValidators } from './sourceDataValidator.mjs';
 import { throwWithCause } from '../helpers/errors.mjs';
+/**
+ * Builds the initial empty dataset rows when `data` is `null`.
+ *
+ * @param {HotInstance} hotInstance The Handsontable instance.
+ * @param {DataMap} newDataMap The newly created DataMap instance.
+ * @param {object} tableMeta The current table settings.
+ * @returns {unknown[]} The generated data array.
+ */ function buildNullData(hotInstance, newDataMap, tableMeta) {
+    const dataSchema = newDataMap.getSchema();
+    const data = [];
+    for(let r = 0, rlen = tableMeta.startRows; r < rlen; r++){
+        let row;
+        if ((hotInstance.dataType === 'object' || hotInstance.dataType === 'function') && tableMeta.dataSchema) {
+            row = deepClone(dataSchema);
+        } else if (hotInstance.dataType === 'array') {
+            row = deepClone(dataSchema[0]);
+        } else {
+            row = [];
+            for(let c = 0, clen = tableMeta.startCols; c < clen; c++){
+                row.push(null);
+            }
+        }
+        data.push(row);
+    }
+    return data;
+}
 /**
  * Loads new data to Handsontable.
  *
@@ -54,27 +80,8 @@ import { throwWithCause } from '../helpers/errors.mjs';
             ];
         }
     } else if (data === null) {
-        const dataSchema = newDataMap.getSchema();
         // eslint-disable-next-line no-param-reassign
-        data = [];
-        let row;
-        let r = 0;
-        let rlen = 0;
-        for(r = 0, rlen = tableMeta.startRows; r < rlen; r++){
-            if ((hotInstance.dataType === 'object' || hotInstance.dataType === 'function') && tableMeta.dataSchema) {
-                row = deepClone(dataSchema);
-                data.push(row);
-            } else if (hotInstance.dataType === 'array') {
-                row = deepClone(dataSchema[0]);
-                data.push(row);
-            } else {
-                row = [];
-                for(let c = 0, clen = tableMeta.startCols; c < clen; c++){
-                    row.push(null);
-                }
-                data.push(row);
-            }
-        }
+        data = buildNullData(hotInstance, newDataMap, tableMeta);
     } else {
         throwWithCause(`${internalSource} only accepts array of objects or array of arrays (${typeof data} given)`);
     }
@@ -85,8 +92,8 @@ import { throwWithCause } from '../helpers/errors.mjs';
     newDataMap.dataSource = data;
     dataSource.data = data;
     dataSource.dataType = hotInstance.dataType;
-    dataSource.colToProp = newDataMap.colToProp.bind(newDataMap);
-    dataSource.propToCol = newDataMap.propToCol.bind(newDataMap);
+    dataSource.colToProp = (column)=>newDataMap.colToProp(column);
+    dataSource.propToCol = (prop)=>newDataMap.propToCol(prop);
     dataSource.countCachedColumns = newDataMap.countCachedColumns.bind(newDataMap);
     // Run the logic for reassuring that the table structure fits the new dataset.
     callbackFunction(newDataMap);

package/dataMap/sourceDataValidator.d.mts

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

package/dataMap/sourceDataValidator.d.ts

@@ -0,0 +1,16 @@
+type CellMeta = Record<string, unknown> & {
+    sourceDataValidator?: (value: unknown, cellMeta: CellMeta, source?: string) => boolean;
+    sourceDataWarningMessage?: string;
+    allowInvalid?: boolean;
+    row?: number;
+    col?: number;
+};
+/**
+ * Runs source-data validator for a single cell.
+ */
+export declare function runSourceDataValidator(value: unknown, cellMeta: CellMeta, source?: string): boolean;
+/**
+ * Runs source-data validators for all cells and emits one aggregated warning per cell type.
+ */
+export declare function runSourceDataValidators(hotInstance: Record<string, unknown>, source?: string): void;
+export {};

package/dataMap/sourceDataValidator.js

@@ -86,16 +86,14 @@ function runSourceDataValidators(hotInstance, source) {
     });
 }
 /**
- * Logs a source data warning.
  *
- * @param {string} message The message to log.
- * @param {Array} items The list of affected cells.
  */ function logSourceDataWarning(message, items) {
     (0, _console.logAggregatedItems)({
         logFunction: _console.warn,
         message,
         items,
-        itemFormatter: ({ row, col, value })=>{
+        itemFormatter: (item)=>{
+            const { row, col, value } = item;
             const rawValue = (0, _mixed.stringify)(value);
             const shortValue = rawValue.length > 64 ? `${rawValue.slice(0, 64)}...` : rawValue;
             return `row ${row}, col ${col}, value: "${shortValue}"`;