@willwade/aac-processors 0.0.29 → 0.1.0

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

@@ -0,0 +1,53 @@
+/**
+ * Crypto utilities for Gridsetx (encrypted Grid3 files)
+ * This module is only needed for .gridsetx files and uses Node-only crypto/zlib
+ */
+/**
+ * Decrypt and inflate a Grid3 encrypted payload (DesktopContentEncrypter).
+ * Uses AES-256-CBC with key/IV derived from the password padded with spaces
+ * and then Deflate decompression.
+ *
+ * @param buffer - Encrypted buffer
+ * @param password - Password (defaults to 'Chocolate')
+ * @returns Decrypted and inflated buffer
+ */
+export function decryptGridsetEntry(buffer, password) {
+    // Dynamic require to avoid breaking in browser environments
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-return
+    const crypto = require('crypto');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-return
+    const zlib = require('zlib');
+    const pwd = (password || 'Chocolate').padEnd(32, ' ');
+    const key = Buffer.from(pwd.slice(0, 32), 'utf8');
+    const iv = Buffer.from(pwd.slice(0, 16), 'utf8');
+    try {
+        const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+        const decrypted = Buffer.concat([decipher.update(buffer), decipher.final()]);
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return zlib.inflateSync(decrypted);
+        }
+        catch {
+            // If data isn't deflated, return raw decrypted bytes
+            return decrypted;
+        }
+    }
+    catch {
+        return buffer;
+    }
+}
+/**
+ * Check if crypto operations are available in the current environment
+ */
+export function isCryptoAvailable() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require('crypto');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require('zlib');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,43 @@
+import path from 'path';
+/**
+ * Resolve the password to use for Grid3 archives.
+ * Preference order:
+ * 1. Explicit processor option
+ * 2. GRIDSET_PASSWORD env var
+ */
+export function resolveGridsetPassword(options, source) {
+    if (options?.gridsetPassword)
+        return options.gridsetPassword;
+    if (process.env.GRIDSET_PASSWORD)
+        return process.env.GRIDSET_PASSWORD;
+    if (typeof source === 'string') {
+        const ext = path.extname(source).toLowerCase();
+        if (ext === '.gridsetx')
+            return process.env.GRIDSET_PASSWORD;
+    }
+    return undefined;
+}
+export function resolveGridsetPasswordFromEnv() {
+    return process.env.GRIDSET_PASSWORD;
+}
+export function getZipEntriesWithPassword(zip, password) {
+    const entries = [];
+    // Note: JSZip doesn't support zip-level password protection like AdmZip
+    // Password protection for .gridsetx files is handled at the encrypted archive level
+    // in crypto.ts before the zip is loaded
+    if (password) {
+        console.warn('JSZip does not support zip-level password protection. For .gridsetx encrypted files, password is handled at the archive level.');
+    }
+    zip.forEach((relativePath, file) => {
+        entries.push({
+            name: relativePath,
+            entryName: relativePath,
+            dir: file.dir || false,
+            getData: async () => {
+                // Use 'uint8array' which is supported everywhere
+                return await file.async('uint8array');
+            },
+        });
+    });
+    return entries;
+}

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

@@ -0,0 +1,277 @@
+/**
+ * Grid 3 Plugin Cell Type Detection
+ *
+ * Grid 3 uses three special cell types for different plugin functionalities:
+ * - Workspace: Full editing workspaces (Email, Chat, WordProcessor, etc.)
+ * - LiveCell: Dynamic content displays (Clock, Volume indicators, etc.)
+ * - AutoContent: Dynamic word/content suggestions
+ *
+ * This module provides detection and metadata extraction for these cell types.
+ */
+/**
+ * Cell types in Grid 3
+ */
+export var Grid3CellType;
+(function (Grid3CellType) {
+    Grid3CellType["Regular"] = "regular";
+    Grid3CellType["Workspace"] = "workspace";
+    Grid3CellType["LiveCell"] = "livecell";
+    Grid3CellType["AutoContent"] = "autocontent";
+})(Grid3CellType || (Grid3CellType = {}));
+/**
+ * Known workspace types in Grid 3
+ */
+export const WORKSPACE_TYPES = {
+    CHAT: 'Chat',
+    EMAIL: 'Email',
+    WORD_PROCESSOR: 'WordProcessor',
+    PHONE: 'Phone',
+    SMS: 'Sms',
+    WEB_BROWSER: 'WebBrowser',
+    COMPUTER_CONTROL: 'ComputerControl',
+    CALCULATOR: 'Calculator',
+    TIMER: 'Timer',
+    MUSIC_VIDEO: 'MusicVideo',
+    PHOTOS: 'Photos',
+    CONTACTS: 'Contacts',
+    INTERACTIVE_LEARNING: 'InteractiveLearning',
+    MESSAGE_BANKING: 'MessageBanking',
+    ENVIRONMENT_CONTROL: 'EnvironmentControl',
+    SETTINGS: 'Settings',
+};
+/**
+ * Known live cell types in Grid 3
+ */
+export const LIVECELL_TYPES = {
+    DIGITAL_CLOCK: 'DigitalClock',
+    ANALOG_CLOCK: 'AnalogClock',
+    DATE_DISPLAY: 'DateDisplay',
+    PUBLIC_VOLUME: 'PublicVolume',
+    PUBLIC_SPEED: 'PublicSpeed',
+    PUBLIC_VOICE: 'PublicVoice',
+    MESSAGES: 'Messages',
+    BATTERY: 'Battery',
+    WIFI_STRENGTH: 'WifiStrength',
+    BLUETOOTH_STATUS: 'BluetoothStatus',
+};
+/**
+ * Known auto content types in Grid 3
+ */
+export const AUTOCONTENT_TYPES = {
+    CHANGE_PUBLIC_VOICE: 'ChangePublicVoice',
+    CHANGE_PUBLIC_SPEED: 'ChangePublicSpeed',
+    EMAIL_CONTACTS: 'EmailContacts',
+    EMAIL_RECIPIENTS: 'EmailRecipients',
+    PHONE_CONTACTS: 'PhoneContacts',
+    SMS_CONTACTS: 'SmsContacts',
+    WEB_FAVORITES: 'WebFavorites',
+    WEB_HISTORY: 'WebHistory',
+    PREDICTION: 'Prediction',
+    GRAMMAR: 'Grammar',
+    CONTEXTUAL: 'Contextual',
+};
+/**
+ * Human-readable names for cell types
+ */
+export function getCellTypeDisplayName(cellType) {
+    switch (cellType) {
+        case Grid3CellType.Workspace:
+            return 'Workspace';
+        case Grid3CellType.LiveCell:
+            return 'Live Cell';
+        case Grid3CellType.AutoContent:
+            return 'Auto Content';
+        case Grid3CellType.Regular:
+            return 'Regular';
+        default:
+            return 'Unknown';
+    }
+}
+/**
+ * Detect plugin cell type from Grid 3 cell content
+ *
+ * @param content - Grid 3 cell content object
+ * @returns Plugin metadata with detected type
+ */
+export function detectPluginCellType(content) {
+    if (!content) {
+        return { cellType: Grid3CellType.Regular };
+    }
+    const contentType = content.ContentType || content.contenttype;
+    const contentSubType = content.ContentSubType || content.contentsubtype;
+    // Workspace cells - full editing workspaces
+    if (contentType === 'Workspace' || content.Style?.BasedOnStyle === 'Workspace') {
+        return {
+            cellType: Grid3CellType.Workspace,
+            subType: contentSubType || undefined,
+            pluginId: inferWorkspacePlugin(String(contentSubType || '')),
+            displayName: contentSubType ? `${contentSubType} Workspace` : 'Workspace',
+        };
+    }
+    // LiveCell detection - dynamic content displays
+    if (contentType === 'LiveCell' || content.Style?.BasedOnStyle === 'LiveCell') {
+        return {
+            cellType: Grid3CellType.LiveCell,
+            liveCellType: contentSubType || undefined,
+            pluginId: inferLiveCellPlugin(String(contentSubType || '')),
+            displayName: contentSubType || 'Live Cell',
+        };
+    }
+    // AutoContent detection - dynamic word/content suggestions
+    if (contentType === 'AutoContent' || content.Style?.BasedOnStyle === 'AutoContent') {
+        const autoContentType = extractAutoContentType(content) || contentSubType;
+        return {
+            cellType: Grid3CellType.AutoContent,
+            autoContentType: autoContentType ? String(autoContentType) : undefined,
+            pluginId: inferAutoContentPlugin(autoContentType ? String(autoContentType) : undefined),
+            displayName: autoContentType ? String(autoContentType) : 'Auto Content',
+        };
+    }
+    // Regular cell
+    return {
+        cellType: Grid3CellType.Regular,
+    };
+}
+/**
+ * Extract auto content type from AutoContent.Activate command
+ */
+function extractAutoContentType(content) {
+    const commands = content.Commands?.Command || content.commands?.command;
+    if (!commands)
+        return undefined;
+    const commandArr = Array.isArray(commands) ? commands : [commands];
+    for (const command of commandArr) {
+        const commandId = command['@_ID'] || command.ID || command.id;
+        if (commandId === 'AutoContent.Activate') {
+            const parameters = command.Parameter || command.parameter;
+            const paramArr = Array.isArray(parameters) ? parameters : parameters ? [parameters] : [];
+            for (const param of paramArr) {
+                const key = param['@_Key'] || param.Key || param.key;
+                if (key === 'autocontenttype') {
+                    return String(param['#text'] || param.text || param.value || '');
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Infer plugin ID from workspace subtype
+ */
+function inferWorkspacePlugin(subType) {
+    if (!subType)
+        return undefined;
+    const normalized = subType.toLowerCase();
+    if (normalized.includes('chat'))
+        return 'Grid3.Chat';
+    if (normalized.includes('email') || normalized.includes('mail'))
+        return 'Grid3.Email';
+    if (normalized.includes('word') || normalized.includes('doc'))
+        return 'Grid3.WordProcessor';
+    if (normalized.includes('phone'))
+        return 'Grid3.Phone';
+    if (normalized.includes('sms') || normalized.includes('text'))
+        return 'Grid3.Sms';
+    if (normalized.includes('browser') || normalized.includes('web'))
+        return 'Grid3.WebBrowser';
+    if (normalized.includes('computer'))
+        return 'Grid3.ComputerControl';
+    if (normalized.includes('calc'))
+        return 'Grid3.Calculator';
+    if (normalized.includes('timer'))
+        return 'Grid3.Timer';
+    if (normalized.includes('music') || normalized.includes('video'))
+        return 'Grid3.MusicVideo';
+    if (normalized.includes('photo') || normalized.includes('image'))
+        return 'Grid3.Photos';
+    if (normalized.includes('contact'))
+        return 'Grid3.Contacts';
+    if (normalized.includes('learning'))
+        return 'Grid3.InteractiveLearning';
+    if (normalized.includes('message') && normalized.includes('banking'))
+        return 'Grid3.MessageBanking';
+    if (normalized.includes('control'))
+        return 'Grid3.EnvironmentControl';
+    if (normalized.includes('settings'))
+        return 'Grid3.Settings';
+    return `Grid3.${subType}`;
+}
+/**
+ * Infer plugin ID from live cell type
+ */
+function inferLiveCellPlugin(liveCellType) {
+    if (!liveCellType)
+        return undefined;
+    const normalized = liveCellType.toLowerCase();
+    if (normalized.includes('clock'))
+        return 'Grid3.Clock';
+    if (normalized.includes('date'))
+        return 'Grid3.Clock';
+    if (normalized.includes('volume'))
+        return 'Grid3.Volume';
+    if (normalized.includes('speed'))
+        return 'Grid3.Speed';
+    if (normalized.includes('voice'))
+        return 'Grid3.Speech';
+    if (normalized.includes('message'))
+        return 'Grid3.Chat';
+    if (normalized.includes('battery'))
+        return 'Grid3.Battery';
+    if (normalized.includes('wifi'))
+        return 'Grid3.Wifi';
+    if (normalized.includes('bluetooth'))
+        return 'Grid3.Bluetooth';
+    return `Grid3.${liveCellType}`;
+}
+/**
+ * Infer plugin ID from auto content type
+ */
+function inferAutoContentPlugin(autoContentType) {
+    if (!autoContentType)
+        return undefined;
+    const normalized = autoContentType.toLowerCase();
+    if (normalized.includes('voice') || normalized.includes('speed'))
+        return 'Grid3.Speech';
+    if (normalized.includes('email') || normalized.includes('mail'))
+        return 'Grid3.Email';
+    if (normalized.includes('phone'))
+        return 'Grid3.Phone';
+    if (normalized.includes('sms') || normalized.includes('text'))
+        return 'Grid3.Sms';
+    if (normalized.includes('web') ||
+        normalized.includes('favorite') ||
+        normalized.includes('history')) {
+        return 'Grid3.WebBrowser';
+    }
+    if (normalized.includes('prediction'))
+        return 'Grid3.Prediction';
+    if (normalized.includes('grammar'))
+        return 'Grid3.Grammar';
+    if (normalized.includes('context'))
+        return 'Grid3.AutoContent';
+    return undefined;
+}
+/**
+ * Check if a cell is a workspace cell
+ */
+export function isWorkspaceCell(metadata) {
+    return metadata.cellType === Grid3CellType.Workspace;
+}
+/**
+ * Check if a cell is a live cell
+ */
+export function isLiveCell(metadata) {
+    return metadata.cellType === Grid3CellType.LiveCell;
+}
+/**
+ * Check if a cell is an auto content cell
+ */
+export function isAutoContentCell(metadata) {
+    return metadata.cellType === Grid3CellType.AutoContent;
+}
+/**
+ * Check if a cell is a regular (non-plugin) cell
+ */
+export function isRegularCell(metadata) {
+    return metadata.cellType === Grid3CellType.Regular;
+}

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

@@ -0,0 +1,137 @@
+import { isSymbolReference, parseSymbolReference } from './symbols';
+function normalizeZipPathLocal(p) {
+    const unified = p.replace(/\\/g, '/');
+    try {
+        return unified.normalize('NFC');
+    }
+    catch {
+        return unified;
+    }
+}
+function listZipEntries(zip, zipEntries) {
+    try {
+        const raw = Array.isArray(zipEntries) && zipEntries.length > 0
+            ? zipEntries
+            : typeof zip?.getEntries === 'function'
+                ? zip.getEntries()
+                : [];
+        let entries = [];
+        if (Array.isArray(raw))
+            entries = raw;
+        const arr = entries;
+        return arr.map((e) => normalizeZipPathLocal(String(e.entryName)));
+    }
+    catch {
+        return [];
+    }
+}
+function extFromName(name) {
+    if (!name)
+        return undefined;
+    const m = name.match(/\.([A-Za-z0-9]+)$/);
+    return m ? `.${m[1].toLowerCase()}` : undefined;
+}
+function joinBaseDir(baseDir, leaf) {
+    const base = normalizeZipPathLocal(baseDir).replace(/\/?$/, '/');
+    return normalizeZipPathLocal(base + leaf.replace(/^\//, ''));
+}
+export function resolveGrid3CellImage(zip, args, zipEntries) {
+    const { baseDir, dynamicFiles } = args;
+    const imageName = args.imageName?.trim();
+    const x = args.x;
+    const y = args.y;
+    const entries = new Set(listZipEntries(zip, zipEntries));
+    const has = (p) => entries.has(normalizeZipPathLocal(p));
+    // Built-in resource like [grid3x]... (old format, not symbol library)
+    // Check this BEFORE general symbol references to avoid misclassification
+    if (imageName && imageName.startsWith('[')) {
+        // Check if it's a symbol library reference like [widgit]/food/apple.png
+        // Symbol library references have a path after the library name
+        if (isSymbolReference(imageName)) {
+            const parsed = parseSymbolReference(imageName);
+            // If it's grid3x, it's a built-in resource, not a symbol library
+            if (parsed.library !== 'grid3x') {
+                // Symbol library references are NOT stored as files in the gridset
+                // They are resolved from the external Grid 3 installation
+                // Return null to indicate this is an external symbol reference
+                return null;
+            }
+        }
+        // For grid3x and other built-in resources, use the builtinHandler
+        if (args.builtinHandler) {
+            const mapped = args.builtinHandler(imageName);
+            if (mapped)
+                return mapped;
+        }
+        return null;
+    }
+    // Direct declared file
+    if (imageName) {
+        const p1 = joinBaseDir(baseDir, imageName);
+        if (has(p1))
+            return p1;
+        const p2 = joinBaseDir(baseDir, `Images/${imageName}`);
+        if (has(p2))
+            return p2;
+    }
+    // FileMap.xml dynamic files
+    if (x != null && y != null && dynamicFiles && dynamicFiles.length > 0) {
+        const prefix = joinBaseDir(baseDir, `${x}-${y}-`);
+        const matches = dynamicFiles
+            .map((f) => normalizeZipPathLocal(f))
+            .filter((f) => f.startsWith(prefix));
+        if (matches.length > 0) {
+            const preferred = matches.find((m) => /text/i.test(m)) || matches[0];
+            if (has(preferred))
+                return preferred;
+        }
+    }
+    // Coordinate-based guesses
+    if (x != null && y != null) {
+        const ext = extFromName(imageName);
+        if (ext) {
+            const c1 = joinBaseDir(baseDir, `${x}-${y}-0-text-0${ext}`);
+            if (has(c1))
+                return c1;
+            const c2 = joinBaseDir(baseDir, `${x}-${y}${ext}`);
+            if (has(c2))
+                return c2;
+        }
+        else {
+            const candidates = [
+                `${x}-${y}-0-text-0.jpeg`,
+                `${x}-${y}-0-text-0.jpg`,
+                `${x}-${y}-0-text-0.png`,
+                `${x}-${y}.jpeg`,
+                `${x}-${y}.jpg`,
+                `${x}-${y}.png`,
+            ].map((n) => joinBaseDir(baseDir, n));
+            for (const c of candidates) {
+                if (has(c))
+                    return c;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if an image reference is a symbol library reference
+ * @param imageName - Image reference from Grid 3
+ * @returns True if it's a symbol library reference
+ */
+export function isSymbolLibraryReference(imageName) {
+    if (!imageName)
+        return false;
+    return isSymbolReference(imageName.trim());
+}
+/**
+ * Parse a symbol library reference from an image name
+ * @param imageName - Image reference from Grid 3
+ * @returns Parsed reference or null if not a symbol reference
+ */
+export function parseImageSymbolReference(imageName) {
+    if (!isSymbolLibraryReference(imageName)) {
+        return null;
+    }
+    return parseSymbolReference(imageName.trim());
+}