@willwade/aac-processors 0.0.5 → 0.0.7

package/dist/processors/excelProcessor.js

@@ -32,7 +32,6 @@ const path_1 = __importDefault(require("path"));
 const ExcelJS = __importStar(require("exceljs"));
 const baseProcessor_1 = require("../core/baseProcessor");
 const treeStructure_1 = require("../core/treeStructure");
-const treeStructure_2 = require("../core/treeStructure");
 /**
  * Excel Processor for converting AAC grids to Excel format
  * Converts AAC tree structures to Excel workbooks with each page as a worksheet
@@ -44,47 +43,18 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param filePathOrBuffer - Path to Excel file or Buffer containing Excel data
      * @returns Array of all text content found in the Excel file
      */
-    extractTexts(filePathOrBuffer) {
-        const texts = [];
-        try {
-            const workbook = new ExcelJS.Workbook();
-            if (Buffer.isBuffer(filePathOrBuffer)) {
-                // For buffer input, we need to read it differently
-                // This is a placeholder - actual implementation would need to handle buffer reading
-                throw new Error('Buffer input not yet implemented for Excel files');
-            }
-            else {
-                // Read from file path
-                if (!fs_1.default.existsSync(filePathOrBuffer)) {
-                    return texts;
-                }
-                // Note: ExcelJS readFile is async, but we need sync for this interface
-                // This is a limitation that would need to be addressed in a real implementation
-                throw new Error('Synchronous Excel reading not yet implemented');
-            }
-        }
-        catch (error) {
-            console.warn(`Failed to extract texts from Excel file: ${error}`);
-            return texts;
-        }
+    extractTexts(_filePathOrBuffer) {
+        console.warn('ExcelProcessor.extractTexts is not implemented yet.');
+        return [];
     }
     /**
      * Load Excel file into AACTree structure
      * @param filePathOrBuffer - Path to Excel file or Buffer containing Excel data
      * @returns AACTree representation of the Excel file
      */
-    loadIntoTree(filePathOrBuffer) {
-        const tree = new treeStructure_1.AACTree();
-        try {
-            // For now, return empty tree as Excel -> AAC conversion is not the primary use case
-            // This would be implemented if bidirectional conversion is needed
-            console.warn('Excel to AAC conversion not implemented - returning empty tree');
-            return tree;
-        }
-        catch (error) {
-            console.warn(`Failed to load Excel file into tree: ${error}`);
-            return tree;
-        }
+    loadIntoTree(_filePathOrBuffer) {
+        console.warn('ExcelProcessor.loadIntoTree is not implemented yet.');
+        return new treeStructure_1.AACTree();
     }
     /**
      * Process texts in Excel file (apply translations)
@@ -93,18 +63,13 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param outputPath - Path where translated Excel file should be saved
      * @returns Buffer containing the translated Excel file
      */
-    processTexts(filePathOrBuffer, translations, outputPath) {
-        try {
-            // Load the Excel file, apply translations, and save
-            // This would involve reading the Excel file, finding text cells,
-            // applying translations, and saving to outputPath
-            throw new Error('Excel text processing not yet implemented');
-        }
-        catch (error) {
-            console.warn(`Failed to process Excel texts: ${error}`);
-            // Return empty buffer as fallback
-            return Buffer.alloc(0);
+    processTexts(_filePathOrBuffer, _translations, outputPath) {
+        console.warn('ExcelProcessor.processTexts is not implemented yet.');
+        const outputDir = path_1.default.dirname(outputPath);
+        if (!fs_1.default.existsSync(outputDir)) {
+            fs_1.default.mkdirSync(outputDir, { recursive: true });
         }
+        return Buffer.alloc(0);
     }
     /**
      * Convert an AAC page to an Excel worksheet
@@ -113,7 +78,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param tree - Full AAC tree for navigation context
      * @param usedNames - Set of already used worksheet names to avoid duplicates
      */
-    async convertPageToWorksheet(workbook, page, tree, usedNames = new Set()) {
+    convertPageToWorksheet(workbook, page, tree, usedNames = new Set()) {
         // Create worksheet with page name (sanitized for Excel and unique)
         const worksheetName = this.getUniqueWorksheetName(page.name || page.id, usedNames);
         const worksheet = workbook.addWorksheet(worksheetName);
@@ -122,16 +87,16 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
         // Add navigation row if enabled (optional feature)
         let startRow = 1;
         if (this.shouldAddNavigationRow()) {
-            await this.addNavigationRow(worksheet, page, tree);
+            this.addNavigationRow(worksheet, page, tree);
             startRow = 2; // Start content after navigation row
         }
         // Convert grid layout if available
         if (page.grid && page.grid.length > 0) {
-            await this.convertGridLayout(worksheet, page.grid, startRow);
+            this.convertGridLayout(worksheet, page.grid, startRow);
         }
         else {
             // Convert button list to grid layout
-            await this.convertButtonsToGrid(worksheet, page.buttons, rows, cols, startRow);
+            this.convertButtonsToGrid(worksheet, page.buttons, rows, cols, startRow);
         }
         // Apply worksheet formatting
         this.formatWorksheet(worksheet, rows, cols, startRow);
@@ -165,14 +130,14 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param grid - 2D array of AAC buttons
      * @param startRow - Starting row number
      */
-    async convertGridLayout(worksheet, grid, startRow) {
+    convertGridLayout(worksheet, grid, startRow) {
         for (let row = 0; row < grid.length; row++) {
             for (let col = 0; col < grid[row].length; col++) {
                 const button = grid[row][col];
                 if (button) {
                     const excelRow = startRow + row;
                     const excelCol = col + 1; // Excel columns are 1-based
-                    await this.setButtonCell(worksheet, button, excelRow, excelCol);
+                    this.setButtonCell(worksheet, button, excelRow, excelCol);
                 }
             }
         }
@@ -185,7 +150,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param cols - Number of columns in grid
      * @param startRow - Starting row number
      */
-    async convertButtonsToGrid(worksheet, buttons, rows, cols, startRow) {
+    convertButtonsToGrid(worksheet, buttons, rows, cols, startRow) {
         for (let i = 0; i < buttons.length; i++) {
             const button = buttons[i];
             const row = Math.floor(i / cols);
@@ -193,7 +158,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
             if (row < rows) {
                 const excelRow = startRow + row;
                 const excelCol = col + 1; // Excel columns are 1-based
-                await this.setButtonCell(worksheet, button, excelRow, excelCol);
+                this.setButtonCell(worksheet, button, excelRow, excelCol);
             }
         }
     }
@@ -204,7 +169,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param row - Excel row number
      * @param col - Excel column number
      */
-    async setButtonCell(worksheet, button, row, col) {
+    setButtonCell(worksheet, button, row, col) {
         const cell = worksheet.getCell(row, col);
         // Set cell value to button label
         cell.value = button.label || '';
@@ -217,7 +182,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
             this.applyCellStyling(cell, button.style);
         }
         // Add navigation link if this is a navigation button
-        if (button.semanticAction?.intent === treeStructure_2.AACSemanticIntent.NAVIGATE_TO && button.targetPageId) {
+        if (button.semanticAction?.intent === treeStructure_1.AACSemanticIntent.NAVIGATE_TO && button.targetPageId) {
             this.addNavigationLink(cell, button.targetPageId);
         }
         // Set cell size for better visibility
@@ -229,14 +194,16 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param style - AAC style object
      */
     applyCellStyling(cell, style) {
-        const fill = {};
+        let fill;
         const font = {};
-        const border = {};
+        let border;
         // Background color
         if (style.backgroundColor) {
-            fill.type = 'pattern';
-            fill.pattern = 'solid';
-            fill.fgColor = { argb: this.convertColorToArgb(style.backgroundColor) };
+            fill = {
+                type: 'pattern',
+                pattern: 'solid',
+                fgColor: { argb: this.convertColorToArgb(style.backgroundColor) },
+            };
         }
         // Font color
         if (style.fontColor) {
@@ -263,24 +230,27 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
             font.underline = true;
         }
         // Border
-        if (style.borderColor || style.borderWidth) {
-            const borderStyle = style.borderWidth > 1 ? 'thick' : 'thin';
+        if (style.borderColor || typeof style.borderWidth === 'number') {
+            const borderWidth = style.borderWidth ?? 1;
+            const borderStyle = borderWidth > 1 ? 'thick' : 'thin';
             const borderColor = style.borderColor
                 ? { argb: this.convertColorToArgb(style.borderColor) }
                 : { argb: 'FF000000' }; // Default black
-            border.top = { style: borderStyle, color: borderColor };
-            border.left = { style: borderStyle, color: borderColor };
-            border.bottom = { style: borderStyle, color: borderColor };
-            border.right = { style: borderStyle, color: borderColor };
+            border = {
+                top: { style: borderStyle, color: borderColor },
+                left: { style: borderStyle, color: borderColor },
+                bottom: { style: borderStyle, color: borderColor },
+                right: { style: borderStyle, color: borderColor },
+            };
         }
         // Apply styling to cell
-        if (Object.keys(fill).length > 0) {
+        if (fill) {
             cell.fill = fill;
         }
         if (Object.keys(font).length > 0) {
             cell.font = font;
         }
-        if (Object.keys(border).length > 0) {
+        if (border) {
             cell.border = border;
         }
         // Center align text
@@ -369,7 +339,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
      * @param page - Current AAC page
      * @param tree - Full AAC tree for navigation context
      */
-    async addNavigationRow(worksheet, page, tree) {
+    addNavigationRow(worksheet, page, tree) {
         const navButtons = ExcelProcessor.NAVIGATION_BUTTONS;
         for (let i = 0; i < navButtons.length; i++) {
             const cell = worksheet.getCell(1, i + 1);
@@ -440,9 +410,9 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
         // - Max 31 characters
         // - Cannot contain: \ / ? * [ ] :
         // - Cannot be empty
-        const cleaned = (name || '')
-            .replace(/[\\\/\?\*\[\]:]/g, '_')
-            .substring(0, 31);
+        let cleaned = (name || '').replace(/[\\/?*:]/g, '_');
+        cleaned = cleaned.replace(/\[/g, '_').replace(/\]/g, '_');
+        cleaned = cleaned.substring(0, 31);
         if (cleaned.length === 0) {
             return 'Sheet1';
         }
@@ -499,11 +469,12 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
             await this.saveFromTreeAsync(tree, outputPath);
         }
         catch (error) {
-            console.error('Failed to save Excel file:', error);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error('Failed to save Excel file:', message);
             try {
                 const fallbackPath = outputPath.replace(/\.xlsx$/i, '_error.txt');
                 fs_1.default.mkdirSync(path_1.default.dirname(fallbackPath), { recursive: true });
-                fs_1.default.writeFileSync(fallbackPath, `Error saving Excel file: ${error?.message || String(error)}`);
+                fs_1.default.writeFileSync(fallbackPath, `Error saving Excel file: ${message}`);
             }
             catch (writeError) {
                 console.error('Failed to write Excel error file:', writeError);
@@ -532,7 +503,7 @@ class ExcelProcessor extends baseProcessor_1.BaseProcessor {
         // Convert each AAC page to an Excel worksheet
         for (const pageId in tree.pages) {
             const page = tree.pages[pageId];
-            await this.convertPageToWorksheet(workbook, page, tree, usedNames);
+            this.convertPageToWorksheet(workbook, page, tree, usedNames);
         }
         // Save the workbook
         await workbook.xlsx.writeFile(outputPath);

package/dist/processors/gridset/colorUtils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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)
+ */
+/**
+ * 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 declare function getNamedColor(name: string): [number, number, number] | undefined;
+/**
+ * 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 declare function rgbaToHex(r: number, g: number, b: number, a: number): string;
+/**
+ * Convert a single color channel value to hex
+ * @param value - Channel value (0-255)
+ * @returns Two-digit hex string
+ */
+export declare function channelToHex(value: number): string;
+/**
+ * Clamp RGB channel value to valid range
+ * @param value - Channel value
+ * @returns Clamped value (0-255)
+ */
+export declare function clampColorChannel(value: number): number;
+/**
+ * Clamp alpha value to valid range
+ * @param value - Alpha value
+ * @returns Clamped value (0-1)
+ */
+export declare function clampAlpha(value: number): number;
+/**
+ * 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 declare function toHexColor(value: string): string | 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 declare function darkenColor(hex: string, amount: number): string;
+/**
+ * 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 declare function normalizeColor(input: string, fallback?: string): string;
+/**
+ * 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 declare function ensureAlphaChannel(color: string | undefined): string;

package/dist/processors/gridset/colorUtils.js

@@ -0,0 +1,331 @@
+"use strict";
+/**
+ * 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)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamedColor = getNamedColor;
+exports.rgbaToHex = rgbaToHex;
+exports.channelToHex = channelToHex;
+exports.clampColorChannel = clampColorChannel;
+exports.clampAlpha = clampAlpha;
+exports.toHexColor = toHexColor;
+exports.darkenColor = darkenColor;
+exports.normalizeColor = normalizeColor;
+exports.ensureAlphaChannel = ensureAlphaChannel;
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+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)
+ */
+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)
+ */
+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
+ */
+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
+ */
+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()}`;
+}
+/**
+ * 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
+ */
+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
+ */
+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';
+}