glost-core 0.5.0

package/src/__tests__/example.test.ts

@@ -0,0 +1,43 @@
+// Example test file showing how to use fixtures
+// This demonstrates that fixtures are only imported in test files
+
+import { describe, it, expect } from 'vitest';
+import {
+  thaiDocumentWithExtras,
+  japaneseDocumentWithExtras,
+  getQuickTranslation,
+  getDifficulty
+} from './mock-data.js';
+import { getAllWords } from '../utils.js';
+
+
+describe('Using mock data fixtures', () => {
+  it('should load Thai document with extras', () => {
+    expect(thaiDocumentWithExtras.type).toBe('RootNode');
+    expect(thaiDocumentWithExtras.lang).toBe('th');
+
+    const words = getAllWords(thaiDocumentWithExtras);
+    expect(words.length).toBeGreaterThan(0);
+  });
+
+  it('should load Japanese document with extras', () => {
+    expect(japaneseDocumentWithExtras.type).toBe('RootNode');
+    expect(japaneseDocumentWithExtras.lang).toBe('ja');
+
+    const words = getAllWords(japaneseDocumentWithExtras);
+    expect(words.length).toBeGreaterThan(0);
+  });
+
+  it('should access translation data from fixtures', () => {
+    const words = getAllWords(thaiDocumentWithExtras);
+    const firstWord = words[0];
+
+    if (firstWord) {
+      const englishTranslation = getQuickTranslation(firstWord, 'en');
+      expect(englishTranslation).toBeDefined();
+
+      const difficulty = getDifficulty(firstWord);
+      expect(difficulty).toBeDefined();
+    }
+  });
+});

package/src/__tests__/example.ts

@@ -0,0 +1,186 @@
+// Example usage of the GLOST package
+import {
+  createSentenceFromWords,
+  createParagraphFromSentences,
+  createDocumentFromParagraphs,
+  getAllWords,
+  getWordTranscription,
+  validateGLOSTTree,
+  getWordText
+} from '../index';
+import { createThaiWord } from 'glost-th';
+import { createJapaneseWord } from 'glost-ja';
+
+// ============================================================================
+// Thai Example: "สวัสดีครับ ผมชื่อสมชาย" (Hello, my name is Somchai)
+// ============================================================================
+
+const thaiWords = [
+  createThaiWord({
+    text: 'สวัสดี',
+    rtgs: 'sà-wàt-dii',
+    partOfSpeech: 'interjection',
+    tone: 2,
+    syllables: ['sa', 'wat', 'dii']
+  }),
+  createThaiWord({
+    text: 'ครับ',
+    rtgs: 'khráp',
+    partOfSpeech: 'particle',
+    tone: 2,
+    syllables: ['khrap']
+  }),
+  createThaiWord({
+    text: 'ผม',
+    rtgs: 'phǒm',
+    partOfSpeech: 'pronoun',
+    tone: 3,
+    syllables: ['phom']
+  }),
+  createThaiWord({
+    text: 'ชื่อ',
+    rtgs: 'chûue',
+    partOfSpeech: 'noun',
+    tone: 3,
+    syllables: ['chue']
+  }),
+  createThaiWord({
+    text: 'สมชาย',
+    rtgs: 'sǒm-chaai',
+    partOfSpeech: 'proper noun',
+    tone: 3,
+    syllables: ['som', 'chaai']
+  })
+];
+
+const thaiSentence = createSentenceFromWords(
+  thaiWords,
+  'th',
+  'thai',
+  'สวัสดีครับ ผมชื่อสมชาย'
+);
+
+// ============================================================================
+// Japanese Example: "私の名前は田中です。" (My name is Tanaka)
+// ============================================================================
+
+const japaneseWords = [
+  createJapaneseWord({
+    text: '私',
+    romaji: 'watashi',
+    partOfSpeech: 'pronoun',
+    furigana: 'わたし'
+  }),
+  createJapaneseWord({
+    text: 'の',
+    romaji: 'no',
+    partOfSpeech: 'particle'
+  }),
+  createJapaneseWord({
+    text: '名前',
+    romaji: 'namae',
+    partOfSpeech: 'noun',
+    furigana: 'なまえ'
+  }),
+  createJapaneseWord({
+    text: 'は',
+    romaji: 'wa',
+    partOfSpeech: 'particle'
+  }),
+  createJapaneseWord({
+    text: '田中',
+    romaji: 'tanaka',
+    partOfSpeech: 'proper noun',
+    furigana: 'たなか'
+  }),
+  createJapaneseWord({
+    text: 'です',
+    romaji: 'desu',
+    partOfSpeech: 'copula'
+  })
+];
+
+const japaneseSentence = createSentenceFromWords(
+  japaneseWords,
+  'ja',
+  'mixed',
+  '私の名前は田中です。'
+);
+
+// ============================================================================
+// Create Document Structure
+// ============================================================================
+
+const thaiParagraph = createParagraphFromSentences([thaiSentence]);
+const japaneseParagraph = createParagraphFromSentences([japaneseSentence]);
+
+const document = createDocumentFromParagraphs(
+  [thaiParagraph, japaneseParagraph],
+  'mixed',
+  'mixed',
+  {
+    title: 'Multilingual Greeting Examples',
+    description: 'Examples of greetings in Thai and Japanese with transcriptions'
+  }
+);
+
+// ============================================================================
+// Demonstrate Utilities
+// ============================================================================
+
+export function demonstrateUtilities() {
+  console.log('=== GLOST Package Demo ===\n');
+
+  // Get all words from the document
+  const allWords = getAllWords(document);
+  console.log(`Total words: ${allWords.length}`);
+
+  // Show Thai words with RTGS transcriptions
+  const thaiWordsOnly = allWords.filter(word => word.lang === 'th');
+  console.log('\n=== Thai Words ===');
+  thaiWordsOnly.forEach(word => {
+    const rtgs = getWordTranscription(word, 'rtgs');
+    console.log(`${getWordText(word)} → ${rtgs} (${word.metadata.partOfSpeech})`);
+  });
+
+  // Show Japanese words with romaji
+  const japaneseWordsOnly = allWords.filter(word => word.lang === 'ja');
+  console.log('\n=== Japanese Words ===');
+  japaneseWordsOnly.forEach(word => {
+    const romaji = getWordTranscription(word, 'romaji');
+    console.log(`${getWordText(word)} → ${romaji} (${word.metadata.partOfSpeech})`);
+  });
+
+  // Validate the tree
+  const validationErrors = validateGLOSTTree(document);
+  if (validationErrors.length === 0) {
+    console.log('\n✅ Document is valid!');
+  } else {
+    console.log('\n❌ Validation errors:');
+    validationErrors.forEach((error: string) => console.log(`  - ${error}`));
+  }
+
+  // Show document structure
+  console.log('\n=== Document Structure ===');
+  console.log(`Language: ${document.lang}`);
+  console.log(`Script: ${document.script}`);
+  console.log(`Paragraphs: ${document.children.length}`);
+  console.log(`Sentences: ${document.children.reduce((acc, p) => {
+    if (p.type === 'ParagraphNode') {
+      return acc + (p.children?.length || 0);
+    }
+    return acc;
+  }, 0)}`);
+  console.log(`Words: ${allWords.length}`);
+}
+
+// Export for use in other files
+export {
+  thaiWords,
+  japaneseWords,
+  thaiSentence,
+  japaneseSentence,
+  thaiParagraph,
+  japaneseParagraph,
+  document
+};

package/src/__tests__/helpers.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Tests for document creation helper functions
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  createSimpleDocument,
+  createDocumentFromSentences,
+  createSentenceFromWords,
+  createGLOSTWordNode,
+  getAllWords,
+} from "../index.js";
+
+describe("Document Helper Functions", () => {
+  describe("createSimpleDocument", () => {
+    it("should create document from words with all required structure", () => {
+      const words = [
+        createGLOSTWordNode({
+          value: "hello",
+          lang: "en",
+          script: "latin",
+        }),
+        createGLOSTWordNode({
+          value: "world",
+          lang: "en",
+          script: "latin",
+        }),
+      ];
+
+      const doc = createSimpleDocument(words, "en", "latin");
+
+      expect(doc.type).toBe("RootNode");
+      expect(doc.lang).toBe("en");
+      expect(doc.script).toBe("latin");
+      expect(doc.children.length).toBe(1); // One paragraph
+
+      const paragraph = doc.children[0];
+      expect(paragraph.type).toBe("ParagraphNode");
+      expect(paragraph.children.length).toBe(1); // One sentence
+
+      const sentence = paragraph.children[0];
+      expect(sentence.type).toBe("SentenceNode");
+      expect(sentence.children.length).toBe(2); // Two words
+    });
+
+    it("should accept custom sentence text", () => {
+      const words = [
+        createGLOSTWordNode({
+          value: "hello",
+          lang: "en",
+          script: "latin",
+        }),
+      ];
+
+      const doc = createSimpleDocument(words, "en", "latin", {
+        sentenceText: "Hello!",
+      });
+
+      const sentence = doc.children[0].children[0];
+      expect(sentence.originalText).toBe("Hello!");
+    });
+
+    it("should accept document metadata", () => {
+      const words = [
+        createGLOSTWordNode({
+          value: "test",
+          lang: "en",
+          script: "latin",
+        }),
+      ];
+
+      const doc = createSimpleDocument(words, "en", "latin", {
+        metadata: {
+          title: "Test Document",
+          author: "Test Author",
+        },
+      });
+
+      expect(doc.metadata?.title).toBe("Test Document");
+      expect(doc.metadata?.author).toBe("Test Author");
+    });
+
+    it("should work with getAllWords utility", () => {
+      const words = [
+        createGLOSTWordNode({ value: "one", lang: "en", script: "latin" }),
+        createGLOSTWordNode({ value: "two", lang: "en", script: "latin" }),
+        createGLOSTWordNode({ value: "three", lang: "en", script: "latin" }),
+      ];
+
+      const doc = createSimpleDocument(words, "en", "latin");
+      const extractedWords = getAllWords(doc);
+
+      expect(extractedWords.length).toBe(3);
+      expect(extractedWords[0].children[0].value).toBe("one");
+      expect(extractedWords[1].children[0].value).toBe("two");
+      expect(extractedWords[2].children[0].value).toBe("three");
+    });
+  });
+
+  describe("createDocumentFromSentences", () => {
+    it("should create document from sentences with paragraph wrapper", () => {
+      const words1 = [
+        createGLOSTWordNode({ value: "hello", lang: "en", script: "latin" }),
+      ];
+      const words2 = [
+        createGLOSTWordNode({ value: "world", lang: "en", script: "latin" }),
+      ];
+
+      const sentence1 = createSentenceFromWords(words1, "en", "latin", "Hello");
+      const sentence2 = createSentenceFromWords(words2, "en", "latin", "World");
+
+      const doc = createDocumentFromSentences([sentence1, sentence2], "en", "latin");
+
+      expect(doc.type).toBe("RootNode");
+      expect(doc.children.length).toBe(1); // One paragraph
+
+      const paragraph = doc.children[0];
+      expect(paragraph.type).toBe("ParagraphNode");
+      expect(paragraph.children.length).toBe(2); // Two sentences
+    });
+
+    it("should accept document metadata", () => {
+      const words = [
+        createGLOSTWordNode({ value: "test", lang: "en", script: "latin" }),
+      ];
+      const sentence = createSentenceFromWords(words, "en", "latin");
+
+      const doc = createDocumentFromSentences([sentence], "en", "latin", {
+        title: "Test",
+        author: "Author",
+      });
+
+      expect(doc.metadata?.title).toBe("Test");
+      expect(doc.metadata?.author).toBe("Author");
+    });
+
+    it("should preserve sentence structure", () => {
+      const words1 = [
+        createGLOSTWordNode({ value: "first", lang: "en", script: "latin" }),
+      ];
+      const words2 = [
+        createGLOSTWordNode({ value: "second", lang: "en", script: "latin" }),
+      ];
+
+      const sentence1 = createSentenceFromWords(words1, "en", "latin");
+      const sentence2 = createSentenceFromWords(words2, "en", "latin");
+
+      const doc = createDocumentFromSentences([sentence1, sentence2], "en", "latin");
+
+      const sentences = doc.children[0].children;
+      expect(sentences.length).toBe(2);
+      expect(sentences[0].children[0].children[0].value).toBe("first");
+      expect(sentences[1].children[0].children[0].value).toBe("second");
+    });
+  });
+
+  describe("Helper comparison", () => {
+    it("createSimpleDocument should produce same structure as manual creation", () => {
+      const word = createGLOSTWordNode({
+        value: "test",
+        lang: "en",
+        script: "latin",
+      });
+
+      // Using helper
+      const docHelper = createSimpleDocument([word], "en", "latin");
+
+      // Manual creation
+      const sentence = createSentenceFromWords([word], "en", "latin");
+      const docManual = createDocumentFromSentences([sentence], "en", "latin");
+
+      expect(docHelper.type).toBe(docManual.type);
+      expect(docHelper.lang).toBe(docManual.lang);
+      expect(docHelper.script).toBe(docManual.script);
+      expect(docHelper.children.length).toBe(docManual.children.length);
+    });
+  });
+});