@willwade/aac-processors 0.1.20 → 0.2.0

package/dist/browser/utilities/analytics/metrics/vocabulary.js

@@ -13,12 +13,12 @@ export class VocabularyAnalyzer {
     /**
      * Analyze vocabulary coverage against core lists
      */
-    analyze(metrics, options) {
+    async analyze(metrics, options) {
         // const locale = options?.locale || metrics.locale || 'en';
         const highEffortThreshold = options?.highEffortThreshold || 5.0;
         const lowEffortThreshold = options?.lowEffortThreshold || 2.0;
         // Load reference data
-        const coreLists = this.referenceLoader.loadCoreLists();
+        const coreLists = await this.referenceLoader.loadCoreLists();
         // Create word to effort map (using lowercase keys for matching)
         const wordEffortMap = new Map();
         metrics.buttons.forEach((btn) => {

package/dist/browser/utilities/analytics/reference/browser.js

@@ -5,34 +5,34 @@ export class InMemoryReferenceLoader {
     constructor(data) {
         this.data = data;
     }
-    loadCoreLists() {
-        return this.data.coreLists;
+    async loadCoreLists() {
+        return Promise.resolve(this.data.coreLists);
     }
-    loadCommonWords() {
-        return this.data.commonWords;
+    async loadCommonWords() {
+        return Promise.resolve(this.data.commonWords);
     }
-    loadSynonyms() {
-        return this.data.synonyms;
+    async loadSynonyms() {
+        return Promise.resolve(this.data.synonyms);
     }
-    loadSentences() {
-        return this.data.sentences;
+    async loadSentences() {
+        return Promise.resolve(this.data.sentences);
     }
-    loadFringe() {
-        return this.data.fringe;
+    async loadFringe() {
+        return Promise.resolve(this.data.fringe);
     }
-    loadBaseWords() {
-        return this.data.baseWords;
+    async loadBaseWords() {
+        return Promise.resolve(this.data.baseWords);
     }
-    loadCommonFringe() {
+    async loadCommonFringe() {
         const commonWords = new Set(this.data.commonWords.words.map((w) => w.toLowerCase()));
         const coreWords = new Set();
         this.data.coreLists.forEach((list) => {
             list.words.forEach((word) => coreWords.add(word.toLowerCase()));
         });
-        return Array.from(commonWords).filter((word) => !coreWords.has(word));
+        return Promise.resolve(Array.from(commonWords).filter((word) => !coreWords.has(word)));
     }
-    loadAll() {
-        return this.data;
+    async loadAll() {
+        return Promise.resolve(this.data);
     }
 }
 export async function loadReferenceDataFromUrl(baseUrl, locale = 'en') {

package/dist/browser/utilities/analytics/reference/index.js

@@ -4,57 +4,63 @@
  * Loads reference vocabulary lists, core lists, and sentences
  * for AAC metrics analysis.
  */
-import { getFs, getPath } from '../../../utils/io';
+import { defaultFileAdapter } from '../../../utils/io';
 export class ReferenceLoader {
-    constructor(dataDir, locale = 'en') {
+    constructor(dataDir, locale = 'en', fileAdapter = defaultFileAdapter) {
         this.locale = locale;
+        this.fileAdapter = fileAdapter;
         if (dataDir) {
             this.dataDir = dataDir;
         }
         else {
             // Resolve the data directory relative to this file's location
             // Use __dirname which works correctly after compilation
-            this.dataDir = getPath().join(__dirname, 'data');
+            this.dataDir = this.fileAdapter.join(__dirname, 'data');
         }
     }
     /**
      * Load core vocabulary lists
      */
-    loadCoreLists() {
-        const filePath = getPath().join(this.dataDir, `core_lists.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+    async loadCoreLists() {
+        const { readTextFromInput } = this.fileAdapter;
+        const filePath = this.fileAdapter.join(this.dataDir, `core_lists.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load common words with baseline effort scores
      */
-    loadCommonWords() {
-        const filePath = getPath().join(this.dataDir, `common_words.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+    async loadCommonWords() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `common_words.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load synonym mappings
      */
-    loadSynonyms() {
-        const filePath = getPath().join(this.dataDir, `synonyms.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+    async loadSynonyms() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `synonyms.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load test sentences
      */
-    loadSentences() {
-        const filePath = getPath().join(this.dataDir, `sentences.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+    async loadSentences() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `sentences.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load fringe vocabulary
      */
-    loadFringe() {
-        const filePath = getPath().join(this.dataDir, `fringe.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+    async loadFringe() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `fringe.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         const data = JSON.parse(String(content));
         // Flatten nested category words if needed
         if (Array.isArray(data) && data.length > 0 && data[0].categories) {
@@ -71,9 +77,10 @@ export class ReferenceLoader {
     /**
      * Load base words hash map
      */
-    loadBaseWords() {
-        const filePath = getPath().join(this.dataDir, `base_words.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+    async loadBaseWords() {
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `base_words.${this.locale}.json`);
+        const content = await readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
@@ -81,10 +88,10 @@ export class ReferenceLoader {
      * Common words that are NOT in core vocabulary lists
      * (matching Ruby loader.rb:413-420)
      */
-    loadCommonFringe() {
-        const commonWordsData = this.loadCommonWords();
+    async loadCommonFringe() {
+        const commonWordsData = await this.loadCommonWords();
         const commonWords = new Set(commonWordsData.words.map((w) => w.toLowerCase()));
-        const coreLists = this.loadCoreLists();
+        const coreLists = await this.loadCoreLists();
         const coreWords = new Set();
         coreLists.forEach((list) => {
             list.words.forEach((word) => coreWords.add(word.toLowerCase()));
@@ -96,27 +103,28 @@ export class ReferenceLoader {
     /**
      * Get all reference data at once
      */
-    loadAll() {
+    async loadAll() {
         return {
-            coreLists: this.loadCoreLists(),
-            commonWords: this.loadCommonWords(),
-            synonyms: this.loadSynonyms(),
-            sentences: this.loadSentences(),
-            fringe: this.loadFringe(),
-            baseWords: this.loadBaseWords(),
+            coreLists: await this.loadCoreLists(),
+            commonWords: await this.loadCommonWords(),
+            synonyms: await this.loadSynonyms(),
+            sentences: await this.loadSentences(),
+            fringe: await this.loadFringe(),
+            baseWords: await this.loadBaseWords(),
         };
     }
 }
 /**
  * Get the default reference data path
  */
-export function getReferenceDataPath() {
-    return String(getPath().join(__dirname, 'data'));
+export function getReferenceDataPath(fileAdapter = defaultFileAdapter) {
+    return String(fileAdapter.join(__dirname, 'data'));
 }
 /**
  * Check if reference data files exist
  */
-export function hasReferenceData() {
+export async function hasReferenceData(fileAdapter = defaultFileAdapter) {
+    const { pathExists, join } = fileAdapter;
     const dataPath = getReferenceDataPath();
     const requiredFiles = [
         'core_lists.en.json',
@@ -125,5 +133,6 @@ export function hasReferenceData() {
         'synonyms.en.json',
         'fringe.en.json',
     ];
-    return requiredFiles.every((file) => getFs().existsSync(getPath().join(dataPath, file)));
+    const existingPaths = await Promise.all(requiredFiles.map(async (file) => await pathExists(join(dataPath, file))));
+    return existingPaths.every((exists) => exists);
 }

package/dist/browser/utils/io.js

@@ -20,11 +20,11 @@ export function getNodeRequire() {
     }
     return cachedRequire;
 }
-export function getFs() {
+function getFs() {
     if (!cachedFs) {
         try {
             const nodeRequire = getNodeRequire();
-            const fsModule = 'fs';
+            const fsModule = 'node:fs';
             cachedFs = nodeRequire(fsModule);
         }
         catch {
@@ -36,7 +36,7 @@ export function getFs() {
     }
     return cachedFs;
 }
-export function getPath() {
+function getPath() {
     if (!cachedPath) {
         try {
             const nodeRequire = getNodeRequire();
@@ -114,37 +114,94 @@ export function encodeText(text) {
     }
     return new TextEncoder().encode(text);
 }
-export function readBinaryFromInput(input) {
+// extname algorithm from node:path
+const splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/; //eslint-disable-line
+const splitTailRe = /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/; //eslint-disable-line
+export function extname(path) {
+    const tail = splitDeviceRe.exec(path)?.at(3) ?? '';
+    return splitTailRe.exec(tail)?.at(3) ?? '';
+}
+async function readBinaryFromInput(input) {
     if (typeof input === 'string') {
-        const fs = getFs();
-        return fs.readFileSync(input);
+        return Promise.resolve(getFs().readFileSync(input));
     }
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
-        return input;
+        return Promise.resolve(input);
     }
     if (input instanceof ArrayBuffer) {
-        return new Uint8Array(input);
+        return Promise.resolve(new Uint8Array(input));
     }
-    return input;
+    return Promise.resolve(input);
 }
-export function readTextFromInput(input, encoding = 'utf8') {
+async function readTextFromInput(input, encoding = 'utf8') {
     if (typeof input === 'string') {
-        const fs = getFs();
-        return fs.readFileSync(input, encoding);
+        return Promise.resolve(getFs().readFileSync(input, encoding));
     }
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
-        return input.toString(encoding);
+        return Promise.resolve(input.toString(encoding));
     }
     if (input instanceof ArrayBuffer) {
-        return decodeText(new Uint8Array(input));
+        return Promise.resolve(decodeText(new Uint8Array(input)));
     }
-    return decodeText(input);
+    return Promise.resolve(decodeText(input));
+}
+async function writeBinaryToPath(outputPath, data) {
+    getFs().writeFileSync(outputPath, data);
+    await Promise.resolve();
+}
+async function writeTextToPath(outputPath, text) {
+    getFs().writeFileSync(outputPath, text, 'utf8');
+    await Promise.resolve();
+}
+async function pathExists(path) {
+    return Promise.resolve(getFs().existsSync(path));
+}
+async function isDirectory(path) {
+    return Promise.resolve(getFs().statSync(path).isDirectory());
+}
+async function getFileSize(path) {
+    return Promise.resolve(getFs().statSync(path).size);
+}
+async function mkDir(path, options) {
+    getFs().mkdirSync(path, options);
+    await Promise.resolve();
+}
+async function listDir(path) {
+    return Promise.resolve(getFs().readdirSync(path));
+}
+async function removePath(path, options) {
+    getFs().rmSync(path, options);
+    await Promise.resolve();
+}
+async function mkTempDir(prefix) {
+    const path = join(getOs().tmpdir(), prefix);
+    return Promise.resolve(getFs().mkdtempSync(path));
+}
+function join(...pathParts) {
+    return getPath().join(...pathParts);
+}
+export function joinWin32(...pathParts) {
+    return getPath().win32.join(...pathParts);
 }
-export function writeBinaryToPath(outputPath, data) {
-    const fs = getFs();
-    fs.writeFileSync(outputPath, data);
+function dirname(path) {
+    return getPath().dirname(path);
 }
-export function writeTextToPath(outputPath, text) {
-    const fs = getFs();
-    fs.writeFileSync(outputPath, text, 'utf8');
+function basename(path, suffix) {
+    return getPath().basename(path, suffix);
 }
+export const defaultFileAdapter = {
+    readBinaryFromInput,
+    readTextFromInput,
+    writeBinaryToPath,
+    writeTextToPath,
+    pathExists,
+    isDirectory,
+    getFileSize,
+    mkDir,
+    listDir,
+    removePath,
+    mkTempDir,
+    join,
+    dirname,
+    basename,
+};

package/dist/browser/utils/sqlite.js

@@ -1,4 +1,4 @@
-import { getFs, getNodeRequire, getOs, getPath, isNodeRuntime, readBinaryFromInput } from './io';
+import { defaultFileAdapter, getNodeRequire, isNodeRuntime } from './io';
 let sqlJsConfig = null;
 let sqlJsPromise = null;
 export function configureSqlJs(config) {
@@ -70,6 +70,7 @@ export function requireBetterSqlite3() {
     return getBetterSqlite3();
 }
 export async function openSqliteDatabase(input, options = {}) {
+    const { readBinaryFromInput, mkTempDir, writeBinaryToPath, removePath, join } = options.fileAdapter ?? defaultFileAdapter;
     if (typeof input === 'string') {
         if (!isNodeRuntime()) {
             throw new Error('SQLite file paths are not supported in browser environments.');
@@ -78,27 +79,24 @@ export async function openSqliteDatabase(input, options = {}) {
         const db = new Database(input, { readonly: options.readonly ?? true });
         return { db };
     }
-    const data = readBinaryFromInput(input);
+    const data = await 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 tempDir = await mkTempDir('aac-sqlite-');
+    const dbPath = join(tempDir, 'input.sqlite');
+    await writeBinaryToPath(dbPath, data);
     const Database = getBetterSqlite3();
     const db = new Database(dbPath, { readonly: options.readonly ?? true });
-    const cleanup = () => {
+    const cleanup = async () => {
         try {
             db.close();
         }
         finally {
             try {
-                fs.rmSync(tempDir, { recursive: true, force: true });
+                await removePath(tempDir, { recursive: true, force: true });
             }
             catch (error) {
                 console.warn('Failed to clean up temporary SQLite files:', error);

package/dist/browser/utils/zip.js

@@ -1,54 +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);
+import { isNodeRuntime, getNodeRequire, defaultFileAdapter, } from './io';
+export async function getZipAdapter(input, fileAdapter) {
+    const adapter = fileAdapter ?? defaultFileAdapter;
     if (isNodeRuntime()) {
         const AdmZip = getNodeRequire()('adm-zip');
-        const admZip = new AdmZip(Buffer.from(data));
+        const zip = input === undefined
+            ? new AdmZip(input)
+            : typeof input === 'string'
+                ? new AdmZip(input)
+                : new AdmZip(Buffer.from(await adapter.readBinaryFromInput(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());
-                },
+            listFiles: () => {
+                return zip
+                    .getEntries()
+                    .filter((entry) => !entry.isDirectory)
+                    .map((entry) => entry.entryName);
+            },
+            readFile: (name) => {
+                const entry = zip.getEntry(name);
+                if (!entry)
+                    throw new Error(`Zip entry not found: ${name}`);
+                return Promise.resolve(entry.getData());
+            },
+            writeFiles: (files) => {
+                files.forEach((file) => {
+                    zip.addFile(file.name, Buffer.from(file.data));
+                });
+                return Promise.resolve(zip.toBuffer());
             },
         };
     }
     const module = await import('jszip');
-    const init = module.default || module;
-    const zip = await init.loadAsync(data);
+    const JSZip = module.default || module;
+    const zip = input ? await JSZip.loadAsync(await adapter.readBinaryFromInput(input)) : new JSZip();
     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');
-            },
+        listFiles: () => {
+            return Object.entries(zip.files)
+                .filter(([_, entry]) => !entry.dir)
+                .map(([name, _]) => name);
+        },
+        readFile: async (name) => {
+            const file = zip.file(name);
+            if (!file)
+                throw new Error(`Zip entry not found: ${name}`);
+            return file.async('uint8array');
+        },
+        writeFiles: async (files) => {
+            files.forEach((file) => {
+                zip.file(file.name, file.data);
+            });
+            return await zip.generateAsync({ type: 'uint8array' });
         },
     };
 }

package/dist/browser/validation/baseValidator.js

@@ -1,3 +1,5 @@
+import { defaultFileAdapter } from '../utils/io';
+import { getZipAdapter } from '../utils/zip';
 import { ValidationError, } from './validationTypes';
 /**
  * Base class for all format validators
@@ -14,6 +16,9 @@ export class BaseValidator {
             includeWarnings: options.includeWarnings ?? true,
             stopOnBlocker: options.stopOnBlocker ?? true,
             customRules: options.customRules || [],
+            fileAdapter: defaultFileAdapter,
+            zipAdapter: getZipAdapter,
+            ...options,
         };
         this.reset();
     }

package/dist/browser/validation/gridsetValidator.js

@@ -1,10 +1,9 @@
 /* eslint-disable @typescript-eslint/require-await */
 /* 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 { decodeText, getBasename, getFs, toUint8Array } from '../utils/io';
+import { decodeText, defaultFileAdapter, getBasename, toUint8Array, } from '../utils/io';
 /**
  * Validator for Grid3/Smartbox Gridset files (.gridset, .gridsetx)
  */
@@ -15,12 +14,12 @@ export class GridsetValidator extends BaseValidator {
     /**
      * Validate a Gridset file from disk
      */
-    static async validateFile(filePath) {
+    static async validateFile(filePath, fileAdapter) {
+        const { readBinaryFromInput, getFileSize } = fileAdapter ?? defaultFileAdapter;
         const validator = new GridsetValidator();
-        const fs = getFs();
-        const content = fs.readFileSync(filePath);
-        const stats = fs.statSync(filePath);
-        return validator.validate(content, getBasename(filePath), stats.size);
+        const content = await readBinaryFromInput(filePath);
+        const size = await getFileSize(filePath);
+        return validator.validate(content, getBasename(filePath), size);
     }
     /**
      * Check if content is Gridset format
@@ -109,24 +108,17 @@ export class GridsetValidator extends BaseValidator {
      * Validate a ZIP archive (.gridset)
      */
     async validateZipArchive(content, filename, _filesize) {
-        let zip;
-        try {
-            zip = await JSZip.loadAsync(toUint8Array(content));
-        }
-        catch (e) {
-            this.err(`Failed to open ZIP archive: ${e.message}`, true);
-            return;
-        }
-        const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+        const zip = await this._options.zipAdapter(content);
+        const entries = zip.listFiles();
         // Check for gridset.xml (required)
         await this.add_check('gridset_xml_presence', 'gridset.xml presence', async () => {
-            const gridsetEntry = entries.find((e) => e.name.toLowerCase() === 'gridset.xml');
+            const gridsetEntry = entries.find((e) => e.toLowerCase() === 'gridset.xml');
             if (!gridsetEntry) {
                 this.err('Missing gridset.xml in archive', true);
             }
             else {
                 try {
-                    const gridsetXml = await gridsetEntry.async('string');
+                    const gridsetXml = await zip.readFile(gridsetEntry);
                     const parser = new xml2js.Parser();
                     const xmlObj = await parser.parseStringPromise(gridsetXml);
                     const gridset = xmlObj.gridset || xmlObj.Gridset;
@@ -144,13 +136,13 @@ export class GridsetValidator extends BaseValidator {
         });
         // Check for settings.xml (highly recommended/required for metadata)
         await this.add_check('settings_xml_presence', 'settings.xml presence', async () => {
-            const settingsEntry = entries.find((e) => e.name.toLowerCase() === 'settings.xml');
+            const settingsEntry = entries.find((e) => e.toLowerCase() === 'settings.xml');
             if (!settingsEntry) {
                 this.warn('Missing settings.xml in archive (required for full metadata)');
             }
             else {
                 try {
-                    const settingsXml = await settingsEntry.async('string');
+                    const settingsXml = await zip.readFile(settingsEntry);
                     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 { decodeText, getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
+import { decodeText, defaultFileAdapter, getBasename, toUint8Array, } from '../utils/io';
 const OBF_FORMAT = 'open-board-0.1';
 const OBF_FORMAT_CURRENT_VERSION = 0.1;
 /**
@@ -18,11 +18,12 @@ export class ObfValidator extends BaseValidator {
     /**
      * Validate an OBF file from disk
      */
-    static async validateFile(filePath) {
+    static async validateFile(filePath, fileAdapter) {
+        const { readBinaryFromInput, getFileSize } = fileAdapter ?? defaultFileAdapter;
         const validator = new ObfValidator();
-        const content = readBinaryFromInput(filePath);
-        const stats = getFs().statSync(filePath);
-        return validator.validate(content, getBasename(filePath), stats.size);
+        const content = await readBinaryFromInput(filePath);
+        const size = await getFileSize(filePath);
+        return validator.validate(content, getBasename(filePath), size);
     }
     /**
      * Check if content is OBF format