handsontable 18.0.0 → 18.1.0-rc7

package/helpers/array.mjs

@@ -185,6 +185,51 @@
  */ export function arrayFlatten(array) {
     return arrayReduce(array, (initial, value)=>initial.concat(Array.isArray(value) ? arrayFlatten(value) : value), []);
 }
+/**
+ * Removes the elements at the given indexes from the array. The array is compacted in one
+ * pass and mutated in place, so external references to it stay valid. Cost is O(array length)
+ * regardless of how many indexes are removed - unlike one `splice` call per removed index,
+ * which re-shifts the tail every time.
+ *
+ * @param {Array} array The array to mutate.
+ * @param {Set<number>} indexes The indexes of the elements to remove.
+ * @returns {Array} Returns the same, mutated array.
+ */ export function removeIndexesInPlace(array, indexes) {
+    let writeIndex = 0;
+    for(let readIndex = 0; readIndex < array.length; readIndex++){
+        if (!indexes.has(readIndex)) {
+            array[writeIndex] = array[readIndex];
+            writeIndex += 1;
+        }
+    }
+    array.length = writeIndex;
+    return array;
+}
+/**
+ * Inserts `amount` copies of `value` into the array at the given index. The tail is shifted
+ * right once by `amount` and the array is mutated in place, so external references to it stay
+ * valid. An index greater than the array length is clamped to it (the values are appended),
+ * matching `Array.prototype.splice` semantics. Cost is O(array length + amount) regardless of
+ * `amount` - unlike one `splice` call per inserted value, which re-shifts the tail every time.
+ *
+ * @param {Array} array The array to mutate.
+ * @param {number} index The index at which to insert the values.
+ * @param {number} amount The number of copies to insert.
+ * @param {*} value The value to insert.
+ * @returns {Array} Returns the same, mutated array.
+ */ export function insertValuesInPlace(array, index, amount, value) {
+    if (amount <= 0) {
+        return array;
+    }
+    const oldLength = array.length;
+    const insertAt = Math.min(index, oldLength);
+    array.length = oldLength + amount;
+    for(let i = oldLength - 1; i >= insertAt; i--){
+        array[i + amount] = array[i];
+    }
+    array.fill(value, insertAt, insertAt + amount);
+    return array;
+}
 /**
  * Unique values in the array.
  *
@@ -192,8 +237,10 @@
  * @returns {Array}
  */ export function arrayUnique(array) {
     const unique = [];
+    const seen = new Set();
     arrayEach(array, (value)=>{
-        if (unique.indexOf(value) === -1) {
+        if (!seen.has(value)) {
+            seen.add(value);
             unique.push(value);
         }
     });
@@ -210,7 +257,8 @@
     ];
     let filteredFirstArray = first;
     arrayEach(rest, (array)=>{
-        filteredFirstArray = filteredFirstArray.filter((value)=>!array.includes(value));
+        const lookup = new Set(array);
+        filteredFirstArray = filteredFirstArray.filter((value)=>!lookup.has(value));
     });
     return filteredFirstArray;
 }
@@ -231,11 +279,15 @@
             arrays.push(arg);
         }
     });
-    const isMatch = comparator ? (value, array)=>array.some((item)=>comparator(value, item)) : (value, array)=>array.includes(value);
     const [first, ...rest] = arrays;
     let filteredFirstArray = first;
     arrayEach(rest, (array)=>{
-        filteredFirstArray = filteredFirstArray.filter((value)=>isMatch(value, array));
+        if (comparator) {
+            filteredFirstArray = filteredFirstArray.filter((value)=>array.some((item)=>comparator(value, item)));
+        } else {
+            const lookup = new Set(array);
+            filteredFirstArray = filteredFirstArray.filter((value)=>lookup.has(value));
+        }
     });
     return filteredFirstArray;
 }

package/helpers/console.d.ts

@@ -13,7 +13,7 @@ export declare function warn(...args: unknown[]): void;
 /**
  * Logs a warning to the console only once per `scope` and `key` pair.
  *
- * Pass a stable per-instance object (for example, `hot.rootGridElement`) as the
+ * Pass a stable per-instance object (for example, `hot.rootElement`) as the
  * `scope` so each Handsontable instance warns at most once for a given `key`.
  * Reuse the same `key` across unrelated modules to collapse their warnings into
  * a single message per instance.
@@ -24,11 +24,33 @@ export declare function warn(...args: unknown[]): void;
  */
 export declare function warnOnce(scope: object, key: string, ...args: unknown[]): void;
 /**
- * Logs deprecated warn to the console if the `console` object is exposed.
+ * Logs a deprecation warning to the console only once per `key` if the `console`
+ * object is exposed. Use it for every deprecated public API so the warning does
+ * not flood the console on repeated calls.
  *
+ * @param {string} key A stable identifier of the deprecated API (for example, the method name).
  * @param {string} message The message to log.
  */
-export declare function deprecatedWarn(message: string): void;
+export declare function deprecatedWarnOnce(key: string, message: string): void;
+/**
+ * Logs a removal warning to the console only once per `key` if the `console` object is exposed.
+ * Use it when a caller configures an API that no longer exists. Unlike `deprecatedWarnOnce`, the
+ * message carries no `Deprecated:` prefix: a removed API is not deprecated, it is gone, and the
+ * message itself has to say so (the same way the removed-hook warning in `core/hooks` does).
+ *
+ * @param {string} key A stable identifier of the removed API (for example, the option name).
+ * @param {string} message The message to log.
+ */
+export declare function removedWarnOnce(key: string, message: string): void;
+/**
+ * Clears the record of already-printed deprecation and removal warnings.
+ *
+ * Test-only. `printedDeprecations` is module-global and never reset in production, so without this
+ * every spec that asserts on one of these warnings would depend on the order the specs run in.
+ *
+ * @private
+ */
+export declare function _resetDeprecationWarnings(): void;
 /**
  * Logs info to the console if the `console` object is exposed.
  *

package/helpers/console.js

@@ -9,8 +9,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get deprecatedWarn () {
-        return deprecatedWarn;
+    get _resetDeprecationWarnings () {
+        return _resetDeprecationWarnings;
+    },
+    get deprecatedWarnOnce () {
+        return deprecatedWarnOnce;
     },
     get error () {
         return error;
@@ -24,6 +27,9 @@ _export(exports, {
     get logAggregatedItems () {
         return logAggregatedItems;
     },
+    get removedWarnOnce () {
+        return removedWarnOnce;
+    },
     get warn () {
         return warn;
     },
@@ -31,7 +37,7 @@ _export(exports, {
         return warnOnce;
     }
 });
-const _string = require("./string");
+const _templateString = require("./templateString");
 const _mixed = require("./mixed");
 function log(...args) {
     if ((0, _mixed.isDefined)(console)) {
@@ -61,10 +67,37 @@ function warnOnce(scope, key, ...args) {
     warnedKeys.add(key);
     warn(...args);
 }
-function deprecatedWarn(message) {
-    if ((0, _mixed.isDefined)(console)) {
-        console.warn(`Deprecated: ${message}`);
+/**
+ * Keys of deprecation and removal warnings that were already printed. Module-level on purpose:
+ * a deprecated or removed API is reported once per page, regardless of how many grid instances
+ * touch it, which is what the deprecation policy promises.
+ */ const printedDeprecations = new Set();
+/**
+ * Logs `message` to the console only once per `key` if the `console` object is exposed.
+ * Shared by the deprecation and removal warnings, so both draw from one record and one reset.
+ *
+ * @param {string} key A stable identifier of the reported API.
+ * @param {string} message The final message to log.
+ */ function warnOncePerKey(key, message) {
+    if (printedDeprecations.has(key)) {
+        return;
     }
+    // Record the key only when the message can actually be printed. Otherwise the first call made
+    // while `console` is missing would burn the key for the whole page and silence every later one.
+    if (!(0, _mixed.isDefined)(console)) {
+        return;
+    }
+    printedDeprecations.add(key);
+    console.warn(message);
+}
+function deprecatedWarnOnce(key, message) {
+    warnOncePerKey(key, `Deprecated: ${message}`);
+}
+function removedWarnOnce(key, message) {
+    warnOncePerKey(key, message);
+}
+function _resetDeprecationWarnings() {
+    printedDeprecations.clear();
 }
 function info(...args) {
     if ((0, _mixed.isDefined)(console)) {
@@ -90,7 +123,7 @@ function logAggregatedItems({ logFunction = log, message = '', items = [], maxSa
             more
         ] : []
     ].join('\n');
-    logFunction((0, _string.substitute)(message, {
+    logFunction((0, _templateString.substitute)(message, {
         itemsCount: `${count} cell${count > 1 ? 's' : ''}`,
         affectedCells: affectedLines
     }));

package/helpers/console.mjs

@@ -1,4 +1,4 @@
-import { substitute } from './string.mjs';
+import { substitute } from './templateString.mjs';
 /* eslint-disable no-console */ /* eslint-disable no-restricted-globals */ /**
  * "In Internet Explorer 9 (and 8), the console object is only exposed when the developer tools are opened
  * for a particular tab.".
@@ -32,7 +32,7 @@ import { substitute } from './string.mjs';
 /**
  * Logs a warning to the console only once per `scope` and `key` pair.
  *
- * Pass a stable per-instance object (for example, `hot.rootGridElement`) as the
+ * Pass a stable per-instance object (for example, `hot.rootElement`) as the
  * `scope` so each Handsontable instance warns at most once for a given `key`.
  * Reuse the same `key` across unrelated modules to collapse their warnings into
  * a single message per instance.
@@ -53,13 +53,58 @@ import { substitute } from './string.mjs';
     warn(...args);
 }
 /**
- * Logs deprecated warn to the console if the `console` object is exposed.
+ * Keys of deprecation and removal warnings that were already printed. Module-level on purpose:
+ * a deprecated or removed API is reported once per page, regardless of how many grid instances
+ * touch it, which is what the deprecation policy promises.
+ */ const printedDeprecations = new Set();
+/**
+ * Logs `message` to the console only once per `key` if the `console` object is exposed.
+ * Shared by the deprecation and removal warnings, so both draw from one record and one reset.
  *
- * @param {string} message The message to log.
- */ export function deprecatedWarn(message) {
-    if (isDefined(console)) {
-        console.warn(`Deprecated: ${message}`);
+ * @param {string} key A stable identifier of the reported API.
+ * @param {string} message The final message to log.
+ */ function warnOncePerKey(key, message) {
+    if (printedDeprecations.has(key)) {
+        return;
     }
+    // Record the key only when the message can actually be printed. Otherwise the first call made
+    // while `console` is missing would burn the key for the whole page and silence every later one.
+    if (!isDefined(console)) {
+        return;
+    }
+    printedDeprecations.add(key);
+    console.warn(message);
+}
+/**
+ * Logs a deprecation warning to the console only once per `key` if the `console`
+ * object is exposed. Use it for every deprecated public API so the warning does
+ * not flood the console on repeated calls.
+ *
+ * @param {string} key A stable identifier of the deprecated API (for example, the method name).
+ * @param {string} message The message to log.
+ */ export function deprecatedWarnOnce(key, message) {
+    warnOncePerKey(key, `Deprecated: ${message}`);
+}
+/**
+ * Logs a removal warning to the console only once per `key` if the `console` object is exposed.
+ * Use it when a caller configures an API that no longer exists. Unlike `deprecatedWarnOnce`, the
+ * message carries no `Deprecated:` prefix: a removed API is not deprecated, it is gone, and the
+ * message itself has to say so (the same way the removed-hook warning in `core/hooks` does).
+ *
+ * @param {string} key A stable identifier of the removed API (for example, the option name).
+ * @param {string} message The message to log.
+ */ export function removedWarnOnce(key, message) {
+    warnOncePerKey(key, message);
+}
+/**
+ * Clears the record of already-printed deprecation and removal warnings.
+ *
+ * Test-only. `printedDeprecations` is module-global and never reset in production, so without this
+ * every spec that asserts on one of these warnings would depend on the order the specs run in.
+ *
+ * @private
+ */ export function _resetDeprecationWarnings() {
+    printedDeprecations.clear();
 }
 /**
  * Logs info to the console if the `console` object is exposed.

package/helpers/dateTime.d.ts

@@ -26,6 +26,20 @@ export declare function parseToLocalTime(value: unknown): Date | null;
  * Checks if a string is a valid time in HH:mm, HH:mm:ss, or HH:mm:ss.SSS format.
  */
 export declare function isValidTime(value: unknown): value is string;
+/**
+ * ISO 8601 date-time pattern. The date part is required; the time part is optional and may use a
+ * `T` or space separator, with optional seconds and fractional seconds (`YYYY-MM-DD`,
+ * `YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:ss`, `YYYY-MM-DD HH:mm:ss.SSS`).
+ */
+export declare const ISO_DATETIME_REGEX: RegExp;
+/**
+ * Parses an ISO 8601 date-time string to a local Date. Date-only values become local midnight.
+ */
+export declare function parseToLocalDateTime(value: unknown): Date | null;
+/**
+ * Checks if a string is a valid ISO 8601 date-time, enforcing the day-of-month calendar bound.
+ */
+export declare function isValidISODateTime(value: unknown): value is string;
 /**
  * Returns a Date at local midnight for today.
  *

package/helpers/dateTime.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get ISO_DATETIME_REGEX () {
+        return ISO_DATETIME_REGEX;
+    },
     get ISO_DATE_REGEX () {
         return ISO_DATE_REGEX;
     },
@@ -30,12 +33,18 @@ _export(exports, {
     get isValidISODate () {
         return isValidISODate;
     },
+    get isValidISODateTime () {
+        return isValidISODateTime;
+    },
     get isValidTime () {
         return isValidTime;
     },
     get parseToLocalDate () {
         return parseToLocalDate;
     },
+    get parseToLocalDateTime () {
+        return parseToLocalDateTime;
+    },
     get parseToLocalTime () {
         return parseToLocalTime;
     }
@@ -59,12 +68,41 @@ function parseToLocalDate(value) {
     }
     return null;
 }
+/**
+ * Number of days in each month for a non-leap year, indexed by zero-based month.
+ */ const DAYS_IN_MONTH = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+/**
+ * Checks if a year is a leap year in the proleptic Gregorian calendar.
+ */ function isLeapYear(year) {
+    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
 function isValidISODate(value) {
     if (typeof value !== 'string' || !ISO_DATE_REGEX.test(value)) {
         return false;
     }
-    const date = new Date(value);
-    return !Number.isNaN(date.getTime()) && value === date.toISOString().slice(0, 10);
+    // The regex guarantees the YYYY-MM-DD shape with month 01-12 and day 01-31. The only remaining
+    // check is the calendar bound: that the day fits the given month and year (e.g. rejecting 02-30,
+    // 04-31, or 02-29 in a non-leap year). Doing this arithmetically avoids constructing a Date and
+    // round-tripping through toISOString() for every cell, which dominated load time on large
+    // date-typed grids.
+    const year = +value.slice(0, 4);
+    const month = +value.slice(5, 7);
+    const day = +value.slice(8, 10);
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
 }
 const TIME_REGEX = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?$/;
 function parseToLocalTime(value) {
@@ -88,6 +126,40 @@ function parseToLocalTime(value) {
 function isValidTime(value) {
     return typeof value === 'string' && TIME_REGEX.test(value);
 }
+const ISO_DATETIME_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(?:[T ]([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?)?$/;
+function parseToLocalDateTime(value) {
+    if ((0, _mixed.isEmpty)(value)) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return null;
+    }
+    const [datePart] = value.split(/[T ]/);
+    const [year, month, day] = datePart.split('-').map(Number);
+    const hours = match[3] !== undefined ? Number(match[3]) : 0;
+    const minutes = match[4] !== undefined ? Number(match[4]) : 0;
+    const seconds = match[5] !== undefined ? Number(match[5]) : 0;
+    const milliseconds = match[6] !== undefined ? Number(match[6].padEnd(3, '0').slice(0, 3)) : 0;
+    return new Date(year, month - 1, day, hours, minutes, seconds, milliseconds);
+}
+function isValidISODateTime(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return false;
+    }
+    const year = +value.slice(0, 4);
+    const month = +match[1];
+    const day = +match[2];
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
+}
 function getTodayLocalDate() {
     const now = new Date();
     return new Date(now.getFullYear(), now.getMonth(), now.getDate());

package/helpers/dateTime.mjs

@@ -23,14 +23,43 @@ import { isEmpty } from './mixed.mjs';
     }
     return null;
 }
+/**
+ * Number of days in each month for a non-leap year, indexed by zero-based month.
+ */ const DAYS_IN_MONTH = [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+/**
+ * Checks if a year is a leap year in the proleptic Gregorian calendar.
+ */ function isLeapYear(year) {
+    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
 /**
  * Checks if a string is a valid ISO 8601 date.
  */ export function isValidISODate(value) {
     if (typeof value !== 'string' || !ISO_DATE_REGEX.test(value)) {
         return false;
     }
-    const date = new Date(value);
-    return !Number.isNaN(date.getTime()) && value === date.toISOString().slice(0, 10);
+    // The regex guarantees the YYYY-MM-DD shape with month 01-12 and day 01-31. The only remaining
+    // check is the calendar bound: that the day fits the given month and year (e.g. rejecting 02-30,
+    // 04-31, or 02-29 in a non-leap year). Doing this arithmetically avoids constructing a Date and
+    // round-tripping through toISOString() for every cell, which dominated load time on large
+    // date-typed grids.
+    const year = +value.slice(0, 4);
+    const month = +value.slice(5, 7);
+    const day = +value.slice(8, 10);
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
 }
 /**
  * Time pattern: HH:mm, HH:mm:ss, or HH:mm:ss.SSS (24-hour).
@@ -60,6 +89,48 @@ import { isEmpty } from './mixed.mjs';
  */ export function isValidTime(value) {
     return typeof value === 'string' && TIME_REGEX.test(value);
 }
+/**
+ * ISO 8601 date-time pattern. The date part is required; the time part is optional and may use a
+ * `T` or space separator, with optional seconds and fractional seconds (`YYYY-MM-DD`,
+ * `YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:ss`, `YYYY-MM-DD HH:mm:ss.SSS`).
+ */ export const ISO_DATETIME_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(?:[T ]([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d)(?:\.(\d{1,3}))?)?)?$/;
+/**
+ * Parses an ISO 8601 date-time string to a local Date. Date-only values become local midnight.
+ */ export function parseToLocalDateTime(value) {
+    if (isEmpty(value)) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return null;
+    }
+    const [datePart] = value.split(/[T ]/);
+    const [year, month, day] = datePart.split('-').map(Number);
+    const hours = match[3] !== undefined ? Number(match[3]) : 0;
+    const minutes = match[4] !== undefined ? Number(match[4]) : 0;
+    const seconds = match[5] !== undefined ? Number(match[5]) : 0;
+    const milliseconds = match[6] !== undefined ? Number(match[6].padEnd(3, '0').slice(0, 3)) : 0;
+    return new Date(year, month - 1, day, hours, minutes, seconds, milliseconds);
+}
+/**
+ * Checks if a string is a valid ISO 8601 date-time, enforcing the day-of-month calendar bound.
+ */ export function isValidISODateTime(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const match = ISO_DATETIME_REGEX.exec(value);
+    if (!match) {
+        return false;
+    }
+    const year = +value.slice(0, 4);
+    const month = +match[1];
+    const day = +match[2];
+    const maxDay = month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+    return day <= maxDay;
+}
 /**
  * Returns a Date at local midnight for today.
  *