handsontable 18.0.0 → 18.1.0-rc7

package/utils/entitlementLicenseKey/sha512.mjs

@@ -0,0 +1,327 @@
+/* eslint-disable no-bitwise */ /**
+ * The SHA-512 round constants. Each 64-bit constant is stored as a pair
+ * of 32-bit integers (high word first, low word second).
+ *
+ * @type {number[]}
+ */ const K = [
+    0x428a2f98,
+    0xd728ae22,
+    0x71374491,
+    0x23ef65cd,
+    0xb5c0fbcf,
+    0xec4d3b2f,
+    0xe9b5dba5,
+    0x8189dbbc,
+    0x3956c25b,
+    0xf348b538,
+    0x59f111f1,
+    0xb605d019,
+    0x923f82a4,
+    0xaf194f9b,
+    0xab1c5ed5,
+    0xda6d8118,
+    0xd807aa98,
+    0xa3030242,
+    0x12835b01,
+    0x45706fbe,
+    0x243185be,
+    0x4ee4b28c,
+    0x550c7dc3,
+    0xd5ffb4e2,
+    0x72be5d74,
+    0xf27b896f,
+    0x80deb1fe,
+    0x3b1696b1,
+    0x9bdc06a7,
+    0x25c71235,
+    0xc19bf174,
+    0xcf692694,
+    0xe49b69c1,
+    0x9ef14ad2,
+    0xefbe4786,
+    0x384f25e3,
+    0x0fc19dc6,
+    0x8b8cd5b5,
+    0x240ca1cc,
+    0x77ac9c65,
+    0x2de92c6f,
+    0x592b0275,
+    0x4a7484aa,
+    0x6ea6e483,
+    0x5cb0a9dc,
+    0xbd41fbd4,
+    0x76f988da,
+    0x831153b5,
+    0x983e5152,
+    0xee66dfab,
+    0xa831c66d,
+    0x2db43210,
+    0xb00327c8,
+    0x98fb213f,
+    0xbf597fc7,
+    0xbeef0ee4,
+    0xc6e00bf3,
+    0x3da88fc2,
+    0xd5a79147,
+    0x930aa725,
+    0x06ca6351,
+    0xe003826f,
+    0x14292967,
+    0x0a0e6e70,
+    0x27b70a85,
+    0x46d22ffc,
+    0x2e1b2138,
+    0x5c26c926,
+    0x4d2c6dfc,
+    0x5ac42aed,
+    0x53380d13,
+    0x9d95b3df,
+    0x650a7354,
+    0x8baf63de,
+    0x766a0abb,
+    0x3c77b2a8,
+    0x81c2c92e,
+    0x47edaee6,
+    0x92722c85,
+    0x1482353b,
+    0xa2bfe8a1,
+    0x4cf10364,
+    0xa81a664b,
+    0xbc423001,
+    0xc24b8b70,
+    0xd0f89791,
+    0xc76c51a3,
+    0x0654be30,
+    0xd192e819,
+    0xd6ef5218,
+    0xd6990624,
+    0x5565a910,
+    0xf40e3585,
+    0x5771202a,
+    0x106aa070,
+    0x32bbd1b8,
+    0x19a4c116,
+    0xb8d2d0c8,
+    0x1e376c08,
+    0x5141ab53,
+    0x2748774c,
+    0xdf8eeb99,
+    0x34b0bcb5,
+    0xe19b48a8,
+    0x391c0cb3,
+    0xc5c95a63,
+    0x4ed8aa4a,
+    0xe3418acb,
+    0x5b9cca4f,
+    0x7763e373,
+    0x682e6ff3,
+    0xd6b2b8a3,
+    0x748f82ee,
+    0x5defb2fc,
+    0x78a5636f,
+    0x43172f60,
+    0x84c87814,
+    0xa1f0ab72,
+    0x8cc70208,
+    0x1a6439ec,
+    0x90befffa,
+    0x23631e28,
+    0xa4506ceb,
+    0xde82bde9,
+    0xbef9a3f7,
+    0xb2c67915,
+    0xc67178f2,
+    0xe372532b,
+    0xca273ece,
+    0xea26619c,
+    0xd186b8c7,
+    0x21c0c207,
+    0xeada7dd6,
+    0xcde0eb1e,
+    0xf57d4f7f,
+    0xee6ed178,
+    0x06f067aa,
+    0x72176fba,
+    0x0a637dc5,
+    0xa2c898a6,
+    0x113f9804,
+    0xbef90dae,
+    0x1b710b35,
+    0x131c471b,
+    0x28db77f5,
+    0x23047d84,
+    0x32caab7b,
+    0x40c72493,
+    0x3c9ebe0a,
+    0x15c9bebc,
+    0x431d67c4,
+    0x9c100d4c,
+    0x4cc5d4be,
+    0xcb3e42b6,
+    0x597f299c,
+    0xfc657e2a,
+    0x5fcb6fab,
+    0x3ad6faec,
+    0x6c44198c,
+    0x4a475817
+];
+/**
+ * Converts a 32-bit integer to a zero-padded 8-character hex string.
+ *
+ * @param {number} value The 32-bit integer value.
+ * @returns {string}
+ */ function toHex32(value) {
+    return `00000000${(value >>> 0).toString(16)}`.slice(-8);
+}
+/**
+ * Calculates the SHA-512 checksum of the passed bytes. The implementation is
+ * a plain (pure JS) one on purpose. It does not depend on the Web Crypto API
+ * (`crypto.subtle`), which browsers expose only on secure origins (https).
+ * Thanks to that, the checksum can be verified on plain http:// pages,
+ * for example, intranets of big companies.
+ *
+ * @param {number[]|Uint8Array} bytes The bytes to calculate the checksum from.
+ * @returns {string} The checksum as a 128-character hex string.
+ */ export function sha512(bytes) {
+    const byteLength = bytes.length;
+    // The message is padded with the 0x80 byte, zeros, and the 128-bit big-endian
+    // bit length so the total length is a multiple of 128 bytes.
+    const blockCount = Math.ceil((byteLength + 17) / 128);
+    const buffer = new Uint8Array(blockCount * 128);
+    buffer.set(bytes);
+    buffer[byteLength] = 0x80;
+    const bitLength = byteLength * 8;
+    const bufferLength = buffer.length;
+    // The supported message sizes fit well within 2^53 bits, so only the two
+    // lowest 32-bit words of the 128-bit length field are ever non-zero.
+    buffer[bufferLength - 7] = Math.floor(bitLength / 0x1000000000000) & 0xff; // bits 48-55
+    buffer[bufferLength - 6] = Math.floor(bitLength / 0x10000000000) & 0xff; // bits 40-47
+    buffer[bufferLength - 5] = Math.floor(bitLength / 0x100000000) & 0xff; // bits 32-39
+    buffer[bufferLength - 4] = bitLength >>> 24 & 0xff; // bits 24-31
+    buffer[bufferLength - 3] = bitLength >>> 16 & 0xff; // bits 16-23
+    buffer[bufferLength - 2] = bitLength >>> 8 & 0xff; // bits 8-15
+    buffer[bufferLength - 1] = bitLength & 0xff; // bits 0-7
+    // The initial hash values, stored as [high, low] 32-bit pairs.
+    const H = [
+        0x6a09e667,
+        0xf3bcc908,
+        0xbb67ae85,
+        0x84caa73b,
+        0x3c6ef372,
+        0xfe94f82b,
+        0xa54ff53a,
+        0x5f1d36f1,
+        0x510e527f,
+        0xade682d1,
+        0x9b05688c,
+        0x2b3e6c1f,
+        0x1f83d9ab,
+        0xfb41bd6b,
+        0x5be0cd19,
+        0x137e2179
+    ];
+    const wh = new Array(80);
+    const wl = new Array(80);
+    for(let block = 0; block < blockCount; block += 1){
+        const offset = block * 128;
+        // Prepare the message schedule.
+        for(let i = 0; i < 16; i += 1){
+            const o = offset + i * 8;
+            wh[i] = (buffer[o] << 24 | buffer[o + 1] << 16 | buffer[o + 2] << 8 | buffer[o + 3]) >>> 0;
+            wl[i] = (buffer[o + 4] << 24 | buffer[o + 5] << 16 | buffer[o + 6] << 8 | buffer[o + 7]) >>> 0;
+        }
+        for(let i = 16; i < 80; i += 1){
+            const x2h = wh[i - 2];
+            const x2l = wl[i - 2];
+            const x15h = wh[i - 15];
+            const x15l = wl[i - 15];
+            // smallSigma1 = ROTR^19(x) XOR ROTR^61(x) XOR SHR^6(x)
+            const s1h = (x2h >>> 19 | x2l << 13) ^ (x2l >>> 29 | x2h << 3) ^ x2h >>> 6;
+            const s1l = (x2l >>> 19 | x2h << 13) ^ (x2h >>> 29 | x2l << 3) ^ (x2l >>> 6 | x2h << 26);
+            // smallSigma0 = ROTR^1(x) XOR ROTR^8(x) XOR SHR^7(x)
+            const s0h = (x15h >>> 1 | x15l << 31) ^ (x15h >>> 8 | x15l << 24) ^ x15h >>> 7;
+            const s0l = (x15l >>> 1 | x15h << 31) ^ (x15l >>> 8 | x15h << 24) ^ (x15l >>> 7 | x15h << 25);
+            const lowSum = (s1l >>> 0) + (wl[i - 7] >>> 0) + (s0l >>> 0) + (wl[i - 16] >>> 0);
+            wl[i] = lowSum >>> 0;
+            wh[i] = (s1h >>> 0) + (wh[i - 7] >>> 0) + (s0h >>> 0) + (wh[i - 16] >>> 0) + Math.floor(lowSum / 0x100000000) >>> 0;
+        }
+        let ah = H[0];
+        let al = H[1];
+        let bh = H[2];
+        let bl = H[3];
+        let ch = H[4];
+        let cl = H[5];
+        let dh = H[6];
+        let dl = H[7];
+        let eh = H[8];
+        let el = H[9];
+        let fh = H[10];
+        let fl = H[11];
+        let gh = H[12];
+        let gl = H[13];
+        let hh = H[14];
+        let hl = H[15];
+        for(let i = 0; i < 80; i += 1){
+            // bigSigma1 = ROTR^14(e) XOR ROTR^18(e) XOR ROTR^41(e)
+            const bs1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
+            const bs1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+            // bigSigma0 = ROTR^28(a) XOR ROTR^34(a) XOR ROTR^39(a)
+            const bs0h = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25);
+            const bs0l = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25);
+            // ch = (e AND f) XOR (NOT e AND g)
+            const chh = eh & fh ^ ~eh & gh;
+            const chl = el & fl ^ ~el & gl;
+            // maj = (a AND b) XOR (a AND c) XOR (b AND c)
+            const majh = ah & bh ^ ah & ch ^ bh & ch;
+            const majl = al & bl ^ al & cl ^ bl & cl;
+            const t1LowSum = (hl >>> 0) + (bs1l >>> 0) + (chl >>> 0) + (K[i * 2 + 1] >>> 0) + (wl[i] >>> 0);
+            const t1l = t1LowSum >>> 0;
+            const t1h = (hh >>> 0) + (bs1h >>> 0) + (chh >>> 0) + (K[i * 2] >>> 0) + (wh[i] >>> 0) + Math.floor(t1LowSum / 0x100000000) >>> 0;
+            const t2LowSum = (bs0l >>> 0) + (majl >>> 0);
+            const t2l = t2LowSum >>> 0;
+            const t2h = (bs0h >>> 0) + (majh >>> 0) + Math.floor(t2LowSum / 0x100000000) >>> 0;
+            hh = gh;
+            hl = gl;
+            gh = fh;
+            gl = fl;
+            fh = eh;
+            fl = el;
+            const eLowSum = (dl >>> 0) + t1l;
+            el = eLowSum >>> 0;
+            eh = (dh >>> 0) + t1h + Math.floor(eLowSum / 0x100000000) >>> 0;
+            dh = ch;
+            dl = cl;
+            ch = bh;
+            cl = bl;
+            bh = ah;
+            bl = al;
+            const aLowSum = t1l + t2l;
+            al = aLowSum >>> 0;
+            ah = t1h + t2h + Math.floor(aLowSum / 0x100000000) >>> 0;
+        }
+        const stateWords = [
+            ah,
+            al,
+            bh,
+            bl,
+            ch,
+            cl,
+            dh,
+            dl,
+            eh,
+            el,
+            fh,
+            fl,
+            gh,
+            gl,
+            hh,
+            hl
+        ];
+        for(let i = 0; i < 16; i += 2){
+            const stateLowSum = (H[i + 1] >>> 0) + (stateWords[i + 1] >>> 0);
+            H[i + 1] = stateLowSum >>> 0;
+            H[i] = (H[i] >>> 0) + (stateWords[i] >>> 0) + Math.floor(stateLowSum / 0x100000000) >>> 0;
+        }
+    }
+    return H.map(toHex32).join('');
+}

package/utils/entitlementLicenseKey/types.d.mts

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

package/utils/entitlementLicenseKey/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The license key formats a Handsontable build can be handed. Only
+ * "entitlement" is read by this module; every other format is routed to the
+ * legacy path.
+ */
+export type LicenseKeyFormat = 'entitlement' | 'legacy' | 'non-commercial-and-evaluation' | 'unknown';
+/**
+ * What one product entry of a verified key grants. Exactly one of
+ * `usage_until` / `release_until` is present - the pair replaces the contract
+ * type, which the payload does not carry. `notice` and `grace` are the warning
+ * and soft-stop windows, in days, and arrive in the key rather than living in
+ * the library. Unknown extra fields survive verification untouched, so a field
+ * added to the format later stays visible to the layers above.
+ */
+export interface ProductEntitlement {
+    capabilities: string[];
+    usage_until?: string;
+    release_until?: string;
+    notice: number;
+    grace: number;
+    flags: string[];
+    [field: string]: unknown;
+}
+/**
+ * The machine-readable data of a verified entitlement license key: what it
+ * grants, keyed by product name. Presence means licensed. A product this build
+ * does not know is kept and ignored - one install can be licensed for one
+ * product and not for another, and the unknown one must not take down the
+ * known ones.
+ */
+export interface EntitlementKeyData {
+    products: {
+        [productName: string]: ProductEntitlement;
+    };
+}
+/**
+ * The lifecycle state of a license, derived from the governing date of the
+ * product entry:
+ *
+ *   - `usage_until` runs the notice -> soft stop -> hard stop windows against
+ *     the current UTC instant. The `trial_*` states are the same windows on a
+ *     key carrying the `trial` flag - they differ in what the user is told and
+ *     shown, not in how they are measured.
+ *   - `release_until` compares the build release date against the maintenance
+ *     date as text. No clock takes part, so the verdict never changes.
+ */
+export type LicenseState = 'usage_valid' | 'usage_notice' | 'usage_soft_stop' | 'usage_hard_stop' | 'trial_valid' | 'trial_notice' | 'trial_soft_stop' | 'trial_hard_stop' | 'release_valid' | 'release_expired';
+/**
+ * The lifecycle facet of a license: the state, whether the key is a trial, the
+ * whole UTC days left until the last licensed day (`null` when no clock is
+ * involved), and the governing date as the bare "YYYY-MM-DD" string the
+ * payload carries. The date is never re-derived from a timestamp - the string
+ * in the key is what the messages print.
+ */
+export interface LicenseLifecycle {
+    state: LicenseState;
+    isTrial: boolean;
+    daysRemaining: number | null;
+    licensedUntil: string | null;
+}
+/**
+ * Which notification channels the license leaves open. A product entry may
+ * carry `no-console-warns` (nothing reaches the console) and `no-ui-warns`
+ * (nothing is rendered on top of the grid); both are the default for a key
+ * issued for external, end-user-facing use.
+ */
+export interface LicenseChannels {
+    console: boolean;
+    ui: boolean;
+}
+/**
+ * What a license unlocks. `unrestricted` is the legacy-and-fallback shortcut -
+ * every query answers "granted" for it, so the same API serves legacy keys
+ * (unlock everything) and entitlement keys (unlock exactly the tokens the
+ * payload lists) without the caller branching on the key family.
+ */
+export interface LicenseGrants {
+    unrestricted: boolean;
+    products: {
+        [productName: string]: {
+            capabilities: string[];
+        };
+    };
+}

package/utils/entitlementLicenseKey/types.js

@@ -0,0 +1,8 @@
+/**
+ * The license key formats a Handsontable build can be handed. Only
+ * "entitlement" is read by this module; every other format is routed to the
+ * legacy path.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/utils/entitlementLicenseKey/types.mjs

@@ -0,0 +1,10 @@
+/**
+ * The license key formats a Handsontable build can be handed. Only
+ * "entitlement" is read by this module; every other format is routed to the
+ * legacy path.
+ */ /**
+ * What a license unlocks. `unrestricted` is the legacy-and-fallback shortcut -
+ * every query answers "granted" for it, so the same API serves legacy keys
+ * (unlock everything) and entitlement keys (unlock exactly the tokens the
+ * payload lists) without the caller branching on the key family.
+ */ export { };

package/utils/ghostTable.d.ts

@@ -37,6 +37,7 @@ interface SampleEntry {
  * @class GhostTable
  */
 declare class GhostTable {
+    #private;
     /**
      * Handsontable instance.
      *

package/utils/ghostTable.js

@@ -8,9 +8,44 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+const _renderCell = require("../renderers/renderCell");
 const _element = require("./../helpers/dom/element");
 const _array = require("./../helpers/array");
 const _errors = require("../helpers/errors");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var /**
+   * Renders one sampled cell into the TD that will be measured, through the same `renderCell`
+   * contract `TableView.cellRenderer` uses: run the cell's own renderer, run the base renderer
+   * when that renderer did not chain it itself, then reset the chaining flag. Calling only the
+   * cell renderer here would leave the measured TD without `cellProperties.className` and the
+   * other base-renderer classes, so AutoRowSize and AutoColumnSize would measure a cell styled
+   * differently from the one the user sees.
+   *
+   * The sampled value must be rendered verbatim — the AutoRowSize and AutoColumnSize samplers
+   * already run `formatCellValue` when building samples. Formatting here again would
+   * double-format: a date sample already formatted to `1/1/24` fails the ISO-only
+   * `parseToLocalDate` and renders as `#bad-value#`, inflating the measured width.
+   *
+   * @param {HTMLTableCellElement} td The cell element that will be measured.
+   * @param {number} row Visual row index.
+   * @param {number} column Visual column index.
+   * @param {*} value The sampled cell value, already formatted by the sampler.
+   * @param {object} cellProperties The cell meta object.
+   */ _renderCell1 = /*#__PURE__*/ new WeakSet();
 /**
  * @class GhostTable
  */ class GhostTable {
@@ -190,13 +225,12 @@ const _errors = require("../helpers/errors");
         this.samples.forEach((sample)=>{
             (0, _array.arrayEach)(sample.strings, (string)=>{
                 const column = string.col;
-                const cellProperties = this.hot.getCellMeta(row, column);
-                const renderer = this.hot.getCellRenderer(cellProperties);
+                const cellProperties = this.hot.getCellMetaTransient(row, column);
                 const td = rootDocument.createElement('td');
                 // Indicate that this element is created and supported by GhostTable. It can be useful to
                 // exclude rendering performance costly logic or exclude logic which doesn't work within a hidden table.
                 td.setAttribute('ghost-table', '1');
-                renderer(this.hot, td, row, column, this.hot.colToProp(column), string.value, cellProperties);
+                _class_private_method_get(this, _renderCell1, renderCell).call(this, td, row, column, string.value, cellProperties);
                 fragment.appendChild(td);
             });
         });
@@ -206,7 +240,10 @@ const _errors = require("../helpers/errors");
    * Creates DOM elements for headers and appends them to the THEAD element of the table.
    */ appendColumnHeadersRow() {
         const rootDocument = this.hot.rootDocument;
-        const domFragment = rootDocument.createDocumentFragment();
+        // The headers must sit in a real `<tr>` (`table > thead > tr > th`), mirroring the grid's
+        // DOM — the cell styling is scoped with child combinators (#4363), so a `<th>` appended
+        // straight into `<thead>` would miss it and measure without padding/borders.
+        const headersRow = rootDocument.createElement('tr');
         const columnHeaders = [];
         if (this.hot.hasRowHeaders()) {
             const th = rootDocument.createElement('th');
@@ -214,7 +251,7 @@ const _errors = require("../helpers/errors");
                 -1,
                 th
             ]);
-            domFragment.appendChild(th);
+            headersRow.appendChild(th);
         }
         this.samples.forEach((sample)=>{
             (0, _array.arrayEach)(sample.strings, (string)=>{
@@ -224,11 +261,11 @@ const _errors = require("../helpers/errors");
                     column,
                     th
                 ]);
-                domFragment.appendChild(th);
+                headersRow.appendChild(th);
             });
         });
         // Appending DOM elements for headers
-        this.table.tHead.appendChild(domFragment);
+        this.table.tHead.appendChild(headersRow);
         (0, _array.arrayEach)(columnHeaders, (columnHeader)=>{
             const [column, th] = columnHeader;
             // Using source method for filling a header with value.
@@ -246,14 +283,13 @@ const _errors = require("../helpers/errors");
         this.samples.forEach((sample)=>{
             (0, _array.arrayEach)(sample.strings, (string)=>{
                 const row = string.row;
-                const cellProperties = this.hot.getCellMeta(row, column);
-                const renderer = this.hot.getCellRenderer(cellProperties);
+                const cellProperties = this.hot.getCellMetaTransient(row, column);
                 const td = rootDocument.createElement('td');
                 const tr = rootDocument.createElement('tr');
                 // Indicate that this element is created and supported by GhostTable. It can be useful to
                 // exclude rendering performance costly logic or exclude logic which doesn't work within a hidden table.
                 td.setAttribute('ghost-table', '1');
-                renderer(this.hot, td, row, column, this.hot.colToProp(column), string.value, cellProperties);
+                _class_private_method_get(this, _renderCell1, renderCell).call(this, td, row, column, string.value, cellProperties);
                 tr.appendChild(td);
                 fragment.appendChild(tr);
             });
@@ -301,7 +337,7 @@ const _errors = require("../helpers/errors");
         const col = this.hot.rootDocument.createElement('col');
         let colspan = 0;
         if (row >= 0 && column >= 0) {
-            colspan = Number(this.hot.getCellMeta(row, column).colspan);
+            colspan = Number(this.hot.getCellMetaTransient(row, column).colspan);
         }
         let width = this.hot.getColWidth(column);
         if (colspan > 1) {
@@ -386,6 +422,7 @@ const _errors = require("../helpers/errors");
     /**
    * Initializes the ghost table utility with a reference to the Handsontable instance used for DOM context.
    */ constructor(hotInstance){
+        _class_private_method_init(this, _renderCell1);
         /**
    * Handsontable instance.
    *
@@ -433,4 +470,16 @@ const _errors = require("../helpers/errors");
         this.hot = hotInstance;
     }
 }
+function renderCell(td, row, column, value, cellProperties) {
+    const rendererArgs = [
+        this.hot,
+        td,
+        row,
+        column,
+        this.hot.colToProp(column),
+        value,
+        cellProperties
+    ];
+    (0, _renderCell.renderCell)(this.hot.getCellRenderer(cellProperties), rendererArgs);
+}
 const _default = GhostTable;