@lokascript/i18n 1.0.0

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@lokascript/i18n",
+  "version": "1.0.0",
+  "description": "Grammar transformation and keyword translation for hyperscript",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.mjs",
+      "require": "./dist/browser.js"
+    },
+    "./dictionaries": {
+      "types": "./dist/dictionaries/index.d.ts",
+      "import": "./dist/dictionaries/index.mjs",
+      "require": "./dist/dictionaries/index.js"
+    },
+    "./plugins/vite": {
+      "types": "./dist/plugins/vite.d.ts",
+      "import": "./dist/plugins/vite.mjs",
+      "require": "./dist/plugins/vite.js"
+    },
+    "./plugins/webpack": {
+      "types": "./dist/plugins/webpack.d.ts",
+      "import": "./dist/plugins/webpack.mjs",
+      "require": "./dist/plugins/webpack.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup && npm run build:browser",
+    "build:browser": "rollup -c rollup.config.mjs",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext ts,tsx",
+    "validate-dictionaries": "node scripts/validate-dictionaries.js"
+  },
+  "browser": "dist/hyperfixi-i18n.min.js",
+  "sideEffects": false,
+  "keywords": [
+    "hyperscript",
+    "i18n",
+    "internationalization",
+    "translation",
+    "localization"
+  ],
+  "author": "Hyperfixi Team",
+  "license": "MIT",
+  "dependencies": {
+    "@lokascript/ast-toolkit": "*",
+    "@lokascript/core": "*",
+    "@lokascript/semantic": "*",
+    "esbuild": "0.25.11",
+    "happy-dom": "20.0.6",
+    "vite": "^7.1.12"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.0",
+    "eslint": "^8.0.0",
+    "rollup": "^4.41.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.0"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/browser.ts

@@ -0,0 +1,122 @@
+/**
+ * Browser entry point for @lokascript/i18n
+ *
+ * This module exports only what's needed for browser usage:
+ * - Keyword providers for each locale
+ * - LocaleManager for runtime locale switching
+ * - Factory functions for custom providers
+ *
+ * Usage with UMD bundle:
+ * ```html
+ * <script src="hyperfixi-core.min.js"></script>
+ * <script src="hyperfixi-i18n.min.js"></script>
+ * <script>
+ *   // Configure HyperFixi with Spanish keywords
+ *   HyperFixi.configure({ keywords: HyperFixiI18n.esKeywords });
+ * </script>
+ * ```
+ *
+ * Usage with ES modules:
+ * ```typescript
+ * import { esKeywords } from '@lokascript/i18n';
+ * import { Parser } from '@lokascript/core';
+ *
+ * const parser = new Parser(tokens, { keywords: esKeywords });
+ * ```
+ */
+
+// Types
+export type { KeywordProvider, KeywordProviderOptions } from './parser/types';
+
+// Factory functions
+export { createKeywordProvider, createEnglishProvider } from './parser/create-provider';
+export {
+  ENGLISH_COMMANDS,
+  ENGLISH_KEYWORDS,
+  UNIVERSAL_ENGLISH_KEYWORDS,
+} from './parser/create-provider';
+
+// Locale keyword providers
+export { esKeywords, esDictionary } from './parser/es';
+export { jaKeywords, jaDictionary } from './parser/ja';
+export { frKeywords, frDictionary } from './parser/fr';
+export { deKeywords, deDictionary } from './parser/de';
+export { arKeywords, arDictionary } from './parser/ar';
+export { koKeywords, koDictionary } from './parser/ko';
+export { zhKeywords, zhDictionary } from './parser/zh';
+export { trKeywords, trDictionary } from './parser/tr';
+export { idKeywords, idDictionary } from './parser/id';
+export { quKeywords, quDictionary } from './parser/qu';
+export { swKeywords, swDictionary } from './parser/sw';
+export { ptKeywords, ptDictionary } from './parser/pt';
+
+// Locale management
+export { LocaleManager, detectBrowserLocale } from './parser/locale-manager';
+
+// Re-export dictionaries for custom provider creation
+export { es } from './dictionaries/es';
+export { ja } from './dictionaries/ja';
+export { fr } from './dictionaries/fr';
+export { de } from './dictionaries/de';
+export { ar } from './dictionaries/ar';
+export { ko } from './dictionaries/ko';
+export { zh } from './dictionaries/zh';
+export { tr } from './dictionaries/tr';
+export { id } from './dictionaries/id';
+export { qu } from './dictionaries/qu';
+export { sw } from './dictionaries/sw';
+export { pt } from './dictionaries/pt';
+
+// Grammar-aware transformation system (Phase 2)
+export {
+  // Types (re-exported for browser usage)
+  type SemanticRole,
+  type WordOrder,
+  type AdpositionType,
+  type MorphologyType,
+  type GrammaticalMarker,
+  type LanguageProfile,
+  type GrammarRule,
+  type PatternMatcher,
+  type PatternTransform,
+  type ParsedStatement,
+  type ParsedElement,
+  // Universal patterns and language family defaults
+  UNIVERSAL_PATTERNS,
+  LANGUAGE_FAMILY_DEFAULTS,
+  // Transformation utilities
+  reorderRoles,
+  insertMarkers,
+  joinTokens,
+  transformStatement,
+  // Profiles
+  profiles,
+  getProfile,
+  getSupportedLocales,
+  englishProfile,
+  japaneseProfile,
+  koreanProfile,
+  chineseProfile,
+  arabicProfile,
+  turkishProfile,
+  spanishProfile,
+  germanProfile,
+  frenchProfile,
+  portugueseProfile,
+  indonesianProfile,
+  quechuaProfile,
+  swahiliProfile,
+  // Direct language-pair translation
+  directMappings,
+  hasDirectMapping,
+  getDirectMapping,
+  translateWordDirect,
+  getSupportedDirectPairs,
+  // Transformer
+  GrammarTransformer,
+  parseStatement,
+  toLocale,
+  toEnglish,
+  translate,
+  examples as grammarExamples,
+} from './grammar';

package/src/compatibility/browser-tests/grammar-demo.spec.ts

@@ -0,0 +1,169 @@
+/**
+ * Browser test for Grammar Transformation Demo
+ *
+ * Verifies that the GrammarTransformer class works correctly in the browser
+ * and the multilingual demo page properly demonstrates live transformations.
+ */
+import { test, expect } from '@playwright/test';
+
+test.describe('Grammar Transformation Demo', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('http://127.0.0.1:3000/examples/multilingual/index.html');
+    // Wait for i18n bundle to load
+    await page.waitForFunction(() => window.LokaScriptI18n !== undefined, { timeout: 5000 });
+  });
+
+  test('should load LokaScriptI18n bundle with GrammarTransformer', async ({ page }) => {
+    const hasI18n = await page.evaluate(() => !!window.LokaScriptI18n);
+    expect(hasI18n).toBe(true);
+
+    const hasTransformer = await page.evaluate(() => !!window.LokaScriptI18n.GrammarTransformer);
+    expect(hasTransformer).toBe(true);
+
+    const hasTranslate = await page.evaluate(
+      () => typeof window.LokaScriptI18n.translate === 'function'
+    );
+    expect(hasTranslate).toBe(true);
+  });
+
+  test('should have profile functions available', async ({ page }) => {
+    const locales = await page.evaluate(() => window.LokaScriptI18n.getSupportedLocales?.() || []);
+    expect(locales).toContain('en');
+    expect(locales).toContain('ja');
+    expect(locales).toContain('ar');
+    expect(locales).toContain('zh');
+  });
+
+  test('should transform English to Japanese (SOV)', async ({ page }) => {
+    const result = await page.evaluate(() => {
+      const { translate } = window.LokaScriptI18n;
+      return translate('on click increment #count', 'en', 'ja');
+    });
+
+    // Japanese SOV should have #count before the action
+    expect(result).toContain('#count');
+    expect(result).toContain('を'); // Object particle
+    // Patient should come before action in SOV
+    const countIndex = result.indexOf('#count');
+    const actionIndex = result.indexOf('増加');
+    expect(countIndex).toBeLessThan(actionIndex);
+  });
+
+  test('should transform English to Arabic (VSO)', async ({ page }) => {
+    const result = await page.evaluate(() => {
+      const { translate } = window.LokaScriptI18n;
+      return translate('on click increment #count', 'en', 'ar');
+    });
+
+    // Arabic VSO should have action first
+    expect(result).toContain('#count');
+    expect(result).toContain('زِد'); // Action should be present
+    // Action should come first in VSO
+    const actionIndex = result.indexOf('زِد');
+    const countIndex = result.indexOf('#count');
+    expect(actionIndex).toBeLessThan(countIndex);
+  });
+
+  test('should transform English to Chinese with circumfix', async ({ page }) => {
+    const result = await page.evaluate(() => {
+      const { translate } = window.LokaScriptI18n;
+      return translate('on click increment #count', 'en', 'zh');
+    });
+
+    // Chinese should have 当...时 circumfix pattern
+    expect(result).toContain('当');
+    expect(result).toContain('时');
+    expect(result).toContain('#count');
+  });
+
+  test('should preserve CSS selectors during transformation', async ({ page }) => {
+    const selectors = ['.active', '#count', '.menu-item[data-active="true"]'];
+
+    for (const selector of selectors) {
+      const result = await page.evaluate(
+        ({ sel }) => {
+          const { translate } = window.LokaScriptI18n;
+          return translate(`on click toggle ${sel}`, 'en', 'ja');
+        },
+        { sel: selector }
+      );
+
+      expect(result).toContain(selector);
+    }
+  });
+
+  test('should have grammar demo section with live input', async ({ page }) => {
+    // Check for grammar demo input
+    const input = await page.locator('#grammar-input');
+    await expect(input).toBeVisible();
+
+    // Check for results container
+    const results = await page.locator('#grammar-results');
+    await expect(results).toBeVisible();
+  });
+
+  test('should update transformations when input changes', async ({ page }) => {
+    const input = await page.locator('#grammar-input');
+    const results = await page.locator('#grammar-results');
+
+    // Clear and enter new code
+    await input.fill('on click toggle .active');
+
+    // Wait for debounce and transformation
+    await page.waitForTimeout(200);
+
+    // Results should contain transformations
+    const resultsText = await results.textContent();
+    expect(resultsText).toContain('.active');
+  });
+
+  test('should show all 10 language transformations', async ({ page }) => {
+    const results = await page.locator('#grammar-results');
+
+    // Wait for initial render
+    await page.waitForTimeout(200);
+
+    // Count language cards (each has a flag emoji)
+    const langCards = await results.locator('div[style*="border-radius: 8px"]').count();
+    expect(langCards).toBeGreaterThanOrEqual(10);
+  });
+
+  test('should handle example buttons', async ({ page }) => {
+    const input = await page.locator('#grammar-input');
+
+    // Click toggle example button
+    await page.click('button:has-text("toggle")');
+
+    // Input should be updated
+    const value = await input.inputValue();
+    expect(value).toBe('on click toggle .active');
+  });
+
+  test('should have utility functions exported', async ({ page }) => {
+    const utilities = await page.evaluate(() => ({
+      hasJoinTokens: typeof window.LokaScriptI18n.joinTokens === 'function',
+      hasReorderRoles: typeof window.LokaScriptI18n.reorderRoles === 'function',
+      hasInsertMarkers: typeof window.LokaScriptI18n.insertMarkers === 'function',
+      hasTransformStatement: typeof window.LokaScriptI18n.transformStatement === 'function',
+      hasUniversalPatterns: !!window.LokaScriptI18n.UNIVERSAL_PATTERNS,
+      hasLanguageFamilyDefaults: !!window.LokaScriptI18n.LANGUAGE_FAMILY_DEFAULTS,
+    }));
+
+    expect(utilities.hasJoinTokens).toBe(true);
+    expect(utilities.hasReorderRoles).toBe(true);
+    expect(utilities.hasInsertMarkers).toBe(true);
+    expect(utilities.hasTransformStatement).toBe(true);
+    expect(utilities.hasUniversalPatterns).toBe(true);
+    expect(utilities.hasLanguageFamilyDefaults).toBe(true);
+  });
+
+  test('should handle joinTokens for agglutinative suffixes', async ({ page }) => {
+    const result = await page.evaluate(() => {
+      const { joinTokens } = window.LokaScriptI18n;
+      return joinTokens(['#count', '-ta', 'increment']); // Quechua-style suffix
+    });
+
+    // Suffix should attach without space
+    expect(result).toBe('#countta increment');
+  });
+});