@willwade/aac-processors 0.2.2 → 0.2.4

package/dist/browser/utilities/analytics/morphology/grid3VerbsParser.js

@@ -0,0 +1,455 @@
+import { XMLParser } from 'fast-xml-parser';
+import AdmZip from 'adm-zip';
+import { join, dirname, basename } from 'path';
+export class Grid3VerbsParser {
+    constructor() {
+        this.parser = new XMLParser({
+            ignoreAttributes: false,
+            ignoreDeclaration: true,
+            textNodeName: '#text',
+        });
+    }
+    parseXml(xmlContent, locale) {
+        const data = this.parser.parse(xmlContent);
+        const verbdata = data.verbdata || data.Verbdata;
+        if (!verbdata) {
+            return { locale: locale || 'unknown', verbs: new Map() };
+        }
+        const detectedLocale = verbdata['@_locale'] || verbdata.locale || locale || 'unknown';
+        const ruleSets = this.parseRuleSets(verbdata);
+        const verbs = this.parseVerbs(verbdata);
+        const result = new Map();
+        for (const verb of verbs) {
+            const forms = this.generateForms(verb, ruleSets);
+            if (forms.length > 0) {
+                result.set(verb.root, forms);
+            }
+        }
+        return { locale: detectedLocale, verbs: result };
+    }
+    parseXmlDetailed(xmlContent, locale) {
+        const data = this.parser.parse(xmlContent);
+        const verbdata = data.verbdata || data.Verbdata;
+        if (!verbdata) {
+            return { locale: locale || 'unknown', verbs: new Map() };
+        }
+        const detectedLocale = verbdata['@_locale'] || verbdata.locale || locale || 'unknown';
+        const ruleSets = this.parseRuleSets(verbdata);
+        const verbs = this.parseVerbs(verbdata);
+        const result = new Map();
+        for (const verb of verbs) {
+            const forms = this.generateFormsDetailed(verb, ruleSets);
+            if (forms.length > 0) {
+                result.set(verb.root, forms);
+            }
+        }
+        return { locale: detectedLocale, verbs: result };
+    }
+    /* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-argument */
+    parseXmlFileDetailed(filePath) {
+        const fs = require('fs');
+        const xml = fs.readFileSync(filePath, 'utf-8');
+        return this.parseXmlDetailed(xml);
+    }
+    /* eslint-enable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-argument */
+    parseZip(zipPath) {
+        const zip = new AdmZip(zipPath);
+        const entries = zip.getEntries();
+        const verbEntry = entries.find((e) => e.entryName.toLowerCase().endsWith('verbs.xml'));
+        if (!verbEntry) {
+            const locale = basename(dirname(zipPath));
+            return { locale, verbs: new Map() };
+        }
+        const xml = verbEntry.getData().toString('utf-8');
+        return this.parseXml(xml);
+    }
+    parseZipDetailed(zipPath) {
+        const zip = new AdmZip(zipPath);
+        const entries = zip.getEntries();
+        const verbEntry = entries.find((e) => e.entryName.toLowerCase().endsWith('verbs.xml'));
+        if (!verbEntry) {
+            const locale = basename(dirname(zipPath));
+            return { locale, verbs: new Map() };
+        }
+        const xml = verbEntry.getData().toString('utf-8');
+        return this.parseXmlDetailed(xml);
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async parseLocale(locale, grid3InstallPath) {
+        const installPath = grid3InstallPath || this.getDefaultInstallPath();
+        if (!installPath) {
+            return { locale, verbs: new Map() };
+        }
+        const zipPath = join(installPath, 'Locale', locale, 'verbs', 'verbs.zip');
+        try {
+            return this.parseZip(zipPath);
+        }
+        catch {
+            return { locale, verbs: new Map() };
+        }
+    }
+    async parseInstalledLocales(grid3InstallPath) {
+        const installPath = grid3InstallPath || this.getDefaultInstallPath();
+        const results = new Map();
+        if (!installPath)
+            return results;
+        const fs = await import('fs');
+        const localeDir = join(installPath, 'Locale');
+        let locales;
+        try {
+            locales = fs
+                .readdirSync(localeDir)
+                .filter((d) => fs.statSync(join(localeDir, d)).isDirectory());
+        }
+        catch {
+            return results;
+        }
+        for (const locale of locales) {
+            const verbsZip = join(localeDir, locale, 'verbs', 'verbs.zip');
+            try {
+                fs.accessSync(verbsZip, fs.constants.R_OK);
+                const forms = this.parseZip(verbsZip);
+                results.set(locale, forms);
+            }
+            catch {
+                // No verbs.zip for this locale
+            }
+        }
+        return results;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    parseCustomDirectory(dirPath, detailed = false) {
+        /* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
+        const fs = require('fs');
+        let locales;
+        try {
+            locales = fs
+                .readdirSync(dirPath)
+                .filter((d) => fs.statSync(join(dirPath, d)).isDirectory());
+        }
+        catch {
+            return new Map();
+        }
+        if (detailed) {
+            const results = new Map();
+            for (const locale of locales) {
+                const verbsZip = join(dirPath, locale, 'verbs', 'verbs.zip');
+                try {
+                    fs.accessSync(verbsZip, fs.constants.R_OK);
+                    results.set(locale, this.parseZipDetailed(verbsZip));
+                }
+                catch {
+                    // No verbs.zip for this locale
+                }
+            }
+            return results;
+        }
+        const results = new Map();
+        for (const locale of locales) {
+            const verbsZip = join(dirPath, locale, 'verbs', 'verbs.zip');
+            try {
+                fs.accessSync(verbsZip, fs.constants.R_OK);
+                results.set(locale, this.parseZip(verbsZip));
+            }
+            catch {
+                // No verbs.zip for this locale
+            }
+        }
+        return results;
+        /* eslint-enable @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
+    }
+    getDefaultInstallPath() {
+        if (typeof process === 'undefined' || process.platform !== 'win32') {
+            return null;
+        }
+        const paths = [
+            'C:\\Program Files (x86)\\Smartbox\\Grid 3',
+            'C:\\Program Files\\Smartbox\\Grid 3',
+        ];
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const fs = require('fs');
+            for (const p of paths) {
+                if (fs.existsSync(p))
+                    return p;
+            }
+        }
+        catch {
+            // Grid 3 not installed
+        }
+        return null;
+    }
+    /* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+    parseRuleSets(verbdata) {
+        const rulesMap = new Map();
+        const rulesList = verbdata.verbruleslist?.verbrules;
+        if (!rulesList)
+            return rulesMap;
+        const rulesArr = Array.isArray(rulesList) ? rulesList : [rulesList];
+        for (const rules of rulesArr) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            const id = rules.Id || rules.id || `rule_${rulesMap.size}`;
+            const placeholders = [];
+            const ph = rules.placeholders?.placeholder;
+            if (ph) {
+                const phArr = Array.isArray(ph) ? ph : [ph];
+                for (const p of phArr) {
+                    const val = typeof p === 'string' ? p : p['#text'] || p;
+                    if (val)
+                        placeholders.push(val);
+                }
+            }
+            const participleRules = new Map();
+            const pr = rules.participlerules?.participlerule;
+            if (pr) {
+                const prArr = Array.isArray(pr) ? pr : [pr];
+                for (const rule of prArr) {
+                    const type = rule['@_type'] || rule.type;
+                    const value = rule['@_value'] || rule.value;
+                    if (type && value) {
+                        participleRules.set(type, value);
+                    }
+                }
+            }
+            const conjugationRules = [];
+            const cr = rules.conjugationrules?.conjugationrule;
+            if (cr) {
+                const crArr = Array.isArray(cr) ? cr : [cr];
+                for (const rule of crArr) {
+                    const value = rule['@_value'] || rule.value;
+                    if (!value)
+                        continue;
+                    const conditions = new Map();
+                    for (const attr of [
+                        'time',
+                        'number',
+                        'person',
+                        'aspect',
+                        'mood',
+                        'voice',
+                        'tense',
+                        'polarity',
+                    ]) {
+                        const v = rule[`@_${attr}`] || rule[attr];
+                        if (v && v !== '*') {
+                            conditions.set(attr, String(v));
+                        }
+                    }
+                    conjugationRules.push({ value, conditions });
+                }
+            }
+            rulesMap.set(id, { id, placeholders, participleRules, conjugationRules });
+        }
+        return rulesMap;
+    }
+    /* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access */
+    parseVerbs(verbdata) {
+        const verbs = [];
+        const verbsData = verbdata.verbs?.verb;
+        if (!verbsData)
+            return verbs;
+        const arr = Array.isArray(verbsData) ? verbsData : [verbsData];
+        for (const v of arr) {
+            const root = v['@_root'] || v.root;
+            if (!root)
+                continue;
+            const ruleId = v['@_ruleid'] || v.ruleid || undefined;
+            const placeholderValues = new Map();
+            const rphv = v.ruleplaceholdervalues?.ruleplaceholdervalue;
+            if (rphv) {
+                const rphvArr = Array.isArray(rphv) ? rphv : [rphv];
+                for (const ph of rphvArr) {
+                    const placeholder = ph['@_placeholder'] || ph.placeholder;
+                    const value = ph['@_value'] || ph.value;
+                    if (placeholder && value) {
+                        placeholderValues.set(placeholder, value);
+                    }
+                }
+            }
+            const participleOverrides = new Map();
+            const parts = v.participles?.participle;
+            if (parts) {
+                const partsArr = Array.isArray(parts) ? parts : [parts];
+                for (const p of partsArr) {
+                    const type = p['@_type'] || p.type;
+                    const value = p['@_value'] || p.value;
+                    if (type && value) {
+                        participleOverrides.set(type, value);
+                    }
+                }
+            }
+            const conjugationOverrides = [];
+            const conjs = v.conjugations?.conjugation;
+            if (conjs) {
+                const conjArr = Array.isArray(conjs) ? conjs : [conjs];
+                for (const c of conjArr) {
+                    const value = c['@_value'] || c.value;
+                    if (!value)
+                        continue;
+                    const conditions = new Map();
+                    const parts2 = c.part;
+                    if (parts2) {
+                        const pArr = Array.isArray(parts2) ? parts2 : [parts2];
+                        for (const p of pArr) {
+                            for (const attr of ['time', 'number', 'person', 'aspect', 'mood', 'voice']) {
+                                const pv = p[`@_${attr}`] || p[attr];
+                                if (pv && pv !== '*') {
+                                    conditions.set(attr, String(pv));
+                                }
+                            }
+                        }
+                    }
+                    conjugationOverrides.push({ value, conditions });
+                }
+            }
+            verbs.push({
+                root,
+                ruleId,
+                placeholderValues,
+                participleOverrides,
+                conjugationOverrides,
+            });
+        }
+        return verbs;
+    }
+    generateForms(verb, ruleSets) {
+        const forms = new Set();
+        const resolvedParticiples = new Map();
+        for (const [type, value] of verb.participleOverrides) {
+            resolvedParticiples.set(type, value);
+        }
+        let appliedRule;
+        if (verb.ruleId && ruleSets.has(verb.ruleId)) {
+            appliedRule = ruleSets.get(verb.ruleId);
+        }
+        else if (ruleSets.size > 0) {
+            appliedRule = ruleSets.values().next().value;
+        }
+        if (appliedRule) {
+            const context = this.buildContext(verb, resolvedParticiples);
+            for (const [type, template] of appliedRule.participleRules) {
+                if (!resolvedParticiples.has(type)) {
+                    const resolved = this.resolveTemplate(template, context);
+                    if (resolved) {
+                        resolvedParticiples.set(type, resolved);
+                    }
+                }
+            }
+            const fullContext = this.buildContext(verb, resolvedParticiples);
+            for (const conjRule of appliedRule.conjugationRules) {
+                const resolved = this.resolveTemplate(conjRule.value, fullContext);
+                this.addIfSingleWord(resolved, forms);
+            }
+        }
+        for (const [, value] of resolvedParticiples) {
+            this.addIfSingleWord(value, forms);
+        }
+        for (const conj of verb.conjugationOverrides) {
+            this.addIfSingleWord(conj.value, forms);
+        }
+        forms.delete(verb.root);
+        return Array.from(forms);
+    }
+    generateFormsDetailed(verb, ruleSets) {
+        const forms = new Map();
+        const resolvedParticiples = new Map();
+        for (const [type, value] of verb.participleOverrides) {
+            resolvedParticiples.set(type, value);
+        }
+        let appliedRule;
+        if (verb.ruleId && ruleSets.has(verb.ruleId)) {
+            appliedRule = ruleSets.get(verb.ruleId);
+        }
+        else if (ruleSets.size > 0) {
+            appliedRule = ruleSets.values().next().value;
+        }
+        if (appliedRule) {
+            const context = this.buildContext(verb, resolvedParticiples);
+            for (const [type, template] of appliedRule.participleRules) {
+                if (!resolvedParticiples.has(type)) {
+                    const resolved = this.resolveTemplate(template, context);
+                    if (resolved) {
+                        resolvedParticiples.set(type, resolved);
+                    }
+                }
+            }
+            const fullContext = this.buildContext(verb, resolvedParticiples);
+            for (const conjRule of appliedRule.conjugationRules) {
+                const resolved = this.resolveTemplate(conjRule.value, fullContext);
+                if (resolved && !resolved.includes(' ') && resolved !== '-') {
+                    const trimmed = resolved.trim();
+                    if (trimmed.length > 0 && trimmed !== verb.root) {
+                        const existing = forms.get(trimmed);
+                        if (existing) {
+                            for (const [k, v] of conjRule.conditions) {
+                                existing.set(k, v);
+                            }
+                        }
+                        else {
+                            forms.set(trimmed, new Map(conjRule.conditions));
+                        }
+                    }
+                }
+            }
+        }
+        for (const [type, value] of resolvedParticiples) {
+            if (!value.includes(' ') && value !== '-' && value.trim().length > 0 && value !== verb.root) {
+                const conditions = forms.get(value) || new Map();
+                conditions.set('participleType', type);
+                forms.set(value, conditions);
+            }
+        }
+        for (const conj of verb.conjugationOverrides) {
+            if (conj.value &&
+                !conj.value.includes(' ') &&
+                conj.value !== '-' &&
+                conj.value.trim().length > 0 &&
+                conj.value !== verb.root) {
+                const existing = forms.get(conj.value) || new Map();
+                for (const [k, v] of conj.conditions) {
+                    existing.set(k, v);
+                }
+                forms.set(conj.value, existing);
+            }
+        }
+        forms.delete(verb.root);
+        return Array.from(forms.entries()).map(([value, conditions]) => ({
+            value,
+            conditions,
+        }));
+    }
+    buildContext(verb, resolvedParticiples) {
+        const context = new Map();
+        context.set('{root}', verb.root);
+        for (const [key, value] of verb.placeholderValues) {
+            context.set(key, value);
+            if (!key.startsWith('{')) {
+                context.set(`{${key}}`, value);
+            }
+        }
+        for (const [type, value] of resolvedParticiples) {
+            context.set(`{${type}}`, value);
+        }
+        return context;
+    }
+    resolveTemplate(template, context) {
+        let result = template;
+        for (const [key, value] of context) {
+            const keyToReplace = key.startsWith('{') ? key : `{${key}}`;
+            result = result.split(keyToReplace).join(value);
+        }
+        return result;
+    }
+    addIfSingleWord(form, set) {
+        if (!form)
+            return;
+        if (form.includes(' '))
+            return;
+        if (form === '-')
+            return;
+        const trimmed = form.trim();
+        if (trimmed.length > 0) {
+            set.add(trimmed);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export { MorphologyEngine } from './engine';
+export { Grid3VerbsParser } from './grid3VerbsParser';
+export { WordFormGenerator } from './wordFormGenerator';

package/dist/browser/utilities/analytics/morphology/types.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/utilities/analytics/morphology/wordFormGenerator.js

@@ -0,0 +1,74 @@
+const SLOT_TAG_MAP = {
+    '3sg': ['3.PERS'],
+    past: ['PAST'],
+    pastPart: ['PAST', 'PARTICIPLE'],
+    presPart: ['GERUND'],
+    plural: ['PLURAL'],
+    comparative: ['COMPARATIVE'],
+    superlative: ['SUPERLATIVE'],
+};
+const CONDITION_TAG_MAP = {
+    person: { first: ['1.PERS'], second: ['2.PERS'], third: ['3.PERS'] },
+    number: { singular: [], plural: ['PLURAL'] },
+    time: { present: ['PRESENT'], past: ['PAST'], future: ['FUTURE'] },
+    aspect: { simple: [], continuous: ['CONTINUOUS'], perfect: ['PERFECT'] },
+    mood: {
+        imperative: ['IMPERATIVE'],
+        indicative: [],
+        conditional: ['CONDITIONAL'],
+    },
+    participleType: {
+        presentparticiple: ['GERUND'],
+        pastparticiple: ['PAST', 'PARTICIPLE'],
+        infinitive: ['BASE'],
+    },
+};
+export class WordFormGenerator {
+    generateFromEngineSlots(base, pos, engine, lang = 'en') {
+        const forms = engine.inflectWithSlots(base, pos);
+        const result = [{ lang, tags: ['BASE'], value: base }];
+        for (const { slot, form } of forms) {
+            const tags = SLOT_TAG_MAP[slot] || [slot.toUpperCase()];
+            result.push({ lang, tags, value: form, base });
+        }
+        return result;
+    }
+    generateFromGrid3Conditions(base, formsWithConditions, lang = 'en') {
+        const result = [{ lang, tags: ['BASE'], value: base }];
+        for (const form of formsWithConditions) {
+            const tags = this.conditionsToTags(form.conditions);
+            result.push({ lang, tags, value: form.value, base });
+        }
+        return this.deduplicate(result);
+    }
+    generateFromPos(base, pos, engine, grid3Parser, verbsZipPath, lang = 'en') {
+        if (verbsZipPath) {
+            const detailed = grid3Parser.parseZipDetailed(verbsZipPath);
+            const forms = detailed.verbs.get(base) || detailed.verbs.get(base.toLowerCase());
+            if (forms && forms.length > 0) {
+                return this.generateFromGrid3Conditions(base, forms, lang);
+            }
+        }
+        return this.generateFromEngineSlots(base, pos, engine, lang);
+    }
+    conditionsToTags(conditions) {
+        const tags = [];
+        for (const [dim, value] of conditions) {
+            const mapped = CONDITION_TAG_MAP[dim]?.[value];
+            if (mapped) {
+                tags.push(...mapped);
+            }
+        }
+        return tags.length > 0 ? tags : ['UNKNOWN'];
+    }
+    deduplicate(forms) {
+        const seen = new Set();
+        return forms.filter((f) => {
+            const key = `${f.value}|${f.tags.sort().join(',')}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+}

package/dist/browser/utils/sqlite.js

@@ -4,12 +4,16 @@ let sqlJsPromise = null;
 export function configureSqlJs(config) {
     sqlJsConfig = { ...(sqlJsConfig ?? {}), ...config };
 }
-async function getSqlJs() {
+async function getSqlJsBrowser() {
     if (!sqlJsPromise) {
-        sqlJsPromise = import('sql.js').then((module) => {
-            const initSqlJs = module.default || module;
-            return initSqlJs(sqlJsConfig ?? {});
-        });
+        const isBrowser = typeof globalThis !== 'undefined' && globalThis.window !== undefined;
+        if (!isBrowser)
+            throw new Error('Must be run in a browser');
+        const window = globalThis.window;
+        if (!('initSqlJs' in window))
+            throw new Error('Need to add sql-wasm.js script element to DOM');
+        const initSqlJs = window.initSqlJs;
+        sqlJsPromise = initSqlJs(sqlJsConfig ?? {});
     }
     return sqlJsPromise;
 }
@@ -81,7 +85,7 @@ export async function openSqliteDatabase(input, options = {}) {
     }
     const data = await readBinaryFromInput(input);
     if (!isNodeRuntime()) {
-        const SQL = await getSqlJs();
+        const SQL = await getSqlJsBrowser();
         const db = new SQL.Database(data);
         return { db: createSqlJsAdapter(db) };
     }

package/dist/core/treeStructure.d.ts

@@ -146,9 +146,17 @@ export declare class AACButton {
         [key: string]: any;
     };
     predictions?: string[];
+    pos?: string;
+    wordForms?: Array<{
+        lang?: string;
+        tags: string[];
+        value: string;
+        pronunciation?: string;
+        base?: string;
+    }>;
     semantic_id?: string;
     clone_id?: string;
-    constructor({ id, label, message, targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, symbolLibrary, symbolPath, x, y, columnSpan, rowSpan, scanBlocks, scanBlock, visibility, directActivate, parameters, predictions, semantic_id, clone_id, type, action, }: {
+    constructor({ id, label, message, targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, symbolLibrary, symbolPath, x, y, columnSpan, rowSpan, scanBlocks, scanBlock, visibility, directActivate, parameters, predictions, pos, wordForms, semantic_id, clone_id, type, action, }: {
         id: string;
         label?: string;
         message?: string;
@@ -179,6 +187,14 @@ export declare class AACButton {
             [key: string]: any;
         };
         predictions?: string[];
+        pos?: string;
+        wordForms?: Array<{
+            lang?: string;
+            tags: string[];
+            value: string;
+            pronunciation?: string;
+            base?: string;
+        }>;
         semantic_id?: string;
         clone_id?: string;
         type?: 'SPEAK' | 'NAVIGATE' | 'ACTION';

package/dist/core/treeStructure.js

@@ -54,7 +54,7 @@ var AACScanType;
     AACScanType["BLOCK_COLUMN_ROW"] = "block-column-row";
 })(AACScanType || (exports.AACScanType = AACScanType = {}));
 class AACButton {
-    constructor({ id, label = '', message = '', targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, symbolLibrary, symbolPath, x, y, columnSpan, rowSpan, scanBlocks, scanBlock, visibility, directActivate, parameters, predictions, semantic_id, clone_id, 
+    constructor({ id, label = '', message = '', targetPageId, semanticAction, audioRecording, style, contentType, contentSubType, image, resolvedImageEntry, symbolLibrary, symbolPath, x, y, columnSpan, rowSpan, scanBlocks, scanBlock, visibility, directActivate, parameters, predictions, pos, wordForms, semantic_id, clone_id, 
     // Legacy input support
     type, action, }) {
         this.id = id;
@@ -80,6 +80,8 @@ class AACButton {
         this.directActivate = directActivate;
         this.parameters = parameters;
         this.predictions = predictions;
+        this.pos = pos;
+        this.wordForms = wordForms;
         this.semantic_id = semantic_id;
         this.clone_id = clone_id;
         // Legacy mapping: if no semanticAction provided, derive from legacy `action` first

package/dist/index.node.d.ts

@@ -12,6 +12,8 @@ export * from './processors';
 export * as Analytics from './analytics';
 export * as Validation from './validation';
 export * as Metrics from './metrics';
+export { Grid3VerbsParser } from './utilities/analytics/morphology/grid3VerbsParser';
+export { WordFormGenerator } from './utilities/analytics/morphology/wordFormGenerator';
 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.Metrics = 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.WordFormGenerator = exports.Grid3VerbsParser = exports.Metrics = exports.Validation = exports.Analytics = void 0;
 exports.getProcessor = getProcessor;
 exports.getSupportedExtensions = getSupportedExtensions;
 exports.isExtensionSupported = isExtensionSupported;
@@ -56,6 +56,11 @@ exports.Analytics = __importStar(require("./analytics"));
 exports.Validation = __importStar(require("./validation"));
 // Metrics namespace (pageset analytics)
 exports.Metrics = __importStar(require("./metrics"));
+// Node-only morphology utilities (Grid 3 verbs parser)
+var grid3VerbsParser_1 = require("./utilities/analytics/morphology/grid3VerbsParser");
+Object.defineProperty(exports, "Grid3VerbsParser", { enumerable: true, get: function () { return grid3VerbsParser_1.Grid3VerbsParser; } });
+var wordFormGenerator_1 = require("./utilities/analytics/morphology/wordFormGenerator");
+Object.defineProperty(exports, "WordFormGenerator", { enumerable: true, get: function () { return wordFormGenerator_1.WordFormGenerator; } });
 // Processor namespaces (platform-specific utilities)
 exports.Gridset = __importStar(require("./gridset"));
 exports.Snap = __importStar(require("./snap"));

package/dist/metrics.d.ts

@@ -12,6 +12,9 @@ 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 { MorphologyEngine } from './utilities/analytics/morphology';
+export { WordFormGenerator } from './utilities/analytics/morphology';
+export type { MorphRuleSet, MorphRule, MorphWordForms, Grid3VerbForms, AstericsWordForm, VerbFormWithConditions, Grid3VerbFormsDetailed, } from './utilities/analytics/morphology';
 export { ReferenceLoader } from './utilities/analytics/reference';
 export { InMemoryReferenceLoader, createBrowserReferenceLoader, loadReferenceDataFromUrl, type ReferenceData, } from './utilities/analytics/reference/browser';
 export * from './utilities/analytics/utils/idGenerator';