@willwade/aac-processors 0.1.20 → 0.1.21

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 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 (!pathExists(grid3BasePath)) {
             return results;
         }
         // Enumerate users
-        const users = fs.readdirSync(grid3BasePath, { withFileTypes: true });
+        const users = listDir(grid3BasePath);
         for (const userDir of users) {
-            if (!userDir.isDirectory())
+            if (!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 = listDir(userPath);
             for (const langDir of langDirs) {
-                if (!langDir.isDirectory())
+                if (!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 (pathExists(historyDbPath)) {
                     results.push({
                         userName,
                         langCode,
@@ -222,8 +222,8 @@ 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 function findGrid3HistoryDatabases(fileAdapter) {
+    return findGrid3UserPaths(fileAdapter).map((userPath) => userPath.historyDbPath);
 }
 /**
  * Get Grid 3 users (alias of findGrid3UserPaths for clarity)
@@ -236,36 +236,37 @@ export function findGrid3Users() {
  * @param userName Optional user filter; matches case-insensitively
  * @returns Array of user/gridset path pairs
  */
-export function findGrid3Vocabularies(userName) {
+export 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 (!pathExists(grid3BasePath)) {
         return results;
     }
     const normalizedUser = userName?.toLowerCase();
-    const users = fs.readdirSync(grid3BasePath, { withFileTypes: true });
+    const users = listDir(grid3BasePath);
     for (const userDir of users) {
-        if (!userDir.isDirectory())
+        if (!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 (!pathExists(gridSetsDir))
             continue;
-        const entries = fs.readdirSync(gridSetsDir, { withFileTypes: true });
+        const entries = listDir(gridSetsDir);
         for (const entry of entries) {
-            if (!entry.isFile())
+            if (!pathExists(entry) || 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 +279,27 @@ 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 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 match = findGrid3UserPaths(fileAdapter).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 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 pathExists(grid3BasePath);
 }
 function parseGrid3ContentXml(xmlContent) {
     const regex = /<r>(?:<!\[CDATA\[)?(.*?)(?:\]\]>)?<\/r>/gis;
@@ -316,9 +318,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 function readGrid3History(historyDbPath, fileAdapter = defaultFileAdapter) {
+    const { pathExists } = fileAdapter;
+    if (!pathExists(historyDbPath))
         return [];
+    const Database = requireBetterSqlite3();
     const db = new Database(historyDbPath, { readonly: true });
     const rows = db
         .prepare(`

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));

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

@@ -0,0 +1,205 @@
+/**
+ * Grid3 Style Helpers
+ *
+ * Utilities for creating and managing Grid3 styles, including default styles,
+ * style XML generation, and style conversion utilities.
+ */
+import { XMLBuilder } from 'fast-xml-parser';
+import { ensureAlphaChannel, darkenColor } from './colorUtils';
+/**
+ * Cell background shapes supported by Grid 3
+ * Maps to Grid 3's CellBackgroundShape enum
+ */
+export var CellBackgroundShape;
+(function (CellBackgroundShape) {
+    CellBackgroundShape[CellBackgroundShape["Rectangle"] = 0] = "Rectangle";
+    CellBackgroundShape[CellBackgroundShape["RoundedRectangle"] = 1] = "RoundedRectangle";
+    CellBackgroundShape[CellBackgroundShape["FoldedCorner"] = 2] = "FoldedCorner";
+    CellBackgroundShape[CellBackgroundShape["Octagon"] = 3] = "Octagon";
+    CellBackgroundShape[CellBackgroundShape["Folder"] = 4] = "Folder";
+    CellBackgroundShape[CellBackgroundShape["Ellipse"] = 5] = "Ellipse";
+    CellBackgroundShape[CellBackgroundShape["SpeechBubble"] = 6] = "SpeechBubble";
+    CellBackgroundShape[CellBackgroundShape["ThoughtBubble"] = 7] = "ThoughtBubble";
+    CellBackgroundShape[CellBackgroundShape["Star"] = 8] = "Star";
+    CellBackgroundShape[CellBackgroundShape["Circle"] = 9] = "Circle";
+    CellBackgroundShape[CellBackgroundShape["ColouredCorner"] = 10] = "ColouredCorner";
+})(CellBackgroundShape || (CellBackgroundShape = {}));
+/**
+ * Human-readable shape names
+ */
+export const SHAPE_NAMES = {
+    [CellBackgroundShape.Rectangle]: 'Rectangle',
+    [CellBackgroundShape.RoundedRectangle]: 'Rounded Rectangle',
+    [CellBackgroundShape.FoldedCorner]: 'Folded Corner',
+    [CellBackgroundShape.Octagon]: 'Octagon',
+    [CellBackgroundShape.Folder]: 'Folder',
+    [CellBackgroundShape.Ellipse]: 'Ellipse',
+    [CellBackgroundShape.SpeechBubble]: 'Speech Bubble',
+    [CellBackgroundShape.ThoughtBubble]: 'Thought Bubble',
+    [CellBackgroundShape.Star]: 'Star',
+    [CellBackgroundShape.Circle]: 'Circle',
+    [CellBackgroundShape.ColouredCorner]: 'Coloured Corner',
+};
+/**
+ * Default Grid3 styles for common use cases
+ * Colors are in 8-digit ARGB hex format (#AARRGGBBFF)
+ */
+export const DEFAULT_GRID3_STYLES = {
+    Default: {
+        BackColour: '#E2EDF8FF',
+        TileColour: '#FFFFFFFF',
+        BorderColour: '#000000FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    Workspace: {
+        BackColour: '#FFFFFFFF',
+        TileColour: '#FFFFFFFF',
+        BorderColour: '#CCCCCCFF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '14',
+    },
+    'Auto content': {
+        BackColour: '#E8F4F8FF',
+        TileColour: '#E8F4F8FF',
+        BorderColour: '#2C82C9FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '14',
+    },
+    'Vocab cell': {
+        BackColour: '#E8F4F8FF',
+        TileColour: '#E8F4F8FF',
+        BorderColour: '#2C82C9FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '14',
+    },
+    'Keyboard key': {
+        BackColour: '#F0F0F0FF',
+        TileColour: '#F0F0F0FF',
+        BorderColour: '#808080FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '12',
+    },
+};
+/**
+ * Category-specific styles for navigation and organization
+ */
+export const CATEGORY_STYLES = {
+    'Actions category style': {
+        BackColour: '#4472C4FF',
+        TileColour: '#4472C4FF',
+        BorderColour: '#2F5496FF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'People category style': {
+        BackColour: '#ED7D31FF',
+        TileColour: '#ED7D31FF',
+        BorderColour: '#C65911FF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Places category style': {
+        BackColour: '#A5A5A5FF',
+        TileColour: '#A5A5A5FF',
+        BorderColour: '#595959FF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Descriptive category style': {
+        BackColour: '#70AD47FF',
+        TileColour: '#70AD47FF',
+        BorderColour: '#4F7C2FFF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Social category style': {
+        BackColour: '#FFC000FF',
+        TileColour: '#FFC000FF',
+        BorderColour: '#BF8F00FF',
+        FontColour: '#000000FF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Questions category style': {
+        BackColour: '#5B9BD5FF',
+        TileColour: '#5B9BD5FF',
+        BorderColour: '#2E5C8AFF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+    'Little words category style': {
+        BackColour: '#C55A11FF',
+        TileColour: '#C55A11FF',
+        BorderColour: '#8B3F0AFF',
+        FontColour: '#FFFFFFFF',
+        FontName: 'Arial',
+        FontSize: '16',
+    },
+};
+/**
+ * Re-export ensureAlphaChannel from colorUtils for backward compatibility
+ * @deprecated Use ensureAlphaChannel from colorUtils instead
+ */
+export { ensureAlphaChannel } from './colorUtils';
+/**
+ * Create a Grid3 style XML string with default and category styles
+ * @param includeCategories - Whether to include category-specific styles (default: true)
+ * @returns XML string for Settings0/styles.xml
+ */
+export function createDefaultStylesXml(includeCategories = true) {
+    const builder = new XMLBuilder({
+        ignoreAttributes: false,
+        format: true,
+        indentBy: '  ',
+    });
+    const styles = { ...DEFAULT_GRID3_STYLES };
+    if (includeCategories) {
+        Object.assign(styles, CATEGORY_STYLES);
+    }
+    const styleArray = Object.entries(styles).map(([key, style]) => ({
+        '@_Key': key,
+        BackColour: style.BackColour,
+        TileColour: style.TileColour,
+        BorderColour: style.BorderColour,
+        FontColour: style.FontColour,
+        FontName: style.FontName,
+        FontSize: style.FontSize?.toString(),
+    }));
+    const stylesData = {
+        StyleData: {
+            '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+            Styles: {
+                Style: styleArray,
+            },
+        },
+    };
+    return builder.build(stylesData);
+}
+/**
+ * Create a custom category style
+ * @param categoryName - Name of the category
+ * @param backgroundColor - Background color in hex format
+ * @param fontColor - Font color in hex format (default: white)
+ * @returns Grid3Style object
+ */
+export function createCategoryStyle(categoryName, backgroundColor, fontColor = '#FFFFFFFF') {
+    return {
+        BackColour: ensureAlphaChannel(backgroundColor),
+        TileColour: ensureAlphaChannel(backgroundColor),
+        BorderColour: ensureAlphaChannel(darkenColor(backgroundColor, 30)),
+        FontColour: ensureAlphaChannel(fontColor),
+        FontName: 'Arial',
+        FontSize: '16',
+    };
+}