@willwade/aac-processors 0.1.5 → 0.1.6

package/dist/browser/utils/io.js

@@ -1,5 +1,6 @@
 let cachedFs = null;
 let cachedPath = null;
+let cachedOs = null;
 let cachedRequire = undefined;
 export function getNodeRequire() {
     if (cachedRequire === undefined) {
@@ -51,6 +52,25 @@ export function getPath() {
     }
     return cachedPath;
 }
+export function getOs() {
+    if (!cachedOs) {
+        try {
+            const nodeRequire = getNodeRequire();
+            const osModule = 'os';
+            cachedOs = nodeRequire(osModule);
+        }
+        catch {
+            throw new Error('OS utilities are not available in this environment.');
+        }
+    }
+    if (!cachedOs) {
+        throw new Error('OS utilities are not available in this environment.');
+    }
+    return cachedOs;
+}
+export function isNodeRuntime() {
+    return typeof process !== 'undefined' && !!process.versions?.node;
+}
 export function getBasename(filePath) {
     const parts = filePath.split(/[/\\]/);
     return parts[parts.length - 1] || filePath;

package/dist/browser/utils/sqlite.js

@@ -0,0 +1,109 @@
+import { getFs, getNodeRequire, getOs, getPath, isNodeRuntime, readBinaryFromInput } from './io';
+let sqlJsConfig = null;
+let sqlJsPromise = null;
+export function configureSqlJs(config) {
+    sqlJsConfig = { ...(sqlJsConfig ?? {}), ...config };
+}
+async function getSqlJs() {
+    if (!sqlJsPromise) {
+        sqlJsPromise = import('sql.js').then((module) => {
+            const initSqlJs = module.default || module;
+            return initSqlJs(sqlJsConfig ?? {});
+        });
+    }
+    return sqlJsPromise;
+}
+function createSqlJsAdapter(db) {
+    return {
+        prepare(sql) {
+            return {
+                all(...params) {
+                    const stmt = db.prepare(sql);
+                    if (params.length > 0) {
+                        stmt.bind(params);
+                    }
+                    const rows = [];
+                    while (stmt.step()) {
+                        rows.push(stmt.getAsObject());
+                    }
+                    stmt.free();
+                    return rows;
+                },
+                get(...params) {
+                    const stmt = db.prepare(sql);
+                    if (params.length > 0) {
+                        stmt.bind(params);
+                    }
+                    const row = stmt.step() ? stmt.getAsObject() : undefined;
+                    stmt.free();
+                    return row;
+                },
+                run(...params) {
+                    const stmt = db.prepare(sql);
+                    if (params.length > 0) {
+                        stmt.bind(params);
+                    }
+                    stmt.step();
+                    stmt.free();
+                    return undefined;
+                },
+            };
+        },
+        exec(sql) {
+            db.exec(sql);
+        },
+        close() {
+            db.close();
+        },
+    };
+}
+function getBetterSqlite3() {
+    try {
+        const nodeRequire = getNodeRequire();
+        return nodeRequire('better-sqlite3');
+    }
+    catch {
+        throw new Error('better-sqlite3 is not available in this environment.');
+    }
+}
+export function requireBetterSqlite3() {
+    return getBetterSqlite3();
+}
+export async function openSqliteDatabase(input, options = {}) {
+    if (typeof input === 'string') {
+        if (!isNodeRuntime()) {
+            throw new Error('SQLite file paths are not supported in browser environments.');
+        }
+        const Database = getBetterSqlite3();
+        const db = new Database(input, { readonly: options.readonly ?? true });
+        return { db };
+    }
+    const data = readBinaryFromInput(input);
+    if (!isNodeRuntime()) {
+        const SQL = await getSqlJs();
+        const db = new SQL.Database(data);
+        return { db: createSqlJsAdapter(db) };
+    }
+    const fs = getFs();
+    const path = getPath();
+    const os = getOs();
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aac-sqlite-'));
+    const dbPath = path.join(tempDir, 'input.sqlite');
+    fs.writeFileSync(dbPath, data);
+    const Database = getBetterSqlite3();
+    const db = new Database(dbPath, { readonly: options.readonly ?? true });
+    const cleanup = () => {
+        try {
+            db.close();
+        }
+        finally {
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch (error) {
+                console.warn('Failed to clean up temporary SQLite files:', error);
+            }
+        }
+    };
+    return { db, cleanup };
+}

package/dist/browser/utils/zip.js

@@ -0,0 +1,54 @@
+import { isNodeRuntime, readBinaryFromInput, getNodeRequire } from './io';
+export async function openZipFromInput(input) {
+    if (typeof input === 'string') {
+        if (!isNodeRuntime()) {
+            throw new Error('Zip file paths are not supported in browser environments.');
+        }
+        const AdmZip = getNodeRequire()('adm-zip');
+        const admZip = new AdmZip(input);
+        return {
+            zip: {
+                listFiles: () => admZip.getEntries().map((entry) => entry.entryName),
+                readFile: (name) => {
+                    const entry = admZip.getEntry(name);
+                    if (!entry) {
+                        throw new Error(`Zip entry not found: ${name}`);
+                    }
+                    return Promise.resolve(entry.getData());
+                },
+            },
+        };
+    }
+    const data = readBinaryFromInput(input);
+    if (isNodeRuntime()) {
+        const AdmZip = getNodeRequire()('adm-zip');
+        const admZip = new AdmZip(Buffer.from(data));
+        return {
+            zip: {
+                listFiles: () => admZip.getEntries().map((entry) => entry.entryName),
+                readFile: (name) => {
+                    const entry = admZip.getEntry(name);
+                    if (!entry) {
+                        throw new Error(`Zip entry not found: ${name}`);
+                    }
+                    return Promise.resolve(entry.getData());
+                },
+            },
+        };
+    }
+    const module = await import('jszip');
+    const init = module.default || module;
+    const zip = await init.loadAsync(data);
+    return {
+        zip: {
+            listFiles: () => Object.keys(zip.files),
+            readFile: async (name) => {
+                const file = zip.file(name);
+                if (!file) {
+                    throw new Error(`Zip entry not found: ${name}`);
+                }
+                return file.async('uint8array');
+            },
+        },
+    };
+}

package/dist/browser/validation/snapValidator.js

@@ -0,0 +1,200 @@
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as xml2js from 'xml2js';
+import JSZip from 'jszip';
+import { BaseValidator } from './baseValidator';
+/**
+ * Validator for Snap files (.spb, .sps)
+ * Snap files are zipped packages containing XML configuration
+ */
+export class SnapValidator extends BaseValidator {
+    constructor() {
+        super();
+    }
+    /**
+     * Validate a Snap file from disk
+     */
+    static async validateFile(filePath) {
+        const validator = new SnapValidator();
+        const content = fs.readFileSync(filePath);
+        const stats = fs.statSync(filePath);
+        return validator.validate(content, path.basename(filePath), stats.size);
+    }
+    /**
+     * Check if content is Snap format
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async identifyFormat(content, filename) {
+        const name = filename.toLowerCase();
+        if (name.endsWith('.spb') || name.endsWith('.sps')) {
+            return true;
+        }
+        // Try to parse as ZIP and check for Snap structure
+        try {
+            const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+            const zip = await JSZip.loadAsync(buffer);
+            const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+            return entries.some((entry) => entry.name.includes('settings') || entry.name.includes('.xml'));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Main validation method
+     */
+    async validate(content, filename, filesize) {
+        this.reset();
+        await this.add_check('filename', 'file extension', async () => {
+            if (!filename.match(/\.(spb|sps)$/)) {
+                this.warn('filename should end with .spb or .sps');
+            }
+        });
+        let zip = null;
+        let validZip = false;
+        await this.add_check('zip', 'valid zip package', async () => {
+            try {
+                const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+                zip = await JSZip.loadAsync(buffer);
+                const entries = Object.values(zip.files);
+                validZip = entries.length > 0;
+            }
+            catch (e) {
+                this.err(`file is not a valid zip package: ${e.message}`, true);
+            }
+        });
+        if (!validZip || !zip) {
+            return this.buildResult(filename, filesize, 'snap');
+        }
+        await this.validateSnapStructure(zip, filename);
+        return this.buildResult(filename, filesize, 'snap');
+    }
+    /**
+     * Validate Snap package structure
+     */
+    async validateSnapStructure(zip, _filename) {
+        // Check for required files
+        await this.add_check('required_files', 'required package files', async () => {
+            const entries = Object.values(zip.files);
+            const entryNames = entries.map((e) => e.name);
+            // Look for common Snap files
+            const hasSettings = entryNames.some((n) => n.toLowerCase().includes('settings'));
+            const hasXml = entryNames.some((n) => n.toLowerCase().endsWith('.xml'));
+            if (!hasSettings && !hasXml) {
+                this.err('Snap package must contain settings.xml or similar configuration file');
+            }
+            if (entries.length === 0) {
+                this.err('Snap package is empty');
+            }
+        });
+        // Try to parse and validate the main settings file
+        const settingsEntry = Object.values(zip.files).find((entry) => !entry.dir && entry.name.toLowerCase().includes('settings'));
+        if (settingsEntry) {
+            await this.validateSettingsFile(settingsEntry);
+        }
+        // Check for pages
+        const pageEntries = Object.values(zip.files).filter((entry) => !entry.dir && entry.name.toLowerCase().includes('page'));
+        await this.add_check('pages', 'pages in package', async () => {
+            if (pageEntries.length === 0) {
+                this.warn('Snap package should contain at least one page file');
+            }
+        });
+        // Validate a sample of pages
+        const samplePages = pageEntries.slice(0, 5); // Limit to first 5 pages
+        for (let i = 0; i < samplePages.length; i++) {
+            await this.validatePageFile(samplePages[i], i);
+        }
+        // Check for images
+        const imageEntries = Object.values(zip.files).filter((entry) => !entry.dir && entry.name.toLowerCase().match(/\.(png|jpg|jpeg|gif|bmp)$/i));
+        await this.add_check('images', 'image files', async () => {
+            if (imageEntries.length === 0) {
+                this.warn('Snap package should contain image files for buttons');
+            }
+        });
+        // Check for audio files
+        const audioEntries = Object.values(zip.files).filter((entry) => !entry.dir && entry.name.toLowerCase().match(/\.(wav|mp3|m4a|ogg)$/i));
+        await this.add_check('audio', 'audio files', async () => {
+            // Audio files are optional, so just warn if missing
+            if (audioEntries.length === 0) {
+                // This is informational, not a warning
+            }
+        });
+        // Check for unexpected files
+        await this.add_check('unexpected_files', 'unexpected file types', async () => {
+            const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+            const unexpectedFiles = entries.filter((entry) => {
+                const name = entry.name.toLowerCase();
+                // Skip common system files and directories
+                if (name.startsWith('__macosx') || name.startsWith('.ds_store')) {
+                    return false;
+                }
+                // Allowed file types
+                return !name.match(/\.(xml|png|jpg|jpeg|gif|bmp|wav|mp3|m4a|ogg|json)$/i);
+            });
+            if (unexpectedFiles.length > 0) {
+                const unexpectedNames = unexpectedFiles.map((f) => f.name).slice(0, 5);
+                this.warn(`Package contains unexpected file types: ${unexpectedNames.join(', ')}`);
+            }
+        });
+    }
+    /**
+     * Validate the main settings file
+     */
+    async validateSettingsFile(entry) {
+        await this.add_check('settings_format', 'settings file format', async () => {
+            try {
+                const content = await entry.async('string');
+                const parser = new xml2js.Parser();
+                const xml = await parser.parseStringPromise(content);
+                // Check for expected root element
+                if (!xml.settings && !xml.Settings && !xml.page && !xml.Page) {
+                    this.warn('settings file does not contain expected root element');
+                }
+                // Check for required settings attributes if present
+                const settings = xml.settings || xml.Settings;
+                if (settings) {
+                    const id = settings.$?.id || settings.$?.Id;
+                    const name = settings.$?.name || settings.$?.Name;
+                    if (!id && !name) {
+                        this.warn('settings should have an id or name attribute');
+                    }
+                }
+            }
+            catch (e) {
+                this.err(`Failed to parse settings file: ${e.message}`);
+            }
+        });
+    }
+    /**
+     * Validate a page file
+     */
+    async validatePageFile(entry, index) {
+        await this.add_check(`page[${index}]`, `page file ${index}: ${entry.name}`, async () => {
+            try {
+                const content = await entry.async('string');
+                const parser = new xml2js.Parser();
+                const xml = await parser.parseStringPromise(content);
+                const page = xml.page || xml.Page;
+                if (!page) {
+                    this.err(`Page file ${entry.name} does not contain a page element`);
+                    return;
+                }
+                // Check page attributes
+                const pageId = page.$?.id || page.$?.Id;
+                if (!pageId) {
+                    this.warn(`Page ${entry.name} is missing an id attribute`);
+                }
+                // Check for cells/buttons
+                const cells = page.cells || page.Cells || page.button || page.Button;
+                if (!cells || (Array.isArray(cells) && cells.length === 0)) {
+                    this.warn(`Page ${entry.name} has no cells or buttons`);
+                }
+            }
+            catch (e) {
+                this.err(`Failed to parse page file ${entry.name}: ${e.message}`);
+            }
+        });
+    }
+}

package/dist/browser/validation/touchChatValidator.js

@@ -0,0 +1,202 @@
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as xml2js from 'xml2js';
+import { BaseValidator } from './baseValidator';
+/**
+ * Validator for TouchChat files (.ce)
+ * TouchChat files are XML-based
+ */
+export class TouchChatValidator extends BaseValidator {
+    constructor() {
+        super();
+    }
+    /**
+     * Validate a TouchChat file from disk
+     */
+    static async validateFile(filePath) {
+        const validator = new TouchChatValidator();
+        const content = fs.readFileSync(filePath);
+        const stats = fs.statSync(filePath);
+        return validator.validate(content, path.basename(filePath), stats.size);
+    }
+    /**
+     * Check if content is TouchChat format
+     */
+    static async identifyFormat(content, filename) {
+        const name = filename.toLowerCase();
+        if (name.endsWith('.ce')) {
+            return true;
+        }
+        // Try to parse as XML and check for TouchChat structure
+        try {
+            const contentStr = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
+            const parser = new xml2js.Parser();
+            const result = await parser.parseStringPromise(contentStr);
+            // TouchChat files typically have specific structure
+            return result && (result.PageSet || result.Pageset || result.page || result.Page);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Main validation method
+     */
+    async validate(content, filename, filesize) {
+        this.reset();
+        await this.add_check('filename', 'file extension', async () => {
+            if (!filename.match(/\.ce$/i)) {
+                this.warn('filename should end with .ce');
+            }
+        });
+        let xmlObj = null;
+        await this.add_check('xml_parse', 'valid XML', async () => {
+            try {
+                const parser = new xml2js.Parser();
+                const contentStr = content.toString('utf-8');
+                xmlObj = await parser.parseStringPromise(contentStr);
+            }
+            catch (e) {
+                this.err(`Failed to parse XML: ${e.message}`, true);
+            }
+        });
+        if (!xmlObj) {
+            return this.buildResult(filename, filesize, 'touchchat');
+        }
+        await this.add_check('xml_structure', 'TouchChat root element', async () => {
+            // TouchChat can have different root elements
+            const hasValidRoot = xmlObj.PageSet ||
+                xmlObj.Pageset ||
+                xmlObj.page ||
+                xmlObj.Page ||
+                xmlObj.pages ||
+                xmlObj.Pages;
+            if (!hasValidRoot) {
+                this.err('file does not contain a recognized TouchChat structure');
+            }
+        });
+        const root = xmlObj.PageSet ||
+            xmlObj.Pageset ||
+            xmlObj.page ||
+            xmlObj.Page ||
+            xmlObj.pages ||
+            xmlObj.Pages;
+        if (root) {
+            await this.validateTouchChatStructure(root);
+        }
+        return this.buildResult(filename, filesize, 'touchchat');
+    }
+    /**
+     * Validate TouchChat structure
+     */
+    async validateTouchChatStructure(root) {
+        // Check for ID
+        await this.add_check('root_id', 'root element ID', async () => {
+            const id = root.$?.id || root.$?.Id;
+            if (!id) {
+                this.warn('root element should have an id attribute');
+            }
+        });
+        // Check for name
+        await this.add_check('root_name', 'root element name', async () => {
+            const name = root.$?.name || root.$?.Name || root.name?.[0];
+            if (!name) {
+                this.warn('root element should have a name');
+            }
+        });
+        // Check for pages
+        await this.add_check('pages', 'pages collection', async () => {
+            const pages = root.page || root.Page || root.pages || root.Pages;
+            if (!pages) {
+                this.err('TouchChat file must contain pages');
+            }
+            else if (!Array.isArray(pages) || pages.length === 0) {
+                this.err('TouchChat file must contain at least one page');
+            }
+        });
+        // Validate individual pages
+        const pages = root.page || root.Page || root.pages || root.Pages;
+        if (pages && Array.isArray(pages)) {
+            await this.add_check('page_count', 'page count', async () => {
+                if (pages.length === 0) {
+                    this.err('Must contain at least one page');
+                }
+            });
+            // Sample first few pages
+            const sampleSize = Math.min(pages.length, 5);
+            for (let i = 0; i < sampleSize; i++) {
+                await this.validatePage(pages[i], i);
+            }
+        }
+    }
+    /**
+     * Validate a single page
+     */
+    async validatePage(page, index) {
+        await this.add_check(`page[${index}]_id`, `page ${index} ID`, async () => {
+            const id = page.$?.id || page.$?.Id;
+            if (!id) {
+                this.warn(`page ${index} is missing an id attribute`);
+            }
+        });
+        await this.add_check(`page[${index}]_name`, `page ${index} name`, async () => {
+            const name = page.$?.name || page.$?.Name || page.name?.[0];
+            if (!name) {
+                this.warn(`page ${index} should have a name`);
+            }
+        });
+        // Check for buttons/items
+        await this.add_check(`page[${index}]_buttons`, `page ${index} buttons`, async () => {
+            const buttons = page.button || page.Button || page.item || page.Item;
+            if (!buttons) {
+                this.warn(`page ${index} has no buttons/items`);
+            }
+            else if (Array.isArray(buttons) && buttons.length === 0) {
+                this.warn(`page ${index} should contain at least one button`);
+            }
+        });
+        // Validate button references
+        const buttons = page.button || page.Button || page.item || page.Item;
+        if (buttons && Array.isArray(buttons)) {
+            const sampleSize = Math.min(buttons.length, 3);
+            for (let i = 0; i < sampleSize; i++) {
+                await this.validateButton(buttons[i], index, i);
+            }
+        }
+    }
+    /**
+     * Validate a single button
+     */
+    async validateButton(button, pageIdx, buttonIdx) {
+        await this.add_check(`page[${pageIdx}]_button[${buttonIdx}]_label`, `button label`, async () => {
+            const label = button.$?.label || button.$?.Label || button.label?.[0];
+            if (!label) {
+                this.warn(`button ${buttonIdx} on page ${pageIdx} should have a label`);
+            }
+        });
+        await this.add_check(`page[${pageIdx}]_button[${buttonIdx}]_vocalization`, `button vocalization`, async () => {
+            const vocalization = button.$?.vocalization || button.$?.Vocalization || button.vocalization?.[0];
+            if (!vocalization) {
+                // Vocalization is optional, so just info
+            }
+        });
+        // Check for image reference
+        await this.add_check(`page[${pageIdx}]_button[${buttonIdx}]_image`, `button image`, async () => {
+            const image = button.$?.image || button.$?.Image || button.img?.[0];
+            if (!image) {
+                this.warn(`button ${buttonIdx} on page ${pageIdx} should have an image reference`);
+            }
+        });
+        // Check for link/action
+        await this.add_check(`page[${pageIdx}]_button[${buttonIdx}]_action`, `button action`, async () => {
+            const link = button.$?.link || button.$?.Link;
+            const action = button.$?.action || button.$?.Action;
+            if (!link && !action) {
+                // Not all buttons need actions, they can just speak
+            }
+        });
+    }
+}

package/dist/index.browser.d.ts

@@ -6,6 +6,10 @@
  * **NOTE: Gridset .gridsetx files**
  * GridsetProcessor supports regular `.gridset` files in browser.
  * Encrypted `.gridsetx` files require Node.js for crypto operations and are not supported in browser.
+ *
+ * **NOTE: SQLite-backed formats**
+ * Snap (.sps/.spb) and TouchChat (.ce) require a WASM-backed SQLite engine.
+ * Configure `sql.js` in browser builds via `configureSqlJs()` before loading these formats.
  */
 export * from './core/treeStructure';
 export * from './core/baseProcessor';
@@ -14,9 +18,12 @@ export { DotProcessor } from './processors/dotProcessor';
 export { OpmlProcessor } from './processors/opmlProcessor';
 export { ObfProcessor } from './processors/obfProcessor';
 export { GridsetProcessor } from './processors/gridsetProcessor';
+export { SnapProcessor } from './processors/snapProcessor';
+export { TouchChatProcessor } from './processors/touchchatProcessor';
 export { ApplePanelsProcessor } from './processors/applePanelsProcessor';
 export { AstericsGridProcessor } from './processors/astericsGridProcessor';
 import { BaseProcessor } from './core/baseProcessor';
+export { configureSqlJs } from './utils/sqlite';
 /**
  * Factory function to get the appropriate processor for a file extension
  * @param filePathOrExtension - File path or extension (e.g., '.dot', '/path/to/file.obf')