@willwade/aac-processors 0.1.7 → 0.1.9

package/dist/utilities/analytics/metrics/comparison.d.ts

@@ -5,12 +5,13 @@
  * analyze vocabulary differences, and generate CARE component scores.
  */
 import { MetricsResult, ComparisonResult } from './types';
+import { type ReferenceDataProvider } from '../reference/index';
 import { MetricsOptions } from './types';
 export declare class ComparisonAnalyzer {
     private vocabAnalyzer;
     private sentenceAnalyzer;
     private referenceLoader;
-    constructor();
+    constructor(referenceLoader?: ReferenceDataProvider);
     private normalize;
     /**
      * Compare two board sets

package/dist/utilities/analytics/metrics/comparison.js

@@ -12,10 +12,10 @@ const vocabulary_1 = require("./vocabulary");
 const index_1 = require("../reference/index");
 const effort_1 = require("./effort");
 class ComparisonAnalyzer {
-    constructor() {
-        this.vocabAnalyzer = new vocabulary_1.VocabularyAnalyzer();
+    constructor(referenceLoader) {
+        this.vocabAnalyzer = new vocabulary_1.VocabularyAnalyzer(referenceLoader);
         this.sentenceAnalyzer = new sentence_1.SentenceAnalyzer();
-        this.referenceLoader = new index_1.ReferenceLoader();
+        this.referenceLoader = referenceLoader || new index_1.ReferenceLoader();
     }
     normalize(word) {
         return word

package/dist/utilities/analytics/metrics/vocabulary.d.ts

@@ -5,7 +5,7 @@
  * and identifies missing/extra words compared to reference lists.
  */
 import { MetricsResult } from './types';
-import { ReferenceLoader } from '../reference/index';
+import { type ReferenceDataProvider } from '../reference/index';
 export interface VocabularyAnalysis {
     core_coverage: {
         [listId: string]: {
@@ -33,7 +33,7 @@ export interface VocabularyAnalysis {
 }
 export declare class VocabularyAnalyzer {
     private referenceLoader;
-    constructor(referenceLoader?: ReferenceLoader);
+    constructor(referenceLoader?: ReferenceDataProvider);
     /**
      * Analyze vocabulary coverage against core lists
      */

package/dist/utilities/analytics/reference/browser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Browser-friendly reference data loader using fetch.
+ */
+import type { CoreList, CommonWordsData, SynonymsData } from '../metrics/types';
+import type { ReferenceDataProvider } from './index';
+export interface ReferenceData {
+    coreLists: CoreList[];
+    commonWords: CommonWordsData;
+    synonyms: SynonymsData;
+    sentences: string[][];
+    fringe: string[];
+    baseWords: {
+        [word: string]: boolean;
+    };
+}
+export declare class InMemoryReferenceLoader implements ReferenceDataProvider {
+    private data;
+    constructor(data: ReferenceData);
+    loadCoreLists(): CoreList[];
+    loadCommonWords(): CommonWordsData;
+    loadSynonyms(): SynonymsData;
+    loadSentences(): string[][];
+    loadFringe(): string[];
+    loadBaseWords(): {
+        [word: string]: boolean;
+    };
+    loadCommonFringe(): string[];
+    loadAll(): ReferenceData;
+}
+export declare function loadReferenceDataFromUrl(baseUrl: string, locale?: string): Promise<ReferenceData>;
+export declare function createBrowserReferenceLoader(baseUrl: string, locale?: string): Promise<InMemoryReferenceLoader>;

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

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Browser-friendly reference data loader using fetch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryReferenceLoader = void 0;
+exports.loadReferenceDataFromUrl = loadReferenceDataFromUrl;
+exports.createBrowserReferenceLoader = createBrowserReferenceLoader;
+class InMemoryReferenceLoader {
+    constructor(data) {
+        this.data = data;
+    }
+    loadCoreLists() {
+        return this.data.coreLists;
+    }
+    loadCommonWords() {
+        return this.data.commonWords;
+    }
+    loadSynonyms() {
+        return this.data.synonyms;
+    }
+    loadSentences() {
+        return this.data.sentences;
+    }
+    loadFringe() {
+        return this.data.fringe;
+    }
+    loadBaseWords() {
+        return this.data.baseWords;
+    }
+    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));
+    }
+    loadAll() {
+        return this.data;
+    }
+}
+exports.InMemoryReferenceLoader = InMemoryReferenceLoader;
+async function loadReferenceDataFromUrl(baseUrl, locale = 'en') {
+    const root = baseUrl.replace(/\/$/, '');
+    const fetchJson = async (name) => {
+        const res = await fetch(`${root}/${name}.${locale}.json`);
+        if (!res.ok) {
+            throw new Error(`Failed to load ${name}.${locale}.json`);
+        }
+        return (await res.json());
+    };
+    const [coreLists, commonWords, synonyms, sentences, fringe, baseWords] = await Promise.all([
+        fetchJson('core_lists'),
+        fetchJson('common_words'),
+        fetchJson('synonyms'),
+        fetchJson('sentences'),
+        fetchJson('fringe'),
+        fetchJson('base_words'),
+    ]);
+    return {
+        coreLists,
+        commonWords,
+        synonyms,
+        sentences,
+        fringe,
+        baseWords,
+    };
+}
+async function createBrowserReferenceLoader(baseUrl, locale = 'en') {
+    const data = await loadReferenceDataFromUrl(baseUrl, locale);
+    return new InMemoryReferenceLoader(data);
+}

package/dist/utilities/analytics/reference/index.d.ts

@@ -5,6 +5,27 @@
  * for AAC metrics analysis.
  */
 import { CoreList, CommonWordsData, SynonymsData } from '../metrics/types';
+export interface ReferenceDataProvider {
+    loadCoreLists(): CoreList[];
+    loadCommonWords(): CommonWordsData;
+    loadSynonyms(): SynonymsData;
+    loadSentences(): string[][];
+    loadFringe(): string[];
+    loadBaseWords(): {
+        [word: string]: boolean;
+    };
+    loadCommonFringe(): string[];
+    loadAll(): {
+        coreLists: CoreList[];
+        commonWords: CommonWordsData;
+        synonyms: SynonymsData;
+        sentences: string[][];
+        fringe: string[];
+        baseWords: {
+            [word: string]: boolean;
+        };
+    };
+}
 export declare class ReferenceLoader {
     private dataDir;
     private locale;

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

@@ -5,35 +5,11 @@
  * Loads reference vocabulary lists, core lists, and sentences
  * for AAC metrics analysis.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferenceLoader = void 0;
 exports.getReferenceDataPath = getReferenceDataPath;
 exports.hasReferenceData = hasReferenceData;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+const io_1 = require("../../../utils/io");
 class ReferenceLoader {
     constructor(dataDir, locale = 'en') {
         this.locale = locale;
@@ -43,48 +19,48 @@ class ReferenceLoader {
         else {
             // Resolve the data directory relative to this file's location
             // Use __dirname which works correctly after compilation
-            this.dataDir = path.join(__dirname, 'data');
+            this.dataDir = (0, io_1.getPath)().join(__dirname, 'data');
         }
     }
     /**
      * Load core vocabulary lists
      */
     loadCoreLists() {
-        const filePath = path.join(this.dataDir, `core_lists.${this.locale}.json`);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return JSON.parse(content);
+        const filePath = (0, io_1.getPath)().join(this.dataDir, `core_lists.${this.locale}.json`);
+        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
     }
     /**
      * Load common words with baseline effort scores
      */
     loadCommonWords() {
-        const filePath = path.join(this.dataDir, `common_words.${this.locale}.json`);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return JSON.parse(content);
+        const filePath = (0, io_1.getPath)().join(this.dataDir, `common_words.${this.locale}.json`);
+        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
     }
     /**
      * Load synonym mappings
      */
     loadSynonyms() {
-        const filePath = path.join(this.dataDir, `synonyms.${this.locale}.json`);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return JSON.parse(content);
+        const filePath = (0, io_1.getPath)().join(this.dataDir, `synonyms.${this.locale}.json`);
+        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
     }
     /**
      * Load test sentences
      */
     loadSentences() {
-        const filePath = path.join(this.dataDir, `sentences.${this.locale}.json`);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return JSON.parse(content);
+        const filePath = (0, io_1.getPath)().join(this.dataDir, `sentences.${this.locale}.json`);
+        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
     }
     /**
      * Load fringe vocabulary
      */
     loadFringe() {
-        const filePath = path.join(this.dataDir, `fringe.${this.locale}.json`);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const data = JSON.parse(content);
+        const filePath = (0, io_1.getPath)().join(this.dataDir, `fringe.${this.locale}.json`);
+        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(String(content));
         // Flatten nested category words if needed
         if (Array.isArray(data) && data.length > 0 && data[0].categories) {
             const flattened = [];
@@ -101,9 +77,9 @@ class ReferenceLoader {
      * Load base words hash map
      */
     loadBaseWords() {
-        const filePath = path.join(this.dataDir, `base_words.${this.locale}.json`);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return JSON.parse(content);
+        const filePath = (0, io_1.getPath)().join(this.dataDir, `base_words.${this.locale}.json`);
+        const content = (0, io_1.getFs)().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
     }
     /**
      * Load common fringe vocabulary
@@ -141,7 +117,7 @@ exports.ReferenceLoader = ReferenceLoader;
  * Get the default reference data path
  */
 function getReferenceDataPath() {
-    return path.join(__dirname, 'data');
+    return String((0, io_1.getPath)().join(__dirname, 'data'));
 }
 /**
  * Check if reference data files exist
@@ -155,5 +131,5 @@ function hasReferenceData() {
         'synonyms.en.json',
         'fringe.en.json',
     ];
-    return requiredFiles.every((file) => fs.existsSync(path.join(dataPath, file)));
+    return requiredFiles.every((file) => (0, io_1.getFs)().existsSync((0, io_1.getPath)().join(dataPath, file)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willwade/aac-processors",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "A comprehensive TypeScript library for processing AAC (Augmentative and Alternative Communication) file formats with translation support",
   "main": "dist/index.js",
   "browser": "dist/browser/index.browser.js",
@@ -67,6 +67,14 @@
     "./validation": {
       "types": "./dist/validation.d.ts",
       "default": "./dist/validation.js"
+    },
+    "./metrics": {
+      "types": "./dist/metrics.d.ts",
+      "default": "./dist/metrics.js"
+    },
+    "./analytics": {
+      "types": "./dist/analytics.d.ts",
+      "default": "./dist/analytics.js"
     }
   },
   "files": [