@willwade/aac-processors 0.1.6 → 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/browser/utils/io.js

@@ -72,8 +72,22 @@ 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/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

@@ -1,10 +1,9 @@
 /* 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';
+import { getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
 /**
  * Validator for Snap files (.spb, .sps)
  * Snap files are zipped packages containing XML configuration
@@ -18,9 +17,9 @@ export class SnapValidator extends BaseValidator {
      */
     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);
+        const content = readBinaryFromInput(filePath);
+        const stats = getFs().statSync(filePath);
+        return validator.validate(content, getBasename(filePath), stats.size);
     }
     /**
      * Check if content is Snap format
@@ -33,8 +32,7 @@ export class SnapValidator extends BaseValidator {
         }
         // 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 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'));
         }
@@ -56,8 +54,7 @@ export class SnapValidator extends BaseValidator {
         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);
+                zip = await JSZip.loadAsync(toUint8Array(content));
                 const entries = Object.values(zip.files);
                 validZip = entries.length > 0;
             }

package/dist/browser/validation/touchChatValidator.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 * as fs from 'fs';
-import * as path from 'path';
 import * as xml2js from 'xml2js';
 import { BaseValidator } from './baseValidator';
+import { decodeText, getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
 /**
  * Validator for TouchChat files (.ce)
  * TouchChat files are XML-based
@@ -18,9 +17,9 @@ export class TouchChatValidator extends BaseValidator {
      */
     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);
+        const content = readBinaryFromInput(filePath);
+        const stats = getFs().statSync(filePath);
+        return validator.validate(content, getBasename(filePath), stats.size);
     }
     /**
      * Check if content is TouchChat format
@@ -32,7 +31,7 @@ export class TouchChatValidator extends BaseValidator {
         }
         // Try to parse as XML and check for TouchChat structure
         try {
-            const contentStr = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
+            const contentStr = typeof content === 'string' ? content : decodeText(toUint8Array(content));
             const parser = new xml2js.Parser();
             const result = await parser.parseStringPromise(contentStr);
             // TouchChat files typically have specific structure
@@ -56,7 +55,7 @@ export class TouchChatValidator extends BaseValidator {
         await this.add_check('xml_parse', 'valid XML', async () => {
             try {
                 const parser = new xml2js.Parser();
-                const contentStr = content.toString('utf-8');
+                const contentStr = decodeText(content);
                 xmlObj = await parser.parseStringPromise(contentStr);
             }
             catch (e) {

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';