@willwade/aac-processors 0.1.5 → 0.1.7

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,9 +52,42 @@ 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;
+    const trimmed = filePath.replace(/[/\\]+$/, '') || filePath;
+    const parts = trimmed.split(/[/\\]/);
+    return parts[parts.length - 1] || trimmed;
+}
+export function toUint8Array(input) {
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    return new Uint8Array(input);
+}
+export function toArrayBuffer(input) {
+    if (input instanceof ArrayBuffer) {
+        return input;
+    }
+    const view = input instanceof Uint8Array ? input : new Uint8Array(input);
+    return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
 }
 export function decodeText(input) {
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {

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/gridsetValidator.js

@@ -2,24 +2,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import JSZip from 'jszip';
+import * as xml2js from 'xml2js';
 import { BaseValidator } from './baseValidator';
-import { getFs, getNodeRequire, getPath } from '../utils/io';
-let cachedXml2js = null;
-function getXml2js() {
-    if (cachedXml2js)
-        return cachedXml2js;
-    try {
-        const nodeRequire = getNodeRequire();
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const module = nodeRequire('xml2js');
-        const resolved = module.default || module;
-        cachedXml2js = resolved;
-        return resolved;
-    }
-    catch {
-        throw new Error('Validator requires Xml2js in this environment.');
-    }
-}
+import { decodeText, getBasename, getFs, toUint8Array } from '../utils/io';
 /**
  * Validator for Grid3/Smartbox Gridset files (.gridset, .gridsetx)
  */
@@ -33,10 +18,9 @@ export class GridsetValidator extends BaseValidator {
     static async validateFile(filePath) {
         const validator = new GridsetValidator();
         const fs = getFs();
-        const path = getPath();
         const content = fs.readFileSync(filePath);
         const stats = fs.statSync(filePath);
-        return validator.validate(content, path.basename(filePath), stats.size);
+        return validator.validate(content, getBasename(filePath), stats.size);
     }
     /**
      * Check if content is Gridset format
@@ -48,8 +32,7 @@ export class GridsetValidator extends BaseValidator {
         }
         // Try to parse as XML and check for gridset structure
         try {
-            const contentStr = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-            const xml2js = getXml2js();
+            const contentStr = typeof content === 'string' ? content : decodeText(toUint8Array(content));
             const parser = new xml2js.Parser();
             const result = await parser.parseStringPromise(contentStr);
             return result && (result.gridset || result.Gridset);
@@ -102,9 +85,8 @@ export class GridsetValidator extends BaseValidator {
         let xmlObj = null;
         await this.add_check('xml_parse', 'valid XML', async () => {
             try {
-                const xml2js = getXml2js();
                 const parser = new xml2js.Parser();
-                const contentStr = content.toString('utf-8');
+                const contentStr = decodeText(content);
                 xmlObj = await parser.parseStringPromise(contentStr);
             }
             catch (e) {
@@ -129,7 +111,7 @@ export class GridsetValidator extends BaseValidator {
     async validateZipArchive(content, filename, _filesize) {
         let zip;
         try {
-            zip = await JSZip.loadAsync(Buffer.from(content));
+            zip = await JSZip.loadAsync(toUint8Array(content));
         }
         catch (e) {
             this.err(`Failed to open ZIP archive: ${e.message}`, true);
@@ -145,7 +127,6 @@ export class GridsetValidator extends BaseValidator {
             else {
                 try {
                     const gridsetXml = await gridsetEntry.async('string');
-                    const xml2js = getXml2js();
                     const parser = new xml2js.Parser();
                     const xmlObj = await parser.parseStringPromise(gridsetXml);
                     const gridset = xmlObj.gridset || xmlObj.Gridset;
@@ -153,7 +134,7 @@ export class GridsetValidator extends BaseValidator {
                         this.err('Invalid gridset.xml structure', true);
                     }
                     else {
-                        await this.validateGridsetStructure(gridset, filename, Buffer.from(gridsetXml));
+                        await this.validateGridsetStructure(gridset, filename, new Uint8Array());
                     }
                 }
                 catch (e) {
@@ -170,7 +151,6 @@ export class GridsetValidator extends BaseValidator {
             else {
                 try {
                     const settingsXml = await settingsEntry.async('string');
-                    const xml2js = getXml2js();
                     const parser = new xml2js.Parser();
                     const xmlObj = await parser.parseStringPromise(settingsXml);
                     const settings = xmlObj.GridSetSettings || xmlObj.gridSetSettings || xmlObj.GridsetSettings;

package/dist/browser/validation/obfValidator.js

@@ -5,7 +5,7 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 import JSZip from 'jszip';
 import { BaseValidator } from './baseValidator';
-import { getFs, getPath, readBinaryFromInput } from '../utils/io';
+import { decodeText, getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
 const OBF_FORMAT = 'open-board-0.1';
 const OBF_FORMAT_CURRENT_VERSION = 0.1;
 /**
@@ -22,7 +22,7 @@ export class ObfValidator extends BaseValidator {
         const validator = new ObfValidator();
         const content = readBinaryFromInput(filePath);
         const stats = getFs().statSync(filePath);
-        return validator.validate(content, getPath().basename(filePath), stats.size);
+        return validator.validate(content, getBasename(filePath), stats.size);
     }
     /**
      * Check if content is OBF format
@@ -34,7 +34,12 @@ export class ObfValidator extends BaseValidator {
         }
         // Try to parse as JSON and check format
         try {
-            const contentStr = Buffer.isBuffer(content) ? content.toString() : content;
+            if (typeof content !== 'string' &&
+                !(content instanceof ArrayBuffer) &&
+                !(content instanceof Uint8Array)) {
+                return false;
+            }
+            const contentStr = typeof content === 'string' ? content : decodeText(toUint8Array(content));
             const json = JSON.parse(contentStr);
             return json && json.format && json.format.startsWith('open-board-');
         }
@@ -68,7 +73,7 @@ export class ObfValidator extends BaseValidator {
         let json = null;
         await this.add_check('valid_json', 'JSON file', async () => {
             try {
-                json = JSON.parse(content.toString());
+                json = JSON.parse(decodeText(content));
             }
             catch {
                 this.err("Couldn't parse as JSON", true);

package/dist/browser/validation/snapValidator.js

@@ -0,0 +1,197 @@
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import * as xml2js from 'xml2js';
+import JSZip from 'jszip';
+import { BaseValidator } from './baseValidator';
+import { getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
+/**
+ * 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 = readBinaryFromInput(filePath);
+        const stats = getFs().statSync(filePath);
+        return validator.validate(content, getBasename(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 zip = await JSZip.loadAsync(toUint8Array(content));
+            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 {
+                zip = await JSZip.loadAsync(toUint8Array(content));
+                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}`);
+            }
+        });
+    }
+}