@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/createAbortRotation.js

@@ -0,0 +1,116 @@
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { observable, runInAction } from 'mobx';
+import { createStatusWindow, statusFraction, statusMessageText, } from './progress.js';
+export function createStatusChannel() {
+    // MobX rather than MST, so this is a value a model can hold rather than a
+    // node it has to parent. A volatile is `observable.ref`, so the fields have
+    // to be observable in their own right for a component to see them move.
+    const state = observable({
+        message: undefined,
+        fraction: undefined,
+    }, {}, { deep: false });
+    return {
+        get message() {
+            return state.message;
+        },
+        get fraction() {
+            return state.fraction;
+        },
+        setStatusMessage(status) {
+            // its own action: the rotation calls this from a status callback, which
+            // fires after an await and so outside whatever MST action started the
+            // fetch
+            runInAction(() => {
+                state.message = statusMessageText(status);
+                state.fraction = statusFraction(status);
+            });
+        },
+    };
+}
+export function createAbortRotation(self, report) {
+    let current;
+    // The host's window when it has one, so a display composing `FetchMixin` has
+    // one window rather than two writing one field; our own otherwise. Lent means
+    // this fetch is one slot beside the host's others rather than a second writer
+    // (ADR-081), which is why `end()` no longer has to ask whether it owns the
+    // field.
+    const lent = report.statusWindow !== undefined;
+    const statusWindow = report.statusWindow
+        ? report.statusWindow
+        : // the one place the field is touched, so the liveness check covers a
+            // stream's statuses and the clear that ends it alike
+            createStatusWindow((status) => {
+                if (isAlive(self)) {
+                    report.setStatusMessage(status);
+                }
+            });
+    let openStream;
+    /**
+     * Stop the in-flight fetch without starting one, and retire its slot.
+     *
+     * Dropping `current` rather than only aborting it is what closes every
+     * outstanding guard: `isCurrent` compares against this field, so one
+     * assignment makes a fetch already past its await stale, whether it is the one
+     * being cancelled or a superseded predecessor still unwinding.
+     *
+     * Retiring, not blanking — the field goes blank only if this was the last
+     * operation reporting on it (ADR-081).
+     *
+     * Named rather than reached through `this`, so a destructured `dispose` still
+     * works: `addDisposer(self, rotation.dispose)` is a shape callers reach for.
+     */
+    const cancel = () => {
+        current?.abort();
+        current = undefined;
+        // a fetch in flight when this is called never reaches its `finally`, and a
+        // slot nobody retires goes on voting
+        openStream?.clear();
+        openStream = undefined;
+    };
+    return {
+        begin() {
+            current?.abort();
+            const controller = new AbortController();
+            current = controller;
+            // `ended` is the term a completed fetch has no other way to express: the
+            // controller comparison catches a SUPERSEDED one, but a fetch that simply
+            // finished still holds the current one. The stream reads it as well as
+            // the caller's commit guard, which is why both go through this closure.
+            let ended = false;
+            const isCurrent = () => !ended && controller === current && isAlive(self);
+            // Opened before the superseded slot retires, so the window is never idle
+            // across the handover and the label on screen survives it (ADR-080).
+            // Retired here rather than left to the superseded run's `finally`, which
+            // comes only when its work settles — and a CRAM record read or a shared
+            // parse the signal is withheld from runs on past the abort, its last
+            // reading summed into this fetch's bar the whole time.
+            const stream = statusWindow.open({ isCurrent });
+            openStream?.clear();
+            openStream = stream;
+            return {
+                signal: controller.signal,
+                isCurrent,
+                statusCallback: stream.statusCallback,
+                end() {
+                    ended = true;
+                    if (openStream === stream) {
+                        openStream = undefined;
+                    }
+                    stream.clear();
+                },
+            };
+        },
+        cancel,
+        dispose() {
+            cancel();
+            // the window outlives the fetch: a trailing write is queued on a timer,
+            // and while the sink's `isCurrent` makes it a no-op rather than a write to
+            // a dead node, the timer itself still stands for up to a window past
+            // teardown. Only ours — resetting a lent one drops a write the host's
+            // other operations are still owed.
+            if (!lent) {
+                statusWindow.reset();
+            }
+        },
+    };
+}

package/esm/util/createSvgRasterCanvas.d.ts

@@ -0,0 +1,17 @@
+export interface SvgRasterCanvasOpts {
+    /**
+     * headless canvas factory for `rasterizeLayers` (jbrowse-img passes one);
+     * without it the raster path needs a DOM canvas
+     */
+    createCanvas?: (width: number, height: number) => HTMLCanvasElement;
+    /**
+     * decodes SVG markup into an image a `createCanvas` canvas can draw, where
+     * the environment's `Image` cannot (node, jsdom). A headless decoder draws
+     * vectors only, so markup headed for it carries no rasterized layers.
+     */
+    decodeSvg?: (markup: string) => Promise<CanvasImageSource>;
+}
+export declare function createSvgRasterCanvas(width: number, height: number, opts: SvgRasterCanvasOpts | undefined): {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};

package/esm/util/createSvgRasterCanvas.js

@@ -0,0 +1,22 @@
+// SVG export's "rasterize a layer to PNG" idiom: a 2× DPR canvas drawn into,
+// then embedded as <image xlinkHref={dataURL}/>. Used by every renderSvg.tsx
+// that has heavy fill paths (alignments pileup, wiggle bins, hic matrix, LD
+// matrix, etc.) where vector output would be unreasonably large.
+//
+// Fixed at 2× — exports go to print/file, not screen, so devicePixelRatio is
+// not the right scale factor.
+const SVG_RASTER_DPR = 2;
+export function createSvgRasterCanvas(width, height, opts) {
+    const dpr = SVG_RASTER_DPR;
+    const canvas = opts?.createCanvas
+        ? opts.createCanvas(width * dpr, height * dpr)
+        : document.createElement('canvas');
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('createSvgRasterCanvas: 2D context unavailable');
+    }
+    ctx.scale(dpr, dpr);
+    return { canvas, ctx };
+}

package/esm/util/crypto.d.ts

@@ -1,7 +1,31 @@
+/**
+ * AES encrypt compatible with crypto-js OpenSSL format
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export declare function aesEncrypt(plaintext: string, password: string): Promise<string>;
+/**
+ * AES decrypt compatible with crypto-js OpenSSL format
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export declare function aesDecrypt(ciphertext: string, password: string): Promise<string>;
+/**
+ * SHA256 hash
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export declare function sha256(data: string): Promise<Uint8Array>;
+/**
+ * Base64 encode a Uint8Array
+ */
 export declare function toBase64(data: Uint8Array): string;
+/**
+ * URL-safe Base64 encode (for OAuth PKCE)
+ */
 export declare function toBase64Url(data: Uint8Array): string;
+/**
+ * SHA256 hash and return as Base64 (for OAuth PKCE code challenge)
+ */
 export declare function sha256Base64(data: string): Promise<string>;
+/**
+ * SHA256 hash and return as URL-safe Base64 (for OAuth PKCE code challenge)
+ */
 export declare function sha256Base64Url(data: string): Promise<string>;

package/esm/util/crypto.js

@@ -1,7 +1,12 @@
+// Crypto utilities using Web Crypto API with pure JS fallback for non-secure contexts
+// Compatible with crypto-js OpenSSL format for AES encryption
 const SALT_PREFIX = 'Salted__';
+// Check if Web Crypto API is available (only in secure contexts)
 function isWebCryptoAvailable() {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     return typeof crypto !== 'undefined' && crypto.subtle !== undefined;
 }
+// AES S-box
 const SBOX = new Uint8Array([
     0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe,
     0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4,
@@ -24,6 +29,7 @@ const SBOX = new Uint8Array([
     0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42,
     0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
 ]);
+// AES inverse S-box
 const SBOX_INV = new Uint8Array([
     0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81,
     0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e,
@@ -46,9 +52,11 @@ const SBOX_INV = new Uint8Array([
     0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6,
     0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
 ]);
+// Round constants for key expansion
 const RCON = new Uint8Array([
     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
 ]);
+// Galois field multiplication
 function gmul(a, b) {
     let p = 0;
     for (let i = 0; i < 8; i++) {
@@ -64,21 +72,25 @@ function gmul(a, b) {
     }
     return p;
 }
+// AES key expansion for 256-bit key
 function aesKeyExpansion(key) {
-    const Nk = 8;
-    const Nr = 14;
+    const Nk = 8; // 256-bit key = 8 words
+    const Nr = 14; // 14 rounds for 256-bit
     const expandedKey = new Uint8Array(16 * (Nr + 1));
     expandedKey.set(key);
     for (let i = Nk; i < 4 * (Nr + 1); i++) {
         const temp = expandedKey.slice((i - 1) * 4, i * 4);
         if (i % Nk === 0) {
+            // RotWord + SubWord + Rcon
             const t = temp[0];
             temp[0] = SBOX[temp[1]] ^ RCON[i / Nk - 1];
             temp[1] = SBOX[temp[2]];
             temp[2] = SBOX[temp[3]];
             temp[3] = SBOX[t];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         }
         else if (Nk > 6 && i % Nk === 4) {
+            // SubWord for 256-bit keys
             for (let j = 0; j < 4; j++) {
                 temp[j] = SBOX[temp[j]];
             }
@@ -89,17 +101,21 @@ function aesKeyExpansion(key) {
     }
     return expandedKey;
 }
+// AES encrypt single block (pure JS)
 function aesEncryptBlock(block, expandedKey) {
     const Nr = 14;
     const state = new Uint8Array(16);
     state.set(block);
+    // AddRoundKey
     for (let i = 0; i < 16; i++) {
         state[i] ^= expandedKey[i];
     }
     for (let round = 1; round <= Nr; round++) {
+        // SubBytes
         for (let i = 0; i < 16; i++) {
             state[i] = SBOX[state[i]];
         }
+        // ShiftRows
         const t1 = state[1];
         state[1] = state[5];
         state[5] = state[9];
@@ -116,6 +132,7 @@ function aesEncryptBlock(block, expandedKey) {
         state[11] = state[7];
         state[7] = state[3];
         state[3] = t3;
+        // MixColumns (skip in last round)
         if (round < Nr) {
             for (let c = 0; c < 4; c++) {
                 const i = c * 4;
@@ -129,6 +146,7 @@ function aesEncryptBlock(block, expandedKey) {
                 state[i + 3] = gmul(s0, 3) ^ s1 ^ s2 ^ gmul(s3, 2);
             }
         }
+        // AddRoundKey
         const roundKey = expandedKey.subarray(round * 16, (round + 1) * 16);
         for (let i = 0; i < 16; i++) {
             state[i] ^= roundKey[i];
@@ -136,14 +154,17 @@ function aesEncryptBlock(block, expandedKey) {
     }
     return state;
 }
+// AES decrypt single block (pure JS)
 function aesDecryptBlock(block, expandedKey) {
     const Nr = 14;
     const state = new Uint8Array(16);
     state.set(block);
+    // AddRoundKey
     for (let i = 0; i < 16; i++) {
         state[i] ^= expandedKey[Nr * 16 + i];
     }
     for (let round = Nr - 1; round >= 0; round--) {
+        // InvShiftRows
         const t1 = state[13];
         state[13] = state[9];
         state[9] = state[5];
@@ -160,13 +181,16 @@ function aesDecryptBlock(block, expandedKey) {
         state[7] = state[11];
         state[11] = state[15];
         state[15] = t3;
+        // InvSubBytes
         for (let i = 0; i < 16; i++) {
             state[i] = SBOX_INV[state[i]];
         }
+        // AddRoundKey
         const roundKey = expandedKey.subarray(round * 16, (round + 1) * 16);
         for (let i = 0; i < 16; i++) {
             state[i] ^= roundKey[i];
         }
+        // InvMixColumns (skip in last round)
         if (round > 0) {
             for (let c = 0; c < 4; c++) {
                 const i = c * 4;
@@ -183,6 +207,7 @@ function aesDecryptBlock(block, expandedKey) {
     }
     return state;
 }
+// PKCS7 padding
 function pkcs7Pad(data, blockSize) {
     const padding = blockSize - (data.length % blockSize);
     const padded = new Uint8Array(data.length + padding);
@@ -202,6 +227,7 @@ function pkcs7Unpad(data) {
     }
     return data.subarray(0, data.length - padding);
 }
+// AES-CBC encrypt (pure JS fallback)
 function aesCbcEncryptFallback(plaintext, key, iv) {
     const expandedKey = aesKeyExpansion(key);
     const padded = pkcs7Pad(plaintext, 16);
@@ -209,6 +235,7 @@ function aesCbcEncryptFallback(plaintext, key, iv) {
     let prevBlock = iv;
     for (let i = 0; i < padded.length; i += 16) {
         const block = padded.slice(i, i + 16);
+        // XOR with previous ciphertext block (or IV for first block)
         for (let j = 0; j < 16; j++) {
             block[j] ^= prevBlock[j];
         }
@@ -218,6 +245,7 @@ function aesCbcEncryptFallback(plaintext, key, iv) {
     }
     return ciphertext;
 }
+// AES-CBC decrypt (pure JS fallback)
 function aesCbcDecryptFallback(ciphertext, key, iv) {
     const expandedKey = aesKeyExpansion(key);
     const plaintext = new Uint8Array(ciphertext.length);
@@ -225,6 +253,7 @@ function aesCbcDecryptFallback(ciphertext, key, iv) {
     for (let i = 0; i < ciphertext.length; i += 16) {
         const block = ciphertext.slice(i, i + 16);
         const decrypted = aesDecryptBlock(block, expandedKey);
+        // XOR with previous ciphertext block (or IV for first block)
         for (let j = 0; j < 16; j++) {
             decrypted[j] ^= prevBlock[j];
         }
@@ -233,16 +262,20 @@ function aesCbcDecryptFallback(ciphertext, key, iv) {
     }
     return pkcs7Unpad(plaintext);
 }
+// Generate random bytes (works in both secure and non-secure contexts)
 function getRandomBytes(length) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
         return crypto.getRandomValues(new Uint8Array(length));
     }
+    // Fallback for environments without crypto.getRandomValues
     const bytes = new Uint8Array(length);
     for (let i = 0; i < length; i++) {
         bytes[i] = Math.floor(Math.random() * 256);
     }
     return bytes;
 }
+// SHA256 constants
 const SHA256_K = new Uint32Array([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
     0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -256,6 +289,7 @@ const SHA256_K = new Uint32Array([
     0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 ]);
+// SHA256 pure JS implementation
 function sha256Fallback(data) {
     function rotr(x, n) {
         return (x >>> n) | (x << (32 - n));
@@ -278,15 +312,19 @@ function sha256Fallback(data) {
     function gamma1(x) {
         return rotr(x, 17) ^ rotr(x, 19) ^ (x >>> 10);
     }
+    // Pre-processing
     const originalLength = data.length;
     const bitLength = originalLength * 8;
+    // Padding: append 1 bit, then zeros, then 64-bit length (big-endian)
     const paddingLength = (64 - ((originalLength + 9) % 64)) % 64;
     const padded = new Uint8Array(originalLength + 1 + paddingLength + 8);
     padded.set(data);
     padded[originalLength] = 0x80;
+    // Append length as big-endian 64-bit
     const view = new DataView(padded.buffer);
     view.setUint32(padded.length - 4, bitLength >>> 0, false);
     view.setUint32(padded.length - 8, Math.floor(bitLength / 0x100000000), false);
+    // Initialize hash values
     let h0 = 0x6a09e667;
     let h1 = 0xbb67ae85;
     let h2 = 0x3c6ef372;
@@ -295,8 +333,10 @@ function sha256Fallback(data) {
     let h5 = 0x9b05688c;
     let h6 = 0x1f83d9ab;
     let h7 = 0x5be0cd19;
+    // Process each 512-bit chunk
     const W = new Uint32Array(64);
     for (let i = 0; i < padded.length; i += 64) {
+        // Prepare message schedule
         for (let t = 0; t < 16; t++) {
             W[t] = view.getUint32(i + t * 4, false);
         }
@@ -345,7 +385,9 @@ function sha256Fallback(data) {
     resultView.setUint32(28, h7, false);
     return result;
 }
+// MD5 implementation for EVP_BytesToKey (required for crypto-js compatibility)
 function md5(data) {
+    // MD5 constants
     const S = [
         7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5,
         9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11,
@@ -368,19 +410,24 @@ function md5(data) {
     function leftRotate(x, c) {
         return (x << c) | (x >>> (32 - c));
     }
+    // Pre-processing: adding padding bits
     const originalLength = data.length;
     const bitLength = originalLength * 8;
+    // Append "1" bit and padding zeros
     const paddingLength = (56 - ((originalLength + 1) % 64) + 64) % 64;
     const padded = new Uint8Array(originalLength + 1 + paddingLength + 8);
     padded.set(data);
     padded[originalLength] = 0x80;
+    // Append original length in bits as 64-bit little-endian
     const view = new DataView(padded.buffer);
     view.setUint32(padded.length - 8, bitLength >>> 0, true);
     view.setUint32(padded.length - 4, Math.floor(bitLength / 0x100000000), true);
+    // Initialize hash values
     let a0 = 0x67452301;
     let b0 = 0xefcdab89;
     let c0 = 0x98badcfe;
     let d0 = 0x10325476;
+    // Process each 512-bit chunk
     for (let i = 0; i < padded.length; i += 64) {
         const M = new Uint32Array(16);
         for (let j = 0; j < 16; j++) {
@@ -428,6 +475,7 @@ function md5(data) {
     resultView.setUint32(12, d0, true);
     return result;
 }
+// EVP_BytesToKey - OpenSSL key derivation function used by crypto-js
 function evpBytesToKey(password, salt, keyLen, ivLen) {
     const result = new Uint8Array(keyLen + ivLen);
     let offset = 0;
@@ -446,13 +494,17 @@ function evpBytesToKey(password, salt, keyLen, ivLen) {
         iv: result.slice(keyLen, keyLen + ivLen),
     };
 }
+// Convert string to Uint8Array (UTF-8)
 function stringToBytes(str) {
     const encoded = new TextEncoder().encode(str);
+    // Return a copy with a fresh ArrayBuffer to satisfy TypeScript's strict typing
     return encoded.slice();
 }
+// Convert Uint8Array to string (UTF-8)
 function bytesToString(bytes) {
     return new TextDecoder().decode(bytes);
 }
+// Base64 encode
 function base64Encode(data) {
     let binary = '';
     for (const byte of data) {
@@ -460,6 +512,7 @@ function base64Encode(data) {
     }
     return btoa(binary);
 }
+// Base64 decode
 function base64Decode(str) {
     const binary = atob(str);
     const bytes = new Uint8Array(binary.length);
@@ -468,18 +521,25 @@ function base64Decode(str) {
     }
     return bytes;
 }
+/**
+ * AES encrypt compatible with crypto-js OpenSSL format
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export async function aesEncrypt(plaintext, password) {
     const salt = getRandomBytes(8);
     const { key, iv } = evpBytesToKey(stringToBytes(password), salt, 32, 16);
     let encrypted;
     if (isWebCryptoAvailable()) {
         const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'AES-CBC' }, false, ['encrypt']);
+        // Web Crypto API handles PKCS7 padding automatically
         const encryptedBuffer = await crypto.subtle.encrypt({ name: 'AES-CBC', iv }, cryptoKey, stringToBytes(plaintext));
         encrypted = new Uint8Array(encryptedBuffer);
     }
     else {
+        // Fallback to pure JS implementation
         encrypted = aesCbcEncryptFallback(stringToBytes(plaintext), key, iv);
     }
+    // Format: "Salted__" + salt + ciphertext, then Base64
     const saltPrefix = stringToBytes(SALT_PREFIX);
     const result = new Uint8Array(saltPrefix.length + salt.length + encrypted.byteLength);
     result.set(saltPrefix);
@@ -487,8 +547,13 @@ export async function aesEncrypt(plaintext, password) {
     result.set(encrypted, saltPrefix.length + salt.length);
     return base64Encode(result);
 }
+/**
+ * AES decrypt compatible with crypto-js OpenSSL format
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export async function aesDecrypt(ciphertext, password) {
     const data = base64Decode(ciphertext);
+    // Check for "Salted__" prefix
     const saltPrefix = stringToBytes(SALT_PREFIX);
     const hasSalt = data.length > saltPrefix.length &&
         bytesToString(data.subarray(0, saltPrefix.length)) === SALT_PREFIX;
@@ -501,14 +566,20 @@ export async function aesDecrypt(ciphertext, password) {
     let decrypted;
     if (isWebCryptoAvailable()) {
         const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'AES-CBC' }, false, ['decrypt']);
+        // Web Crypto API handles PKCS7 padding automatically
         const decryptedBuffer = await crypto.subtle.decrypt({ name: 'AES-CBC', iv }, cryptoKey, encrypted);
         decrypted = new Uint8Array(decryptedBuffer);
     }
     else {
+        // Fallback to pure JS implementation
         decrypted = aesCbcDecryptFallback(encrypted, key, iv);
     }
     return bytesToString(decrypted);
 }
+/**
+ * SHA256 hash
+ * Uses Web Crypto API when available, falls back to pure JS in non-secure contexts
+ */
 export async function sha256(data) {
     const encoded = stringToBytes(data);
     if (isWebCryptoAvailable()) {
@@ -517,19 +588,31 @@ export async function sha256(data) {
     }
     return sha256Fallback(encoded);
 }
+/**
+ * Base64 encode a Uint8Array
+ */
 export function toBase64(data) {
     return base64Encode(data);
 }
+/**
+ * URL-safe Base64 encode (for OAuth PKCE)
+ */
 export function toBase64Url(data) {
     return base64Encode(data)
         .replaceAll('+', '-')
         .replaceAll('/', '_')
         .replaceAll('=', '');
 }
+/**
+ * SHA256 hash and return as Base64 (for OAuth PKCE code challenge)
+ */
 export async function sha256Base64(data) {
     const hash = await sha256(data);
     return toBase64(hash);
 }
+/**
+ * SHA256 hash and return as URL-safe Base64 (for OAuth PKCE code challenge)
+ */
 export async function sha256Base64Url(data) {
     const hash = await sha256(data);
     return toBase64Url(hash);

package/esm/util/cssColorParse.d.ts

@@ -0,0 +1,15 @@
+import type { Color } from './color-bits/core.ts';
+/**
+ * Normalize a bare BED color triple to canonical "r,g,b", or undefined if the
+ * string isn't one. Each component must be in range: the underlying parser
+ * masks to 8 bits, so a bogus "999,0,0" would otherwise *wrap* to 231 and paint
+ * a plausible-looking but wrong color rather than being caught.
+ */
+export declare function bedTriple(str: string): string | undefined;
+export declare function parseCssColorOr(color: string, fallback: Color): Color;
+/**
+ * Whether the painters read `color` as a color — a CSS name, hex, functional
+ * form, `transparent` or a BED triple — rather than as the invalid sentinel.
+ * What a `color` config slot admits.
+ */
+export declare function isCssColor(color: string): boolean;

package/esm/util/cssColorParse.js

@@ -0,0 +1,53 @@
+import { newColor } from './color-bits/core.js';
+import { parse } from './color-bits/parse.js';
+import { namedColorToHex } from './color/cssColorsLevel4.js';
+// Split out of colorBits.ts so a config slot can ask "is this a color?" without
+// taking that module's re-export of render-core's packers: the closure ceiling
+// in scripts/moduleClosure.test.ts is what says so.
+// A bare BED color triple ("255,0,0"), which is not a CSS color but is what
+// BED-family adapters put on the feature verbatim. The spec has no spaces, but
+// tolerate them rather than silently ignoring an otherwise-usable color.
+const BED_TRIPLE = /^(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})$/;
+/**
+ * Normalize a bare BED color triple to canonical "r,g,b", or undefined if the
+ * string isn't one. Each component must be in range: the underlying parser
+ * masks to 8 bits, so a bogus "999,0,0" would otherwise *wrap* to 231 and paint
+ * a plausible-looking but wrong color rather than being caught.
+ */
+export function bedTriple(str) {
+    const m = BED_TRIPLE.exec(str.trim());
+    const rgb = m?.slice(1, 4).map(Number);
+    return rgb?.every(n => n <= 255) ? rgb.join(',') : undefined;
+}
+function tryParseCssColor(color) {
+    const str = color.trim().toLowerCase();
+    if (str === 'transparent') {
+        return newColor(0, 0, 0, 0);
+    }
+    try {
+        const hex = namedColorToHex(str);
+        const triple = bedTriple(str);
+        return parse(hex ? hex : triple ? `rgb(${triple})` : str);
+    }
+    catch {
+        return undefined;
+    }
+}
+// Resolve a CSS color string to a Color: honors named colors, `transparent`,
+// and bare BED color triples, and returns `fallback` on malformed-but-nonempty
+// input. `parse` throws on e.g. an empty "rgb()"; callers pass a fallback so one
+// bad per-feature color can't crash a whole render/RPC. An out-of-range triple
+// is left to throw into `fallback` (magenta) rather than wrapping to a wrong
+// color — the same rule featureItemRgb applies, so a jexl callback reading an
+// itemRgb column and the automatic path agree on what counts as a color.
+export function parseCssColorOr(color, fallback) {
+    return tryParseCssColor(color) ?? fallback;
+}
+/**
+ * Whether the painters read `color` as a color — a CSS name, hex, functional
+ * form, `transparent` or a BED triple — rather than as the invalid sentinel.
+ * What a `color` config slot admits.
+ */
+export function isCssColor(color) {
+    return tryParseCssColor(color) !== undefined;
+}

package/esm/util/dataGridUtils.d.ts

@@ -0,0 +1,9 @@
+import type { GridRowId, GridRowSelectionModel } from '@mui/x-data-grid';
+export declare function measureGridWidth(elements: unknown[], args?: {
+    minWidth?: number;
+    fontSize?: number;
+    maxWidth?: number;
+    padding?: number;
+    stripHTML?: boolean;
+}): number;
+export declare function resolveSelectedIds(model: GridRowSelectionModel, allIds: Iterable<GridRowId>): Set<GridRowId>;