glost 0.1.0

package/dist/utils.d.ts

@@ -0,0 +1,203 @@
+import type { LanguageCode, GLOSTCharacter, GLOSTClause, GLOSTNode, GLOSTParagraph, GLOSTPhrase, GLOSTRoot, GLOSTSentence, GLOSTSyllable, GLOSTWord, TranscriptionSystem } from "./types";
+/**
+ * Parse a BCP-47 language tag into its components
+ * Format: language[-script][-region][-variant]
+ */
+export declare function parseLanguageTag(tag: string): {
+    language: string;
+    script?: string;
+    region?: string;
+    variant?: string;
+    fullTag: string;
+};
+/**
+ * Get the base language from a BCP-47 tag
+ * Examples: "en-US" -> "en", "zh-CN" -> "zh"
+ */
+export declare function getBaseLanguage(tag: string): string;
+/**
+ * Check if two language tags are compatible (same base language)
+ * Examples: "en-US" and "en-GB" are compatible
+ */
+export declare function areLanguagesCompatible(tag1: string, tag2: string): boolean;
+/**
+ * Find the best matching language tag from available options
+ * Prioritizes exact matches, then region matches, then base language matches
+ */
+export declare function findBestLanguageMatch(target: string, available: string[]): string | null;
+/**
+ * Get a fallback language tag when the exact one isn't available
+ * Examples: "en-US" -> "en", "zh-CN" -> "zh"
+ */
+export declare function getLanguageFallback(tag: string): string;
+/**
+ * Normalize a language tag to standard format
+ * Converts to lowercase and ensures proper formatting
+ */
+export declare function normalizeLanguageTag(tag: string): string;
+/**
+ * Check if a language tag is valid BCP-47 format
+ */
+export declare function isValidLanguageTag(tag: string): boolean;
+/**
+ * Get all word nodes from an GLOST tree
+ */
+export declare function getAllWords(node: GLOSTNode): GLOSTWord[];
+/**
+ * Get all sentence nodes from an GLOST tree
+ */
+export declare function getAllSentences(node: GLOSTNode): GLOSTSentence[];
+/**
+ * Get all paragraph nodes from an GLOST tree
+ */
+export declare function getAllParagraphs(node: GLOSTNode): GLOSTParagraph[];
+/**
+ * Get all clause nodes from an GLOST tree
+ */
+export declare function getAllClauses(node: GLOSTNode): GLOSTClause[];
+/**
+ * Get all phrase nodes from an GLOST tree
+ */
+export declare function getAllPhrases(node: GLOSTNode): GLOSTPhrase[];
+/**
+ * Get all syllable nodes from an GLOST tree
+ */
+export declare function getAllSyllables(node: GLOSTNode): GLOSTSyllable[];
+/**
+ * Get all character nodes from an GLOST tree
+ */
+export declare function getAllCharacters(node: GLOSTNode): GLOSTCharacter[];
+/**
+ * Find nodes by type with better typing
+ */
+export declare function findNodesByType<T extends GLOSTNode>(node: GLOSTNode, type: string): T[];
+/**
+ * Get all words from a document with proper typing
+ */
+export declare function getWordsFromDocument(doc: GLOSTRoot): GLOSTWord[];
+/**
+ * Get the first sentence from a document
+ */
+export declare function getFirstSentence(doc: GLOSTRoot): GLOSTSentence | null;
+/**
+ * Get words from a specific sentence
+ */
+export declare function getWordsFromSentence(sentence: GLOSTSentence): GLOSTWord[];
+/**
+ * Get words from a specific paragraph
+ */
+export declare function getWordsFromParagraph(paragraph: GLOSTParagraph): GLOSTWord[];
+/**
+ * Find word nodes with specific language
+ */
+export declare function findWordsByLanguage(node: GLOSTNode, lang: LanguageCode): GLOSTWord[];
+/**
+ * Find word nodes with specific transcription system
+ */
+export declare function findWordsByTranscriptionSystem(node: GLOSTNode, system: TranscriptionSystem): GLOSTWord[];
+/**
+ * Enhanced type guards for the new GLOST types
+ */
+export declare function isGLOSTWord(node: any): node is GLOSTWord;
+export declare function isGLOSTSentence(node: any): node is GLOSTSentence;
+export declare function isGLOSTParagraph(node: any): node is GLOSTParagraph;
+export declare function isGLOSTRoot(node: any): node is GLOSTRoot;
+/**
+ * Type guard for GLOSTClause nodes
+ */
+export declare function isGLOSTClause(node: any): node is GLOSTClause;
+/**
+ * Type guard for GLOSTPhrase nodes
+ */
+export declare function isGLOSTPhrase(node: any): node is GLOSTPhrase;
+/**
+ * Type guard for GLOSTSyllable nodes
+ */
+export declare function isGLOSTSyllable(node: any): node is GLOSTSyllable;
+/**
+ * Type guard for GLOSTCharacter nodes
+ */
+export declare function isGLOSTCharacter(node: any): node is GLOSTCharacter;
+/**
+ * Extract text value from a word node
+ */
+export declare function getWordText(word: GLOSTWord): string;
+/**
+ * Get transcription for a specific system
+ */
+export declare function getWordTranscription(word: GLOSTWord, system: TranscriptionSystem): string | null;
+/**
+ * Check if a word has transcription for a specific system
+ */
+export declare function hasWordTranscription(word: GLOSTWord, system: TranscriptionSystem): boolean;
+/**
+ * Get word translation for a specific language
+ * @param word - The word node
+ * @param language - Target language code (default: "en-US")
+ * @returns Translation string or empty string if not found
+ */
+export declare function getWordTranslation(word: GLOSTWord, language?: string): string;
+/**
+ * Get word meaning/definition
+ * @deprecated Use getWordTranslation for multi-language support.
+ * This function is kept for backward compatibility.
+ */
+export declare function getWordMeaning(word: GLOSTWord): string;
+/**
+ * Get word part of speech
+ */
+export declare function getWordPartOfSpeech(word: GLOSTWord): string;
+/**
+ * Get word difficulty
+ */
+export declare function getWordDifficulty(word: GLOSTWord): string;
+/**
+ * Get sentence translation
+ */
+export declare function getSentenceTranslation(sentence: GLOSTSentence, language?: string): string | null;
+/**
+ * Generic paragraph structure for word count calculation
+ * This interface allows converting external paragraph structures to GLOST format
+ */
+export type ParagraphLike = {
+    sentences: Array<{
+        sentence: string;
+        translation?: string;
+    }>;
+};
+/**
+ * Convert a paragraph-like structure to GLOST format for word count calculation
+ * This is a minimal adapter that only converts what's needed for word counting
+ *
+ * @param paragraph - Paragraph structure with sentences containing text and optional translations
+ * @returns GLOST paragraph node
+ *
+ * @example
+ * ```ts
+ * const paragraph = {
+ *   sentences: [
+ *     { sentence: "Hello", translation: "สวัสดี" },
+ *     { sentence: "World", translation: "โลก" }
+ *   ]
+ * };
+ * const mtstParagraph = adaptParagraphLikeToGLOST(paragraph);
+ * const wordCount = getGLOSTWordCount(mtstParagraph);
+ * ```
+ */
+export declare function adaptParagraphLikeToGLOST(paragraph: ParagraphLike): GLOSTParagraph;
+/**
+ * Calculate word count from GLOST content
+ * Counts words from sentence translations or original text
+ *
+ * @param content - GLOST paragraph, sentence, or root node
+ * @param language - Optional language code for translation preference (default: 'en')
+ * @returns Word count as a number, or undefined if content is empty
+ *
+ * @example
+ * ```ts
+ * const wordCount = getGLOSTWordCount(paragraph, 'en');
+ * // Returns: 245
+ * ```
+ */
+export declare function getGLOSTWordCount(content: GLOSTParagraph | GLOSTSentence | GLOSTRoot, language?: string): number | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/dist/utils.js

@@ -0,0 +1,497 @@
+import { is as isNode } from "unist-util-is";
+import { visit } from "unist-util-visit";
+// ============================================================================
+// BCP-47 Language Tag Utilities
+// ============================================================================
+/**
+ * Parse a BCP-47 language tag into its components
+ * Format: language[-script][-region][-variant]
+ */
+export function parseLanguageTag(tag) {
+    const parts = tag.split("-");
+    const result = {
+        language: parts[0] || "",
+        script: undefined,
+        region: undefined,
+        variant: undefined,
+        fullTag: tag,
+    };
+    if (parts.length >= 2) {
+        // Check if second part is a script (4 letters) or region (2-3 letters)
+        if (parts[1] && parts[1].length === 4 && /^[A-Za-z]{4}$/.test(parts[1])) {
+            result.script = parts[1];
+            if (parts.length >= 3 && parts[2]) {
+                result.region = parts[2];
+                if (parts.length >= 4) {
+                    result.variant = parts.slice(3).join("-");
+                }
+            }
+        }
+        else {
+            // Second part is likely a region
+            if (parts[1]) {
+                result.region = parts[1];
+                if (parts.length >= 3) {
+                    result.variant = parts.slice(2).join("-");
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Get the base language from a BCP-47 tag
+ * Examples: "en-US" -> "en", "zh-CN" -> "zh"
+ */
+export function getBaseLanguage(tag) {
+    const parts = tag.split("-");
+    return parts[0] || tag;
+}
+/**
+ * Check if two language tags are compatible (same base language)
+ * Examples: "en-US" and "en-GB" are compatible
+ */
+export function areLanguagesCompatible(tag1, tag2) {
+    return getBaseLanguage(tag1) === getBaseLanguage(tag2);
+}
+/**
+ * Find the best matching language tag from available options
+ * Prioritizes exact matches, then region matches, then base language matches
+ */
+export function findBestLanguageMatch(target, available) {
+    if (available.includes(target)) {
+        return target;
+    }
+    const targetParts = parseLanguageTag(target);
+    // Try to find region-specific matches
+    for (const option of available) {
+        const optionParts = parseLanguageTag(option);
+        if (optionParts.language === targetParts.language &&
+            optionParts.region === targetParts.region) {
+            return option;
+        }
+    }
+    // Try to find base language matches
+    for (const option of available) {
+        const optionParts = parseLanguageTag(option);
+        if (optionParts.language === targetParts.language) {
+            return option;
+        }
+    }
+    return null;
+}
+/**
+ * Get a fallback language tag when the exact one isn't available
+ * Examples: "en-US" -> "en", "zh-CN" -> "zh"
+ */
+export function getLanguageFallback(tag) {
+    const parts = parseLanguageTag(tag);
+    return parts.language;
+}
+/**
+ * Normalize a language tag to standard format
+ * Converts to lowercase and ensures proper formatting
+ */
+export function normalizeLanguageTag(tag) {
+    const parts = tag.split("-");
+    const language = parts[0]?.toLowerCase() || "";
+    if (parts.length === 1) {
+        return language;
+    }
+    // Handle script (4 letters, title case)
+    if (parts[1] && parts[1].length === 4) {
+        const script = parts[1]
+            .toLowerCase()
+            .replace(/\b\w/g, (l) => l.toUpperCase());
+        if (parts.length === 2) {
+            return `${language}-${script}`;
+        }
+        // Handle region (2-3 letters, uppercase)
+        const region = parts[2]?.toUpperCase() || "";
+        if (parts.length === 3) {
+            return `${language}-${script}-${region}`;
+        }
+        // Handle variants (lowercase)
+        const variants = parts.slice(3).join("-").toLowerCase();
+        return `${language}-${script}-${region}-${variants}`;
+    }
+    else {
+        // No script, just language-region
+        const region = parts[1]?.toUpperCase() || "";
+        if (parts.length === 2) {
+            return `${language}-${region}`;
+        }
+        // Handle variants
+        const variants = parts.slice(2).join("-").toLowerCase();
+        return `${language}-${region}-${variants}`;
+    }
+}
+/**
+ * Check if a language tag is valid BCP-47 format
+ */
+export function isValidLanguageTag(tag) {
+    // Basic BCP-47 validation
+    const bcp47Pattern = /^[a-z]{2,3}(-[A-Za-z]{4})?(-[A-Za-z]{2,3})?(-[A-Za-z0-9]+)*$/;
+    return bcp47Pattern.test(tag);
+}
+// ============================================================================
+// Enhanced Tree Traversal Utilities (using unist-util-visit)
+// ============================================================================
+/**
+ * Get all word nodes from an GLOST tree
+ */
+export function getAllWords(node) {
+    const words = [];
+    visit(node, "WordNode", (wordNode) => {
+        if (isGLOSTWord(wordNode)) {
+            words.push(wordNode);
+        }
+    });
+    return words;
+}
+/**
+ * Get all sentence nodes from an GLOST tree
+ */
+export function getAllSentences(node) {
+    const sentences = [];
+    visit(node, "SentenceNode", (sentenceNode) => {
+        if (isGLOSTSentence(sentenceNode)) {
+            sentences.push(sentenceNode);
+        }
+    });
+    return sentences;
+}
+/**
+ * Get all paragraph nodes from an GLOST tree
+ */
+export function getAllParagraphs(node) {
+    const paragraphs = [];
+    visit(node, "ParagraphNode", (paragraphNode) => {
+        if (isGLOSTParagraph(paragraphNode)) {
+            paragraphs.push(paragraphNode);
+        }
+    });
+    return paragraphs;
+}
+/**
+ * Get all clause nodes from an GLOST tree
+ */
+export function getAllClauses(node) {
+    const clauses = [];
+    visit(node, "ClauseNode", (clauseNode) => {
+        if (isGLOSTClause(clauseNode)) {
+            clauses.push(clauseNode);
+        }
+    });
+    return clauses;
+}
+/**
+ * Get all phrase nodes from an GLOST tree
+ */
+export function getAllPhrases(node) {
+    const phrases = [];
+    visit(node, "PhraseNode", (phraseNode) => {
+        if (isGLOSTPhrase(phraseNode)) {
+            phrases.push(phraseNode);
+        }
+    });
+    return phrases;
+}
+/**
+ * Get all syllable nodes from an GLOST tree
+ */
+export function getAllSyllables(node) {
+    const syllables = [];
+    visit(node, "SyllableNode", (syllableNode) => {
+        if (isGLOSTSyllable(syllableNode)) {
+            syllables.push(syllableNode);
+        }
+    });
+    return syllables;
+}
+/**
+ * Get all character nodes from an GLOST tree
+ */
+export function getAllCharacters(node) {
+    const characters = [];
+    visit(node, "CharacterNode", (characterNode) => {
+        if (isGLOSTCharacter(characterNode)) {
+            characters.push(characterNode);
+        }
+    });
+    return characters;
+}
+/**
+ * Find nodes by type with better typing
+ */
+export function findNodesByType(node, type) {
+    const results = [];
+    visit(node, type, (foundNode) => {
+        results.push(foundNode);
+    });
+    return results;
+}
+// ============================================================================
+// New Utilities for Transcription Components
+// ============================================================================
+/**
+ * Get all words from a document with proper typing
+ */
+export function getWordsFromDocument(doc) {
+    return getAllWords(doc);
+}
+/**
+ * Get the first sentence from a document
+ */
+export function getFirstSentence(doc) {
+    const paragraphs = getAllParagraphs(doc);
+    if (paragraphs.length === 0)
+        return null;
+    const firstParagraph = paragraphs[0];
+    if (!firstParagraph)
+        return null;
+    const sentences = getAllSentences(firstParagraph);
+    if (sentences.length === 0)
+        return null;
+    const firstSentence = sentences[0];
+    return firstSentence || null;
+}
+/**
+ * Get words from a specific sentence
+ */
+export function getWordsFromSentence(sentence) {
+    return getAllWords(sentence);
+}
+/**
+ * Get words from a specific paragraph
+ */
+export function getWordsFromParagraph(paragraph) {
+    const words = [];
+    visit(paragraph, "WordNode", (wordNode) => {
+        if (isGLOSTWord(wordNode)) {
+            words.push(wordNode);
+        }
+    });
+    return words;
+}
+/**
+ * Find word nodes with specific language
+ */
+export function findWordsByLanguage(node, lang) {
+    const words = getAllWords(node);
+    return words.filter((word) => word.lang === lang);
+}
+/**
+ * Find word nodes with specific transcription system
+ */
+export function findWordsByTranscriptionSystem(node, system) {
+    const words = getAllWords(node);
+    return words.filter((word) => word.transcription && word.transcription[system]);
+}
+// ============================================================================
+// Enhanced Type Guards (using unist-util-is)
+// ============================================================================
+/**
+ * Enhanced type guards for the new GLOST types
+ */
+export function isGLOSTWord(node) {
+    return (isNode(node, "WordNode") && "transcription" in node && "metadata" in node);
+}
+export function isGLOSTSentence(node) {
+    return (isNode(node, "SentenceNode") &&
+        "lang" in node &&
+        "script" in node &&
+        "originalText" in node);
+}
+export function isGLOSTParagraph(node) {
+    return isNode(node, "ParagraphNode");
+}
+export function isGLOSTRoot(node) {
+    return isNode(node, "Root") && "lang" in node && "script" in node;
+}
+/**
+ * Type guard for GLOSTClause nodes
+ */
+export function isGLOSTClause(node) {
+    return isNode(node, "ClauseNode") && "clauseType" in node;
+}
+/**
+ * Type guard for GLOSTPhrase nodes
+ */
+export function isGLOSTPhrase(node) {
+    return isNode(node, "PhraseNode") && "phraseType" in node;
+}
+/**
+ * Type guard for GLOSTSyllable nodes
+ */
+export function isGLOSTSyllable(node) {
+    return isNode(node, "SyllableNode") && "structure" in node;
+}
+/**
+ * Type guard for GLOSTCharacter nodes
+ */
+export function isGLOSTCharacter(node) {
+    return isNode(node, "CharacterNode") && "value" in node;
+}
+// ============================================================================
+// Utility Functions for Transcription Components
+// ============================================================================
+/**
+ * Extract text value from a word node
+ */
+export function getWordText(word) {
+    const textNode = word.children.find((child) => child.type === "TextNode");
+    return textNode?.value ?? "";
+}
+/**
+ * Get transcription for a specific system
+ */
+export function getWordTranscription(word, system) {
+    return word.transcription[system]?.text ?? null;
+}
+/**
+ * Check if a word has transcription for a specific system
+ */
+export function hasWordTranscription(word, system) {
+    return system in word.transcription && !!word.transcription[system]?.text;
+}
+/**
+ * Get word translation for a specific language
+ * @param word - The word node
+ * @param language - Target language code (default: "en-US")
+ * @returns Translation string or empty string if not found
+ */
+export function getWordTranslation(word, language = "en-US") {
+    // Check extras.translations first (preferred format)
+    if (word.extras?.translations?.[language]) {
+        return word.extras.translations[language];
+    }
+    // Also check short language code (e.g., "en" for "en-US")
+    const shortLang = language.split("-")[0];
+    if (shortLang && word.extras?.translations?.[shortLang]) {
+        return word.extras.translations[shortLang];
+    }
+    return "";
+}
+/**
+ * Get word meaning/definition
+ * @deprecated Use getWordTranslation for multi-language support.
+ * This function is kept for backward compatibility.
+ */
+export function getWordMeaning(word) {
+    // Priority: extras.translations (preferred) > metadata.meaning (deprecated) > shortDefinition (deprecated)
+    const translation = getWordTranslation(word, "en-US");
+    if (translation)
+        return translation;
+    return (word.metadata?.meaning ?? word.shortDefinition ?? word.fullDefinition ?? "");
+}
+/**
+ * Get word part of speech
+ */
+export function getWordPartOfSpeech(word) {
+    return word.metadata?.partOfSpeech ?? "";
+}
+/**
+ * Get word difficulty
+ */
+export function getWordDifficulty(word) {
+    return word.difficulty ?? word.extras?.metadata?.difficulty ?? "";
+}
+/**
+ * Get sentence translation
+ */
+export function getSentenceTranslation(sentence, language = "en") {
+    if (sentence.extras?.translations?.[language]) {
+        return sentence.extras.translations[language];
+    }
+    // Fallback: build from word meanings
+    const words = getWordsFromSentence(sentence);
+    const wordMeanings = words
+        .map((word) => getWordMeaning(word))
+        .filter(Boolean)
+        .join(" ");
+    return wordMeanings || null;
+}
+/**
+ * Convert a paragraph-like structure to GLOST format for word count calculation
+ * This is a minimal adapter that only converts what's needed for word counting
+ *
+ * @param paragraph - Paragraph structure with sentences containing text and optional translations
+ * @returns GLOST paragraph node
+ *
+ * @example
+ * ```ts
+ * const paragraph = {
+ *   sentences: [
+ *     { sentence: "Hello", translation: "สวัสดี" },
+ *     { sentence: "World", translation: "โลก" }
+ *   ]
+ * };
+ * const mtstParagraph = adaptParagraphLikeToGLOST(paragraph);
+ * const wordCount = getGLOSTWordCount(mtstParagraph);
+ * ```
+ */
+export function adaptParagraphLikeToGLOST(paragraph) {
+    return {
+        type: "ParagraphNode",
+        children: paragraph.sentences.map((sentence) => ({
+            type: "SentenceNode",
+            lang: "unknown",
+            script: "unknown",
+            originalText: sentence.sentence,
+            children: [],
+            extras: {
+                translations: sentence.translation
+                    ? { en: sentence.translation }
+                    : undefined,
+            },
+        })),
+    };
+}
+/**
+ * Calculate word count from GLOST content
+ * Counts words from sentence translations or original text
+ *
+ * @param content - GLOST paragraph, sentence, or root node
+ * @param language - Optional language code for translation preference (default: 'en')
+ * @returns Word count as a number, or undefined if content is empty
+ *
+ * @example
+ * ```ts
+ * const wordCount = getGLOSTWordCount(paragraph, 'en');
+ * // Returns: 245
+ * ```
+ */
+export function getGLOSTWordCount(content, language = "en") {
+    if (isGLOSTParagraph(content)) {
+        const sentences = getAllSentences(content);
+        if (sentences.length === 0) {
+            return undefined;
+        }
+        return sentences.reduce((count, sentence) => {
+            const translation = getSentenceTranslation(sentence, language);
+            const text = translation || sentence.originalText || "";
+            return count + text.split(/\s+/).filter((word) => word.length > 0).length;
+        }, 0);
+    }
+    if (isGLOSTSentence(content)) {
+        const translation = getSentenceTranslation(content, language);
+        const text = translation || content.originalText || "";
+        if (!text) {
+            return undefined;
+        }
+        return text.split(/\s+/).filter((word) => word.length > 0).length;
+    }
+    if (isGLOSTRoot(content)) {
+        const paragraphs = getAllParagraphs(content);
+        if (paragraphs.length === 0) {
+            return undefined;
+        }
+        return paragraphs.reduce((count, paragraph) => {
+            const paragraphCount = getGLOSTWordCount(paragraph, language);
+            return count + (paragraphCount ?? 0);
+        }, 0);
+    }
+    return undefined;
+}
+//# sourceMappingURL=utils.js.map