@willwade/aac-processors 0.1.7 → 0.1.8

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

@@ -0,0 +1,138 @@
+/**
+ * Vocabulary Coverage Analysis
+ *
+ * Analyzes how well an AAC board set covers core vocabulary
+ * and identifies missing/extra words compared to reference lists.
+ */
+import { ReferenceLoader } from '../reference/index';
+import { spellingEffort } from './effort';
+export class VocabularyAnalyzer {
+    constructor(referenceLoader) {
+        this.referenceLoader = referenceLoader || new ReferenceLoader();
+    }
+    /**
+     * Analyze vocabulary coverage against core lists
+     */
+    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();
+        // Create word to effort map (using lowercase keys for matching)
+        const wordEffortMap = new Map();
+        metrics.buttons.forEach((btn) => {
+            const word = btn.label.toLowerCase();
+            const existing = wordEffortMap.get(word);
+            if (!existing || btn.effort < existing) {
+                wordEffortMap.set(word, btn.effort);
+            }
+        });
+        // Analyze each core list
+        const core_coverage = {};
+        coreLists.forEach((list) => {
+            const analysis = this.analyzeCoreList(list, wordEffortMap);
+            core_coverage[list.id] = analysis;
+        });
+        // Find extra words (words not in any core list)
+        const allCoreWords = new Set();
+        coreLists.forEach((list) => {
+            list.words.forEach((word) => allCoreWords.add(word.toLowerCase()));
+        });
+        const extraWords = [];
+        wordEffortMap.forEach((effort, word) => {
+            if (!allCoreWords.has(word.toLowerCase())) {
+                extraWords.push(word);
+            }
+        });
+        extraWords.sort((a, b) => a.localeCompare(b));
+        // Find high/low effort words
+        const highEffortWords = [];
+        const lowEffortWords = [];
+        wordEffortMap.forEach((effort, word) => {
+            if (effort > highEffortThreshold) {
+                highEffortWords.push({ word, effort });
+            }
+            else if (effort < lowEffortThreshold) {
+                lowEffortWords.push({ word, effort });
+            }
+        });
+        highEffortWords.sort((a, b) => b.effort - a.effort);
+        lowEffortWords.sort((a, b) => a.effort - b.effort);
+        return {
+            core_coverage,
+            total_unique_words: wordEffortMap.size,
+            words_with_effort: wordEffortMap.size,
+            words_requiring_spelling: 0, // Calculated during sentence analysis
+            extra_words: extraWords,
+            high_effort_words: highEffortWords.slice(0, 50), // Top 50
+            low_effort_words: lowEffortWords.slice(0, 50), // Bottom 50
+        };
+    }
+    /**
+     * Analyze coverage for a single core list
+     */
+    analyzeCoreList(list, wordEffortMap) {
+        const covered = [];
+        const missing = [];
+        let totalEffort = 0;
+        list.words.forEach((word) => {
+            const lowerWord = word.toLowerCase();
+            const effort = wordEffortMap.get(lowerWord);
+            if (effort !== undefined) {
+                covered.push(word);
+                totalEffort += effort;
+            }
+            else {
+                missing.push(word);
+            }
+        });
+        const averageEffort = covered.length > 0 ? totalEffort / covered.length : 0;
+        return {
+            name: list.name,
+            total_words: list.words.length,
+            covered: covered.length,
+            missing: missing.length,
+            coverage_percent: (covered.length / list.words.length) * 100,
+            missing_words: missing,
+            average_effort: averageEffort,
+        };
+    }
+    /**
+     * Calculate coverage percentage for a specific word list
+     */
+    calculateCoverage(wordList, metrics) {
+        const wordSet = new Set(metrics.buttons.map((btn) => btn.label.toLowerCase()));
+        const covered = [];
+        const missing = [];
+        wordList.forEach((word) => {
+            if (wordSet.has(word.toLowerCase())) {
+                covered.push(word);
+            }
+            else {
+                missing.push(word);
+            }
+        });
+        return {
+            covered,
+            missing,
+            coverage_percent: (covered.length / wordList.length) * 100,
+        };
+    }
+    /**
+     * Get effort for a word, or calculate spelling effort if missing
+     */
+    getWordEffort(word, metrics) {
+        const btn = metrics.buttons.find((b) => b.label.toLowerCase() === word.toLowerCase());
+        if (btn) {
+            return btn.effort;
+        }
+        return spellingEffort(word, metrics.spelling_effort_base, metrics.spelling_effort_per_letter);
+    }
+    /**
+     * Check if a word is in the board set
+     */
+    hasWord(word, metrics) {
+        return metrics.buttons.some((b) => b.label.toLowerCase() === word.toLowerCase());
+    }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Browser-friendly reference data loader using fetch.
+ */
+export 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;
+    }
+}
+export 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,
+    };
+}
+export async function createBrowserReferenceLoader(baseUrl, locale = 'en') {
+    const data = await loadReferenceDataFromUrl(baseUrl, locale);
+    return new InMemoryReferenceLoader(data);
+}

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

@@ -0,0 +1,129 @@
+/**
+ * Reference Data Loader
+ *
+ * Loads reference vocabulary lists, core lists, and sentences
+ * for AAC metrics analysis.
+ */
+import { getFs, getPath } from '../../../utils/io';
+export class ReferenceLoader {
+    constructor(dataDir, locale = 'en') {
+        this.locale = locale;
+        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');
+        }
+    }
+    /**
+     * Load core vocabulary lists
+     */
+    loadCoreLists() {
+        const filePath = getPath().join(this.dataDir, `core_lists.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        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');
+        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');
+        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');
+        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');
+        const data = JSON.parse(String(content));
+        // Flatten nested category words if needed
+        if (Array.isArray(data) && data.length > 0 && data[0].categories) {
+            const flattened = [];
+            data.forEach((list) => {
+                list.categories.forEach((cat) => {
+                    flattened.push(...cat.words);
+                });
+            });
+            return flattened;
+        }
+        return data;
+    }
+    /**
+     * Load base words hash map
+     */
+    loadBaseWords() {
+        const filePath = getPath().join(this.dataDir, `base_words.${this.locale}.json`);
+        const content = getFs().readFileSync(filePath, 'utf-8');
+        return JSON.parse(String(content));
+    }
+    /**
+     * Load common fringe vocabulary
+     * Common words that are NOT in core vocabulary lists
+     * (matching Ruby loader.rb:413-420)
+     */
+    loadCommonFringe() {
+        const commonWordsData = this.loadCommonWords();
+        const commonWords = new Set(commonWordsData.words.map((w) => w.toLowerCase()));
+        const coreLists = this.loadCoreLists();
+        const coreWords = new Set();
+        coreLists.forEach((list) => {
+            list.words.forEach((word) => coreWords.add(word.toLowerCase()));
+        });
+        // Common fringe = common words - core words
+        const commonFringe = Array.from(commonWords).filter((word) => !coreWords.has(word));
+        return commonFringe;
+    }
+    /**
+     * Get all reference data at once
+     */
+    loadAll() {
+        return {
+            coreLists: this.loadCoreLists(),
+            commonWords: this.loadCommonWords(),
+            synonyms: this.loadSynonyms(),
+            sentences: this.loadSentences(),
+            fringe: this.loadFringe(),
+            baseWords: this.loadBaseWords(),
+        };
+    }
+}
+/**
+ * Get the default reference data path
+ */
+export function getReferenceDataPath() {
+    return String(getPath().join(__dirname, 'data'));
+}
+/**
+ * Check if reference data files exist
+ */
+export function hasReferenceData() {
+    const dataPath = getReferenceDataPath();
+    const requiredFiles = [
+        'core_lists.en.json',
+        'common_words.en.json',
+        'sentences.en.json',
+        'synonyms.en.json',
+        'fringe.en.json',
+    ];
+    return requiredFiles.every((file) => getFs().existsSync(getPath().join(dataPath, file)));
+}

package/dist/browser/utils/dotnetTicks.js

@@ -0,0 +1,17 @@
+/**
+ * Number of ticks (.NET 100ns units) between 0001-01-01 and Unix epoch.
+ */
+export const DOTNET_EPOCH_TICKS = 621355968000000000n;
+/**
+ * Number of ticks per millisecond.
+ */
+export const TICKS_PER_MILLISECOND = 10000n;
+/**
+ * Convert .NET ticks (100ns since 0001-01-01) to a JavaScript Date.
+ * Accepts bigint or number and rounds down to millisecond precision.
+ */
+export function dotNetTicksToDate(ticks) {
+    const tickValue = BigInt(ticks);
+    const ms = Number((tickValue - DOTNET_EPOCH_TICKS) / TICKS_PER_MILLISECOND);
+    return new Date(ms);
+}

package/dist/index.browser.d.ts

@@ -22,6 +22,7 @@ export { SnapProcessor } from './processors/snapProcessor';
 export { TouchChatProcessor } from './processors/touchchatProcessor';
 export { ApplePanelsProcessor } from './processors/applePanelsProcessor';
 export { AstericsGridProcessor } from './processors/astericsGridProcessor';
+export * as Metrics from './metrics';
 import { BaseProcessor } from './core/baseProcessor';
 export { configureSqlJs } from './utils/sqlite';
 /**

package/dist/index.browser.js

@@ -23,11 +23,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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 __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+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.configureSqlJs = exports.AstericsGridProcessor = exports.ApplePanelsProcessor = exports.TouchChatProcessor = exports.SnapProcessor = exports.GridsetProcessor = exports.ObfProcessor = exports.OpmlProcessor = exports.DotProcessor = void 0;
+exports.configureSqlJs = exports.Metrics = exports.AstericsGridProcessor = exports.ApplePanelsProcessor = exports.TouchChatProcessor = exports.SnapProcessor = exports.GridsetProcessor = exports.ObfProcessor = exports.OpmlProcessor = exports.DotProcessor = void 0;
 exports.getProcessor = getProcessor;
 exports.getSupportedExtensions = getSupportedExtensions;
 exports.isExtensionSupported = isExtensionSupported;
@@ -56,6 +68,11 @@ var applePanelsProcessor_1 = require("./processors/applePanelsProcessor");
 Object.defineProperty(exports, "ApplePanelsProcessor", { enumerable: true, get: function () { return applePanelsProcessor_1.ApplePanelsProcessor; } });
 var astericsGridProcessor_1 = require("./processors/astericsGridProcessor");
 Object.defineProperty(exports, "AstericsGridProcessor", { enumerable: true, get: function () { return astericsGridProcessor_1.AstericsGridProcessor; } });
+// ===================================================================
+// UTILITY FUNCTIONS
+// ===================================================================
+// Metrics namespace (pageset analytics)
+exports.Metrics = __importStar(require("./metrics"));
 const dotProcessor_2 = require("./processors/dotProcessor");
 const opmlProcessor_2 = require("./processors/opmlProcessor");
 const obfProcessor_2 = require("./processors/obfProcessor");

package/dist/index.node.d.ts

@@ -9,9 +9,9 @@ export * from './core/treeStructure';
 export * from './core/baseProcessor';
 export * from './core/stringCasing';
 export * from './processors';
-export * as Analytics from './utilities/analytics';
-export * from './utilities/analytics';
+export * as Analytics from './analytics';
 export * as Validation from './validation';
+export * as Metrics from './metrics';
 export * as Gridset from './gridset';
 export * as Snap from './snap';
 export * as OBF from './obf';

package/dist/index.node.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Translation = exports.AstericsGrid = exports.ApplePanels = exports.Opml = exports.Excel = exports.Dot = exports.TouchChat = exports.Obfset = exports.OBF = exports.Snap = exports.Gridset = exports.Validation = exports.Analytics = void 0;
+exports.Translation = exports.AstericsGrid = exports.ApplePanels = exports.Opml = exports.Excel = exports.Dot = exports.TouchChat = exports.Obfset = exports.OBF = exports.Snap = exports.Gridset = exports.Metrics = exports.Validation = exports.Analytics = void 0;
 exports.getProcessor = getProcessor;
 exports.getSupportedExtensions = getSupportedExtensions;
 exports.isExtensionSupported = isExtensionSupported;
@@ -50,12 +50,12 @@ __exportStar(require("./processors"), exports);
 // ===================================================================
 // NAMESPACES
 // ===================================================================
-// Analytics namespace
-exports.Analytics = __importStar(require("./utilities/analytics"));
-// Also export analytics classes directly for convenience
-__exportStar(require("./utilities/analytics"), exports);
+// Analytics namespace (usage/history)
+exports.Analytics = __importStar(require("./analytics"));
 // Validation namespace
 exports.Validation = __importStar(require("./validation"));
+// Metrics namespace (pageset analytics)
+exports.Metrics = __importStar(require("./metrics"));
 // Processor namespaces (platform-specific utilities)
 exports.Gridset = __importStar(require("./gridset"));
 exports.Snap = __importStar(require("./snap"));

package/dist/metrics.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Metrics Namespace
+ *
+ * Pageset-focused metrics and analytics (board structure, effort, vocabulary).
+ * Use this for analyzing AAC trees, not end-user usage logs.
+ */
+export * from './utilities/analytics/metrics/types';
+export * from './utilities/analytics/metrics/effort';
+export * from './utilities/analytics/metrics/obl-types';
+export { OblUtil, OblAnonymizer } from './utilities/analytics/metrics/obl';
+export { MetricsCalculator } from './utilities/analytics/metrics/core';
+export { VocabularyAnalyzer } from './utilities/analytics/metrics/vocabulary';
+export { SentenceAnalyzer } from './utilities/analytics/metrics/sentence';
+export { ComparisonAnalyzer } from './utilities/analytics/metrics/comparison';
+export { ReferenceLoader } from './utilities/analytics/reference';
+export { InMemoryReferenceLoader, createBrowserReferenceLoader, loadReferenceDataFromUrl, type ReferenceData, } from './utilities/analytics/reference/browser';
+export * from './utilities/analytics/utils/idGenerator';

package/dist/metrics.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Metrics Namespace
+ *
+ * Pageset-focused metrics and analytics (board structure, effort, vocabulary).
+ * Use this for analyzing AAC trees, not end-user usage logs.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadReferenceDataFromUrl = exports.createBrowserReferenceLoader = exports.InMemoryReferenceLoader = exports.ReferenceLoader = exports.ComparisonAnalyzer = exports.SentenceAnalyzer = exports.VocabularyAnalyzer = exports.MetricsCalculator = exports.OblAnonymizer = exports.OblUtil = void 0;
+__exportStar(require("./utilities/analytics/metrics/types"), exports);
+__exportStar(require("./utilities/analytics/metrics/effort"), exports);
+__exportStar(require("./utilities/analytics/metrics/obl-types"), exports);
+var obl_1 = require("./utilities/analytics/metrics/obl");
+Object.defineProperty(exports, "OblUtil", { enumerable: true, get: function () { return obl_1.OblUtil; } });
+Object.defineProperty(exports, "OblAnonymizer", { enumerable: true, get: function () { return obl_1.OblAnonymizer; } });
+var core_1 = require("./utilities/analytics/metrics/core");
+Object.defineProperty(exports, "MetricsCalculator", { enumerable: true, get: function () { return core_1.MetricsCalculator; } });
+var vocabulary_1 = require("./utilities/analytics/metrics/vocabulary");
+Object.defineProperty(exports, "VocabularyAnalyzer", { enumerable: true, get: function () { return vocabulary_1.VocabularyAnalyzer; } });
+var sentence_1 = require("./utilities/analytics/metrics/sentence");
+Object.defineProperty(exports, "SentenceAnalyzer", { enumerable: true, get: function () { return sentence_1.SentenceAnalyzer; } });
+var comparison_1 = require("./utilities/analytics/metrics/comparison");
+Object.defineProperty(exports, "ComparisonAnalyzer", { enumerable: true, get: function () { return comparison_1.ComparisonAnalyzer; } });
+var reference_1 = require("./utilities/analytics/reference");
+Object.defineProperty(exports, "ReferenceLoader", { enumerable: true, get: function () { return reference_1.ReferenceLoader; } });
+var browser_1 = require("./utilities/analytics/reference/browser");
+Object.defineProperty(exports, "InMemoryReferenceLoader", { enumerable: true, get: function () { return browser_1.InMemoryReferenceLoader; } });
+Object.defineProperty(exports, "createBrowserReferenceLoader", { enumerable: true, get: function () { return browser_1.createBrowserReferenceLoader; } });
+Object.defineProperty(exports, "loadReferenceDataFromUrl", { enumerable: true, get: function () { return browser_1.loadReferenceDataFromUrl; } });
+__exportStar(require("./utilities/analytics/utils/idGenerator"), exports);

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);
+}