@willwade/aac-processors 0.1.20 → 0.2.0

package/dist/browser/processors/gridset/colorUtils.js

@@ -0,0 +1,354 @@
+/**
+ * Grid3 Color Utilities
+ *
+ * Comprehensive color handling for Grid3 format, including:
+ * - CSS color name lookup (147 named colors)
+ * - Color format conversion (hex, RGB, RGBA, named colors)
+ * - Color manipulation (darkening, normalization)
+ * - Grid3-specific color formatting (8-digit ARGB hex)
+ */
+/**
+ * CSS color names to RGB values
+ * Supports 147 standard CSS color names
+ */
+const CSS_COLORS = {
+    aliceblue: [240, 248, 255],
+    antiquewhite: [250, 235, 215],
+    aqua: [0, 255, 255],
+    aquamarine: [127, 255, 212],
+    azure: [240, 255, 255],
+    beige: [245, 245, 220],
+    bisque: [255, 228, 196],
+    black: [0, 0, 0],
+    blanchedalmond: [255, 235, 205],
+    blue: [0, 0, 255],
+    blueviolet: [138, 43, 226],
+    brown: [165, 42, 42],
+    burlywood: [222, 184, 135],
+    cadetblue: [95, 158, 160],
+    chartreuse: [127, 255, 0],
+    chocolate: [210, 105, 30],
+    coral: [255, 127, 80],
+    cornflowerblue: [100, 149, 237],
+    cornsilk: [255, 248, 220],
+    crimson: [220, 20, 60],
+    cyan: [0, 255, 255],
+    darkblue: [0, 0, 139],
+    darkcyan: [0, 139, 139],
+    darkgoldenrod: [184, 134, 11],
+    darkgray: [169, 169, 169],
+    darkgreen: [0, 100, 0],
+    darkgrey: [169, 169, 169],
+    darkkhaki: [189, 183, 107],
+    darkmagenta: [139, 0, 139],
+    darkolivegreen: [85, 107, 47],
+    darkorange: [255, 140, 0],
+    darkorchid: [153, 50, 204],
+    darkred: [139, 0, 0],
+    darksalmon: [233, 150, 122],
+    darkseagreen: [143, 188, 143],
+    darkslateblue: [72, 61, 139],
+    darkslategray: [47, 79, 79],
+    darkslategrey: [47, 79, 79],
+    darkturquoise: [0, 206, 209],
+    darkviolet: [148, 0, 211],
+    deeppink: [255, 20, 147],
+    deepskyblue: [0, 191, 255],
+    dimgray: [105, 105, 105],
+    dimgrey: [105, 105, 105],
+    dodgerblue: [30, 144, 255],
+    firebrick: [178, 34, 34],
+    floralwhite: [255, 250, 240],
+    forestgreen: [34, 139, 34],
+    fuchsia: [255, 0, 255],
+    gainsboro: [220, 220, 220],
+    ghostwhite: [248, 248, 255],
+    gold: [255, 215, 0],
+    goldenrod: [218, 165, 32],
+    gray: [128, 128, 128],
+    grey: [128, 128, 128],
+    green: [0, 128, 0],
+    greenyellow: [173, 255, 47],
+    honeydew: [240, 255, 240],
+    hotpink: [255, 105, 180],
+    indianred: [205, 92, 92],
+    indigo: [75, 0, 130],
+    ivory: [255, 255, 240],
+    khaki: [240, 230, 140],
+    lavender: [230, 230, 250],
+    lavenderblush: [255, 240, 245],
+    lawngreen: [124, 252, 0],
+    lemonchiffon: [255, 250, 205],
+    lightblue: [173, 216, 230],
+    lightcoral: [240, 128, 128],
+    lightcyan: [224, 255, 255],
+    lightgoldenrodyellow: [250, 250, 210],
+    lightgray: [211, 211, 211],
+    lightgreen: [144, 238, 144],
+    lightgrey: [211, 211, 211],
+    lightpink: [255, 182, 193],
+    lightsalmon: [255, 160, 122],
+    lightseagreen: [32, 178, 170],
+    lightskyblue: [135, 206, 250],
+    lightslategray: [119, 136, 153],
+    lightslategrey: [119, 136, 153],
+    lightsteelblue: [176, 196, 222],
+    lightyellow: [255, 255, 224],
+    lime: [0, 255, 0],
+    limegreen: [50, 205, 50],
+    linen: [250, 240, 230],
+    magenta: [255, 0, 255],
+    maroon: [128, 0, 0],
+    mediumaquamarine: [102, 205, 170],
+    mediumblue: [0, 0, 205],
+    mediumorchid: [186, 85, 211],
+    mediumpurple: [147, 112, 219],
+    mediumseagreen: [60, 179, 113],
+    mediumslateblue: [123, 104, 238],
+    mediumspringgreen: [0, 250, 154],
+    mediumturquoise: [72, 209, 204],
+    mediumvioletred: [199, 21, 133],
+    midnightblue: [25, 25, 112],
+    mintcream: [245, 255, 250],
+    mistyrose: [255, 228, 225],
+    moccasin: [255, 228, 181],
+    navajowhite: [255, 222, 173],
+    navy: [0, 0, 128],
+    oldlace: [253, 245, 230],
+    olive: [128, 128, 0],
+    olivedrab: [107, 142, 35],
+    orange: [255, 165, 0],
+    orangered: [255, 69, 0],
+    orchid: [218, 112, 214],
+    palegoldenrod: [238, 232, 170],
+    palegreen: [152, 251, 152],
+    paleturquoise: [175, 238, 238],
+    palevioletred: [219, 112, 147],
+    papayawhip: [255, 239, 213],
+    peachpuff: [255, 218, 185],
+    peru: [205, 133, 63],
+    pink: [255, 192, 203],
+    plum: [221, 160, 221],
+    powderblue: [176, 224, 230],
+    purple: [128, 0, 128],
+    rebeccapurple: [102, 51, 153],
+    red: [255, 0, 0],
+    rosybrown: [188, 143, 143],
+    royalblue: [65, 105, 225],
+    saddlebrown: [139, 69, 19],
+    salmon: [250, 128, 114],
+    sandybrown: [244, 164, 96],
+    seagreen: [46, 139, 87],
+    seashell: [255, 245, 238],
+    sienna: [160, 82, 45],
+    silver: [192, 192, 192],
+    skyblue: [135, 206, 235],
+    slateblue: [106, 90, 205],
+    slategray: [112, 128, 144],
+    slategrey: [112, 128, 144],
+    snow: [255, 250, 250],
+    springgreen: [0, 255, 127],
+    steelblue: [70, 130, 180],
+    tan: [210, 180, 140],
+    teal: [0, 128, 128],
+    thistle: [216, 191, 216],
+    tomato: [255, 99, 71],
+    turquoise: [64, 224, 208],
+    violet: [238, 130, 238],
+    wheat: [245, 222, 179],
+    white: [255, 255, 255],
+    whitesmoke: [245, 245, 245],
+    yellow: [255, 255, 0],
+    yellowgreen: [154, 205, 50],
+};
+/**
+ * Get RGB values for a CSS color name
+ * @param name - CSS color name (case-insensitive)
+ * @returns RGB tuple [r, g, b] or undefined if not found
+ */
+export function getNamedColor(name) {
+    const color = CSS_COLORS[name.toLowerCase()];
+    return color;
+}
+/**
+ * Convert RGBA values to hex format
+ * @param r - Red channel (0-255)
+ * @param g - Green channel (0-255)
+ * @param b - Blue channel (0-255)
+ * @param a - Alpha channel (0-1)
+ * @returns Hex color string in format #RRGGBBAA
+ */
+export function rgbaToHex(r, g, b, a) {
+    const red = channelToHex(r);
+    const green = channelToHex(g);
+    const blue = channelToHex(b);
+    const alpha = channelToHex(Math.round(a * 255));
+    return `#${red}${green}${blue}${alpha}`;
+}
+/**
+ * Convert a single color channel value to hex
+ * @param value - Channel value (0-255)
+ * @returns Two-digit hex string
+ */
+export function channelToHex(value) {
+    const clamped = Math.max(0, Math.min(255, Math.round(value)));
+    return clamped.toString(16).padStart(2, '0').toUpperCase();
+}
+/**
+ * Clamp RGB channel value to valid range
+ * @param value - Channel value
+ * @returns Clamped value (0-255)
+ */
+export function clampColorChannel(value) {
+    if (Number.isNaN(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(255, value));
+}
+/**
+ * Clamp alpha value to valid range
+ * @param value - Alpha value
+ * @returns Clamped value (0-1)
+ */
+export function clampAlpha(value) {
+    if (Number.isNaN(value)) {
+        return 1;
+    }
+    return Math.max(0, Math.min(1, value));
+}
+/**
+ * Convert any color format to hex
+ * Supports: hex (#RGB, #RRGGBB, #RRGGBBAA), RGB/RGBA, and CSS color names
+ * @param value - Color string in any supported format
+ * @returns Hex color string (#RRGGBBAA) or undefined if invalid
+ */
+export function toHexColor(value) {
+    // Try hex format
+    const hexMatch = value.match(/^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
+    if (hexMatch) {
+        const hex = hexMatch[1];
+        if (hex.length === 3 || hex.length === 4) {
+            return `#${hex
+                .split('')
+                .map((char) => char + char)
+                .join('')}`;
+        }
+        return `#${hex}`;
+    }
+    // Try RGB/RGBA format
+    const rgbMatch = value.match(/^rgba?\((.+)\)$/i);
+    if (rgbMatch) {
+        const parts = rgbMatch[1]
+            .split(',')
+            .map((part) => part.trim())
+            .filter(Boolean);
+        if (parts.length === 3 || parts.length === 4) {
+            const [r, g, b, a] = parts;
+            const red = clampColorChannel(parseFloat(r));
+            const green = clampColorChannel(parseFloat(g));
+            const blue = clampColorChannel(parseFloat(b));
+            const alpha = parts.length === 4 ? clampAlpha(parseFloat(a)) : 1;
+            return rgbaToHex(red, green, blue, alpha);
+        }
+    }
+    // Try CSS color name
+    const rgb = getNamedColor(value);
+    if (rgb) {
+        return rgbaToHex(rgb[0], rgb[1], rgb[2], 1);
+    }
+    return undefined;
+}
+/**
+ * Darken a hex color by a specified amount
+ * @param hex - Hex color string
+ * @param amount - Amount to darken (0-255)
+ * @returns Darkened hex color
+ */
+export function darkenColor(hex, amount) {
+    const normalized = ensureAlphaChannel(hex).substring(1); // strip #
+    const rgb = normalized.substring(0, 6);
+    const alpha = normalized.substring(6) || 'FF';
+    const r = parseInt(rgb.substring(0, 2), 16);
+    const g = parseInt(rgb.substring(2, 4), 16);
+    const b = parseInt(rgb.substring(4, 6), 16);
+    const clamp = (val) => Math.max(0, Math.min(255, val));
+    const newR = clamp(r - amount);
+    const newG = clamp(g - amount);
+    const newB = clamp(b - amount);
+    return `#${channelToHex(newR)}${channelToHex(newG)}${channelToHex(newB)}${alpha.toUpperCase()}`;
+}
+/**
+ * Lighten a hex color by a specified amount
+ * @param hex - Hex color string
+ * @param amount - Amount to lighten (0-255)
+ * @returns Lightened hex color
+ */
+export function lightenColor(hex, amount) {
+    const normalized = ensureAlphaChannel(hex).substring(1); // strip #
+    const rgb = normalized.substring(0, 6);
+    const alpha = normalized.substring(6) || 'FF';
+    const r = parseInt(rgb.substring(0, 2), 16);
+    const g = parseInt(rgb.substring(2, 4), 16);
+    const b = parseInt(rgb.substring(4, 6), 16);
+    const clamp = (val) => Math.max(0, Math.min(255, val));
+    const newR = clamp(r + amount);
+    const newG = clamp(g + amount);
+    const newB = clamp(b + amount);
+    return `#${channelToHex(newR)}${channelToHex(newG)}${channelToHex(newB)}${alpha.toUpperCase()}`;
+}
+/**
+ * Convert hex color to RGBA object
+ * @param hex - Hex color string (#RRGGBB or #RRGGBBAA)
+ * @returns RGBA object with r, g, b, a properties (0-1 for alpha)
+ */
+export function hexToRgba(hex) {
+    const normalized = ensureAlphaChannel(hex).substring(1); // strip #
+    const rgb = normalized.substring(0, 6);
+    const alphaHex = normalized.substring(6) || 'FF';
+    const r = parseInt(rgb.substring(0, 2), 16);
+    const g = parseInt(rgb.substring(2, 4), 16);
+    const b = parseInt(rgb.substring(4, 6), 16);
+    const a = parseInt(alphaHex, 16) / 255;
+    return { r, g, b, a };
+}
+/**
+ * Normalize any color format to Grid3's 8-digit hex format
+ * @param input - Color string in any supported format
+ * @param fallback - Fallback color if input is invalid (default: white)
+ * @returns Normalized color in format #AARRGGBBFF
+ */
+export function normalizeColor(input, fallback = '#FFFFFFFF') {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return fallback;
+    }
+    const hex = toHexColor(trimmed);
+    if (hex) {
+        return ensureAlphaChannel(hex).toUpperCase();
+    }
+    return fallback;
+}
+/**
+ * Ensure a color has an alpha channel (Grid3 format requires 8-digit ARGB)
+ * @param color - Color string (hex format)
+ * @returns Color with alpha channel in format #AARRGGBBFF
+ */
+export function ensureAlphaChannel(color) {
+    if (!color)
+        return '#FFFFFFFF';
+    // If already 8 digits (with alpha), return as is
+    if (color.match(/^#[0-9A-Fa-f]{8}$/))
+        return color;
+    // If 6 digits (no alpha), add FF for fully opaque
+    if (color.match(/^#[0-9A-Fa-f]{6}$/))
+        return color + 'FF';
+    // If 3 digits (shorthand), expand to 8
+    if (color.match(/^#[0-9A-Fa-f]{3}$/)) {
+        const r = color[1];
+        const g = color[2];
+        const b = color[3];
+        return `#${r}${r}${g}${g}${b}${b}FF`;
+    }
+    // Invalid or unknown format, return white
+    return '#FFFFFFFF';
+}

package/dist/browser/processors/gridset/helpers.js

@@ -1,12 +1,10 @@
 import { XMLBuilder } from 'fast-xml-parser';
 import { AACSemanticCategory, AACSemanticIntent, } from '../../core/treeStructure';
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import Database from 'better-sqlite3';
 import { dotNetTicksToDate } from '../../utils/dotnetTicks';
 import { getZipEntriesFromAdapter, resolveGridsetPasswordFromEnv } from './password';
-import { openZipFromInput } from '../../utils/zip';
+import { defaultFileAdapter, extname, getNodeRequire, joinWin32, } from '../../utils/io';
+import { getZipAdapter } from '../../utils/zip';
+import { requireBetterSqlite3 } from '../../utils/sqlite';
 function normalizeZipPath(p) {
     const unified = p.replace(/\\/g, '/');
     try {
@@ -52,11 +50,11 @@ export function getAllowedImageEntries(tree) {
  * @param entryPath Entry name inside the zip
  * @returns Image data buffer or null if not found
  */
-export async function openImage(gridsetBuffer, entryPath, password = resolveGridsetPasswordFromEnv(), zipAdapter) {
+export async function openImage(gridsetBuffer, entryPath, password = resolveGridsetPasswordFromEnv(), fileAdapter = defaultFileAdapter, zipAdapter) {
     try {
-        const { zip } = zipAdapter
+        const zip = zipAdapter
             ? await zipAdapter(gridsetBuffer)
-            : await openZipFromInput(gridsetBuffer);
+            : await getZipAdapter(gridsetBuffer, fileAdapter);
         const entries = getZipEntriesFromAdapter(zip, password);
         const want = normalizeZipPath(entryPath);
         const entry = entries.find((e) => normalizeZipPath(e.entryName) === want);
@@ -149,8 +147,9 @@ export function getCommonDocumentsPath() {
     }
     try {
         // Query registry for Common Documents path
+        const child_process = getNodeRequire()('child_process');
         const command = 'REG.EXE QUERY "HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders" /V "Common Documents"';
-        const output = execSync(command, { encoding: 'utf-8', windowsHide: true });
+        const output = child_process.execSync(command, { encoding: 'utf-8', windowsHide: true });
         // Parse the output to extract the path
         const match = output.match(/Common Documents\s+REG_SZ\s+(.+)/);
         if (match && match[1]) {
@@ -171,7 +170,8 @@ export function getCommonDocumentsPath() {
  * C:\Users\Public\Documents\Smartbox\Grid 3\Users\{UserName}\Grid Sets\
  * @returns Array of Grid3 user path information
  */
-export function findGrid3UserPaths() {
+export async function findGrid3UserPaths(fileAdapter = defaultFileAdapter) {
+    const { pathExists, listDir, isDirectory } = fileAdapter;
     const results = [];
     // Only works on Windows
     if (process.platform !== 'win32') {
@@ -180,28 +180,28 @@ export function findGrid3UserPaths() {
     try {
         const commonDocs = getCommonDocumentsPath();
         // Use Windows path joining so tests that mock a Windows platform stay consistent even on POSIX runners
-        const grid3BasePath = path.win32.join(commonDocs, 'Smartbox', 'Grid 3', 'Users');
+        const grid3BasePath = joinWin32(commonDocs, 'Smartbox', 'Grid 3', 'Users');
         // Check if Grid3 Users directory exists
-        if (!fs.existsSync(grid3BasePath)) {
+        if (!(await pathExists(grid3BasePath))) {
             return results;
         }
         // Enumerate users
-        const users = fs.readdirSync(grid3BasePath, { withFileTypes: true });
+        const users = await listDir(grid3BasePath);
         for (const userDir of users) {
-            if (!userDir.isDirectory())
+            if (!(await isDirectory(userDir)))
                 continue;
-            const userName = userDir.name;
-            const userPath = path.win32.join(grid3BasePath, userName);
+            const userName = userDir;
+            const userPath = joinWin32(grid3BasePath, userName);
             // Enumerate language codes
-            const langDirs = fs.readdirSync(userPath, { withFileTypes: true });
+            const langDirs = await listDir(userPath);
             for (const langDir of langDirs) {
-                if (!langDir.isDirectory())
+                if (!(await isDirectory(langDir)))
                     continue;
-                const langCode = langDir.name;
-                const basePath = path.win32.join(userPath, langCode);
-                const historyDbPath = path.win32.join(basePath, 'Phrases', 'history.sqlite');
+                const langCode = langDir;
+                const basePath = joinWin32(userPath, langCode);
+                const historyDbPath = joinWin32(basePath, 'Phrases', 'history.sqlite');
                 // Only include if history database exists
-                if (fs.existsSync(historyDbPath)) {
+                if (await pathExists(historyDbPath)) {
                     results.push({
                         userName,
                         langCode,
@@ -222,50 +222,52 @@ export function findGrid3UserPaths() {
  * Convenience method that returns just the database file paths
  * @returns Array of paths to history.sqlite files
  */
-export function findGrid3HistoryDatabases() {
-    return findGrid3UserPaths().map((userPath) => userPath.historyDbPath);
+export async function findGrid3HistoryDatabases(fileAdapter) {
+    const userPaths = await findGrid3UserPaths(fileAdapter);
+    return userPaths.map((userPath) => userPath.historyDbPath);
 }
 /**
  * Get Grid 3 users (alias of findGrid3UserPaths for clarity)
  */
-export function findGrid3Users() {
-    return findGrid3UserPaths();
+export async function findGrid3Users() {
+    return await findGrid3UserPaths();
 }
 /**
  * Find Grid 3 gridset/vocabulary files for each user
  * @param userName Optional user filter; matches case-insensitively
  * @returns Array of user/gridset path pairs
  */
-export function findGrid3Vocabularies(userName) {
+export async function findGrid3Vocabularies(userName, fileAdapter = defaultFileAdapter) {
+    const { pathExists, listDir, isDirectory } = fileAdapter;
     const results = [];
     if (process.platform !== 'win32') {
         return results;
     }
     const commonDocs = getCommonDocumentsPath();
-    const grid3BasePath = path.win32.join(commonDocs, 'Smartbox', 'Grid 3', 'Users');
-    if (!fs.existsSync(grid3BasePath)) {
+    const grid3BasePath = joinWin32(commonDocs, 'Smartbox', 'Grid 3', 'Users');
+    if (!(await pathExists(grid3BasePath))) {
         return results;
     }
     const normalizedUser = userName?.toLowerCase();
-    const users = fs.readdirSync(grid3BasePath, { withFileTypes: true });
+    const users = await listDir(grid3BasePath);
     for (const userDir of users) {
-        if (!userDir.isDirectory())
+        if (!(await isDirectory(userDir)))
             continue;
-        if (normalizedUser && userDir.name.toLowerCase() !== normalizedUser)
+        if (normalizedUser && userDir.toLowerCase() !== normalizedUser)
             continue;
-        const userRoot = path.win32.join(grid3BasePath, userDir.name);
-        const gridSetsDir = path.win32.join(userRoot, 'Grid Sets');
-        if (!fs.existsSync(gridSetsDir))
+        const userRoot = joinWin32(grid3BasePath, userDir);
+        const gridSetsDir = joinWin32(userRoot, 'Grid Sets');
+        if (!(await pathExists(gridSetsDir)))
             continue;
-        const entries = fs.readdirSync(gridSetsDir, { withFileTypes: true });
+        const entries = await listDir(gridSetsDir);
         for (const entry of entries) {
-            if (!entry.isFile())
+            if (!(await pathExists(entry)) || (await isDirectory(entry)))
                 continue;
-            const ext = path.extname(entry.name).toLowerCase();
+            const ext = extname(entry).toLowerCase();
             if (ext === '.gridset' || ext === '.gridsetx' || ext === '.grd' || ext === '.grdl') {
                 results.push({
-                    userName: userDir.name,
-                    gridsetPath: path.win32.join(gridSetsDir, entry.name),
+                    userName: userDir,
+                    gridsetPath: joinWin32(gridSetsDir, entry),
                 });
             }
         }
@@ -278,26 +280,28 @@ export function findGrid3Vocabularies(userName) {
  * @param langCode Optional language code filter (case-insensitive)
  * @returns Path to history.sqlite or null if not found
  */
-export function findGrid3UserHistory(userName, langCode) {
+export async function findGrid3UserHistory(userName, langCode, fileAdapter) {
     if (!userName)
         return null;
     const normalizedUser = userName.toLowerCase();
     const normalizedLang = langCode?.toLowerCase();
-    const match = findGrid3UserPaths().find((u) => u.userName.toLowerCase() === normalizedUser &&
+    const userPaths = await findGrid3UserPaths(fileAdapter);
+    const match = userPaths.find((u) => u.userName.toLowerCase() === normalizedUser &&
         (!normalizedLang || u.langCode.toLowerCase() === normalizedLang));
     return match?.historyDbPath ?? null;
 }
 /**
  * Check whether Grid 3 appears to be installed (Windows only)
  */
-export function isGrid3Installed() {
+export async function isGrid3Installed(fileAdapter = defaultFileAdapter) {
+    const { pathExists } = fileAdapter;
     if (process.platform !== 'win32')
         return false;
     const commonDocs = getCommonDocumentsPath();
     if (!commonDocs)
         return false;
-    const grid3BasePath = path.win32.join(commonDocs, 'Smartbox', 'Grid 3', 'Users');
-    return fs.existsSync(grid3BasePath);
+    const grid3BasePath = joinWin32(commonDocs, 'Smartbox', 'Grid 3', 'Users');
+    return await pathExists(grid3BasePath);
 }
 function parseGrid3ContentXml(xmlContent) {
     const regex = /<r>(?:<!\[CDATA\[)?(.*?)(?:\]\]>)?<\/r>/gis;
@@ -316,9 +320,11 @@ function parseGrid3ContentXml(xmlContent) {
  * @param historyDbPath Absolute path to the history database
  * @returns Parsed history entries grouped by phrase
  */
-export function readGrid3History(historyDbPath) {
-    if (!fs.existsSync(historyDbPath))
+export async function readGrid3History(historyDbPath, fileAdapter = defaultFileAdapter) {
+    const { pathExists } = fileAdapter;
+    if (!(await pathExists(historyDbPath)))
         return [];
+    const Database = requireBetterSqlite3();
     const db = new Database(historyDbPath, { readonly: true });
     const rows = db
         .prepare(`
@@ -376,17 +382,18 @@ export function readGrid3History(historyDbPath) {
  * @param langCode Optional language code to narrow selection (case-insensitive)
  * @returns History entries for that user/language, or empty array if none
  */
-export function readGrid3HistoryForUser(userName, langCode) {
-    const dbPath = findGrid3UserHistory(userName, langCode);
+export async function readGrid3HistoryForUser(userName, langCode) {
+    const dbPath = await findGrid3UserHistory(userName, langCode);
     if (!dbPath)
         return [];
-    return readGrid3History(dbPath);
+    return await readGrid3History(dbPath);
 }
 /**
  * Load all available Grid 3 histories on the machine.
  * @returns Combined history entries from every discovered history.sqlite
  */
-export function readAllGrid3History() {
-    const paths = findGrid3HistoryDatabases();
-    return paths.flatMap((p) => readGrid3History(p));
+export async function readAllGrid3History() {
+    const paths = await findGrid3HistoryDatabases();
+    const history = await Promise.all(paths.map(async (p) => await readGrid3History(p)));
+    return history.flat();
 }

package/dist/browser/processors/gridset/index.js

@@ -0,0 +1,61 @@
+/**
+ * Grid 3 Enhanced Support Module
+ *
+ * This module exports all enhanced Grid 3 functionality including:
+ * - Cell shape detection and support
+ * - Plugin cell type detection (Workspace, LiveCell, AutoContent)
+ * - Comprehensive command definitions and detection
+ * - Color utilities and style helpers
+ * - Image resolution helpers
+ */
+// Style helpers
+export { CellBackgroundShape, SHAPE_NAMES, DEFAULT_GRID3_STYLES, CATEGORY_STYLES, createDefaultStylesXml, createCategoryStyle, } from './styleHelpers';
+// Plugin cell type detection
+export { detectPluginCellType, Grid3CellType, WORKSPACE_TYPES, LIVECELL_TYPES, AUTOCONTENT_TYPES, getCellTypeDisplayName, isWorkspaceCell, isLiveCell, isAutoContentCell, isRegularCell, } from './pluginTypes';
+// Command definitions and detection
+export { detectCommand, getCommandDefinition, getCommandsByPlugin, getCommandsByCategory, getAllCommandIds, getAllPluginIds, extractCommandParameters, GRID3_COMMANDS, Grid3CommandCategory, } from './commands';
+// Import for local use in constant definitions
+import { getAllCommandIds, getAllPluginIds } from './commands';
+import { CellBackgroundShape } from './styleHelpers';
+import { Grid3CellType } from './pluginTypes';
+import { Grid3CommandCategory } from './commands';
+// Color utilities
+export { ensureAlphaChannel, darkenColor, lightenColor, hexToRgba, rgbaToHex } from './colorUtils';
+// Password handling
+export { resolveGridsetPassword, getZipEntriesWithPassword, getZipEntriesFromAdapter, resolveGridsetPasswordFromEnv, } from './password';
+// Helper functions
+export { getPageTokenImageMap, getAllowedImageEntries, openImage, generateGrid3Guid, createSettingsXml, createFileMapXml, getCommonDocumentsPath, findGrid3UserPaths, findGrid3HistoryDatabases, findGrid3Vocabularies, findGrid3UserHistory, findGrid3Users, isGrid3Installed, readGrid3History, readGrid3HistoryForUser, readAllGrid3History, } from './helpers';
+// Symbol library handling
+export { parseSymbolReference, isSymbolReference, resolveSymbolReference, getAvailableSymbolLibraries, getSymbolLibraryInfo, extractSymbolReferences, analyzeSymbolUsage, createSymbolReference, getSymbolLibraryName, getSymbolPath, isKnownSymbolLibrary, getSymbolLibraryDisplayName, getDefaultGrid3Path, getSymbolLibrariesDir, getSymbolSearchIndexesDir, symbolReferenceToFilename, SYMBOL_LIBRARIES, } from './symbols';
+// Backward compatibility aliases for old function names
+export { getSymbolsDir, getSymbolSearchDir } from './symbols';
+// Image resolution
+export { resolveGrid3CellImage, isSymbolLibraryReference, parseImageSymbolReference, } from './resolver';
+// Symbol extraction and conversion
+export { extractButtonImage, extractSymbolLibraryImage, convertToAstericsImage, analyzeSymbolExtraction, suggestExtractionStrategy, exportSymbolReferencesToCsv, createSymbolManifest, } from './symbolExtractor';
+// Symbol search functionality
+export { parsePixFile, loadSearchIndexes, searchSymbols, searchSymbolsWithReferences, getSymbolFilename, getSymbolDisplayName, getAllSearchTerms, getSearchSuggestions, countLibrarySymbols, getSymbolSearchStats, } from './symbolSearch';
+/**
+ * Get all Grid 3 command IDs as a readonly array
+ * Useful for validation and autocomplete
+ */
+export const GRID3_COMMAND_IDS = Object.freeze(getAllCommandIds());
+/**
+ * Get all Grid 3 plugin IDs as a readonly array
+ */
+export const GRID3_PLUGIN_IDS = Object.freeze(getAllPluginIds());
+/**
+ * Grid 3 cell shapes enum values
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const GRID3_CELL_SHAPES = Object.freeze(Object.values(CellBackgroundShape));
+/**
+ * Grid 3 cell types enum values
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const GRID3_CELL_TYPES = Object.freeze(Object.values(Grid3CellType));
+/**
+ * Grid 3 command categories enum values
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const GRID3_COMMAND_CATEGORIES = Object.freeze(Object.values(Grid3CommandCategory));