@idealyst/translate 1.2.3

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@idealyst/translate",
+  "version": "1.2.3",
+  "description": "Cross-platform internationalization for Idealyst Framework",
+  "readme": "README.md",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "react-native": "src/index.native.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IdealystIO/idealyst-framework.git",
+    "directory": "packages/translate"
+  },
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "react-native": "./src/index.native.ts",
+      "import": "./src/index.ts",
+      "require": "./src/index.ts",
+      "types": "./src/index.ts"
+    },
+    "./plugin": {
+      "import": "./src/babel/plugin.js",
+      "require": "./src/babel/plugin.js"
+    },
+    "./config": {
+      "import": "./src/config/index.ts",
+      "require": "./src/config/index.ts",
+      "types": "./src/config/index.ts"
+    }
+  },
+  "scripts": {
+    "prepublishOnly": "echo 'Publishing TypeScript source directly'",
+    "publish:npm": "npm publish"
+  },
+  "peerDependencies": {
+    "i18next": ">=23.0.0",
+    "react": ">=16.8.0",
+    "react-i18next": ">=13.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@babel/types": "^7.28.5",
+    "@types/babel__core": "^7.20.0",
+    "@types/glob": "^8.0.0",
+    "@types/react": "^19.1.0",
+    "glob": "^10.0.0",
+    "i18next": ">=23.0.0",
+    "react-i18next": ">=13.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "CLAUDE.md"
+  ],
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "translate",
+    "react",
+    "react-native",
+    "cross-platform",
+    "babel-plugin"
+  ]
+}

package/src/babel/__tests__/extractor.test.ts

@@ -0,0 +1,224 @@
+import { KeyRegistry, parseKey, extractKeysFromSource } from '../extractor';
+
+describe('parseKey', () => {
+  it('parses namespace:key format', () => {
+    const result = parseKey('common:buttons.submit');
+    expect(result).toEqual({
+      namespace: 'common',
+      localKey: 'buttons.submit',
+    });
+  });
+
+  it('parses namespace.key format (first segment as namespace)', () => {
+    const result = parseKey('common.buttons.submit');
+    expect(result).toEqual({
+      namespace: 'common',
+      localKey: 'buttons.submit',
+    });
+  });
+
+  it('uses default namespace for single key', () => {
+    const result = parseKey('submit', 'translation');
+    expect(result).toEqual({
+      namespace: 'translation',
+      localKey: 'submit',
+    });
+  });
+
+  it('handles deeply nested keys', () => {
+    const result = parseKey('common.forms.validation.errors.required');
+    expect(result).toEqual({
+      namespace: 'common',
+      localKey: 'forms.validation.errors.required',
+    });
+  });
+
+  it('handles colon in local key', () => {
+    const result = parseKey('common:time:format');
+    expect(result).toEqual({
+      namespace: 'common',
+      localKey: 'time:format',
+    });
+  });
+});
+
+describe('KeyRegistry', () => {
+  let registry: KeyRegistry;
+
+  beforeEach(() => {
+    registry = new KeyRegistry();
+  });
+
+  it('adds and retrieves keys', () => {
+    registry.addKey({
+      key: 'common.test',
+      namespace: 'common',
+      localKey: 'test',
+      file: 'test.tsx',
+      line: 1,
+      column: 0,
+      isDynamic: false,
+    });
+
+    expect(registry.getKeyCount()).toBe(1);
+    expect(registry.hasKey('common.test')).toBe(true);
+  });
+
+  it('tracks multiple usages of the same key', () => {
+    const baseKey = {
+      key: 'common.test',
+      namespace: 'common',
+      localKey: 'test',
+      isDynamic: false,
+    };
+
+    registry.addKey({ ...baseKey, file: 'file1.tsx', line: 1, column: 0 });
+    registry.addKey({ ...baseKey, file: 'file2.tsx', line: 5, column: 0 });
+
+    const usages = registry.getKeyUsages('common.test');
+    expect(usages).toHaveLength(2);
+    expect(usages[0].file).toBe('file1.tsx');
+    expect(usages[1].file).toBe('file2.tsx');
+  });
+
+  it('separates static and dynamic keys', () => {
+    registry.addKey({
+      key: 'common.static',
+      namespace: 'common',
+      localKey: 'static',
+      file: 'test.tsx',
+      line: 1,
+      column: 0,
+      isDynamic: false,
+    });
+
+    registry.addKey({
+      key: '<dynamic>',
+      namespace: 'common',
+      localKey: '<dynamic>',
+      file: 'test.tsx',
+      line: 2,
+      column: 0,
+      isDynamic: true,
+    });
+
+    expect(registry.getStaticKeys()).toHaveLength(1);
+    expect(registry.getDynamicKeys()).toHaveLength(1);
+  });
+
+  it('returns unique keys', () => {
+    const baseKey = {
+      key: 'common.test',
+      namespace: 'common',
+      localKey: 'test',
+      isDynamic: false,
+    };
+
+    registry.addKey({ ...baseKey, file: 'file1.tsx', line: 1, column: 0 });
+    registry.addKey({ ...baseKey, file: 'file2.tsx', line: 5, column: 0 });
+
+    const uniqueKeys = registry.getUniqueKeys();
+    expect(uniqueKeys).toHaveLength(1);
+    expect(uniqueKeys[0]).toBe('common.test');
+  });
+
+  it('groups keys by namespace', () => {
+    registry.addKey({
+      key: 'common.test1',
+      namespace: 'common',
+      localKey: 'test1',
+      file: 'test.tsx',
+      line: 1,
+      column: 0,
+      isDynamic: false,
+    });
+
+    registry.addKey({
+      key: 'auth.login',
+      namespace: 'auth',
+      localKey: 'login',
+      file: 'test.tsx',
+      line: 2,
+      column: 0,
+      isDynamic: false,
+    });
+
+    const byNamespace = registry.getKeysByNamespace();
+    expect(Object.keys(byNamespace)).toEqual(['common', 'auth']);
+    expect(byNamespace.common).toHaveLength(1);
+    expect(byNamespace.auth).toHaveLength(1);
+  });
+
+  it('clears all keys', () => {
+    registry.addKey({
+      key: 'common.test',
+      namespace: 'common',
+      localKey: 'test',
+      file: 'test.tsx',
+      line: 1,
+      column: 0,
+      isDynamic: false,
+    });
+
+    registry.clear();
+    expect(registry.getKeyCount()).toBe(0);
+  });
+});
+
+describe('extractKeysFromSource', () => {
+  it('extracts t() calls with single quotes', () => {
+    const code = `const label = t('common.buttons.submit');`;
+    const keys = extractKeysFromSource(code, 'test.tsx');
+
+    expect(keys).toHaveLength(1);
+    expect(keys[0].key).toBe('common.buttons.submit');
+    expect(keys[0].namespace).toBe('common');
+    expect(keys[0].localKey).toBe('buttons.submit');
+  });
+
+  it('extracts t() calls with double quotes', () => {
+    const code = `const label = t("common.buttons.submit");`;
+    const keys = extractKeysFromSource(code, 'test.tsx');
+
+    expect(keys).toHaveLength(1);
+    expect(keys[0].key).toBe('common.buttons.submit');
+  });
+
+  it('extracts multiple t() calls', () => {
+    const code = `
+      const submit = t('common.buttons.submit');
+      const cancel = t('common.buttons.cancel');
+    `;
+    const keys = extractKeysFromSource(code, 'test.tsx');
+
+    expect(keys).toHaveLength(2);
+    expect(keys[0].key).toBe('common.buttons.submit');
+    expect(keys[1].key).toBe('common.buttons.cancel');
+  });
+
+  it('extracts Trans component i18nKey', () => {
+    const code = `<Trans i18nKey="common.richText" />`;
+    const keys = extractKeysFromSource(code, 'test.tsx');
+
+    expect(keys).toHaveLength(1);
+    expect(keys[0].key).toBe('common.richText');
+  });
+
+  it('extracts both t() and Trans keys', () => {
+    const code = `
+      const label = t('common.title');
+      return <Trans i18nKey="common.description" />;
+    `;
+    const keys = extractKeysFromSource(code, 'test.tsx');
+
+    expect(keys).toHaveLength(2);
+  });
+
+  it('includes line numbers', () => {
+    const code = `const label = t('common.test');`;
+    const keys = extractKeysFromSource(code, 'test.tsx');
+
+    expect(keys[0].line).toBe(1);
+    expect(keys[0].file).toBe('test.tsx');
+  });
+});

package/src/babel/__tests__/plugin.test.ts

@@ -0,0 +1,289 @@
+import * as babel from '@babel/core';
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Import the plugin
+const plugin = require('../plugin');
+
+// Reset the global registry before each test
+beforeEach(() => {
+  plugin.globalRegistry.clear();
+});
+
+function transform(code: string, options = {}, filename = 'test.tsx') {
+  const result = babel.transformSync(code, {
+    filename,
+    presets: ['@babel/preset-typescript'],
+    plugins: [[plugin, options]],
+    babelrc: false,
+    configFile: false,
+  });
+  return result;
+}
+
+function transformWithReact(code: string, options = {}, filename = 'test.tsx') {
+  const result = babel.transformSync(code, {
+    filename,
+    presets: [
+      ['@babel/preset-react', { runtime: 'automatic' }],
+      '@babel/preset-typescript',
+    ],
+    plugins: [[plugin, options]],
+    babelrc: false,
+    configFile: false,
+  });
+  return result;
+}
+
+describe('Babel Plugin - Key Extraction', () => {
+  describe('t() function calls', () => {
+    it('extracts simple t() calls', () => {
+      const code = `const label = t('common.hello');`;
+
+      transform(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('common.hello');
+      expect(keys[0].namespace).toBe('common');
+      expect(keys[0].localKey).toBe('hello');
+    });
+
+    it('extracts t() with namespace:key format', () => {
+      const code = `const label = t('auth:login.title');`;
+
+      transform(code, { defaultNamespace: 'common' });
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('auth:login.title');
+      expect(keys[0].namespace).toBe('auth');
+      expect(keys[0].localKey).toBe('login.title');
+    });
+
+    it('extracts t() with interpolation options', () => {
+      const code = `const greeting = t('common.greeting', { name: 'World' });`;
+
+      transform(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('common.greeting');
+    });
+
+    it('extracts defaultValue from options', () => {
+      const code = `const label = t('common.new', { defaultValue: 'New Feature' });`;
+
+      transform(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].defaultValue).toBe('New Feature');
+    });
+
+    it('extracts i18n.t() calls', () => {
+      const code = `const label = i18n.t('common.hello');`;
+
+      transform(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('common.hello');
+    });
+
+    it('marks dynamic keys as isDynamic', () => {
+      const code = `
+        const key = 'common.' + someVar;
+        const label = t(key);
+      `;
+
+      transform(code);
+      const dynamicKeys = plugin.globalRegistry.getDynamicKeys();
+
+      expect(dynamicKeys).toHaveLength(1);
+      expect(dynamicKeys[0].isDynamic).toBe(true);
+      expect(dynamicKeys[0].key).toBe('<dynamic>');
+    });
+
+    it('marks template literals with expressions as dynamic', () => {
+      const code = 'const label = t(`common.${type}.title`);';
+
+      transform(code);
+      const dynamicKeys = plugin.globalRegistry.getDynamicKeys();
+
+      expect(dynamicKeys).toHaveLength(1);
+      expect(dynamicKeys[0].isDynamic).toBe(true);
+    });
+
+    it('treats template literals without expressions as static', () => {
+      const code = 'const label = t(`common.hello`);';
+
+      transform(code);
+      const staticKeys = plugin.globalRegistry.getStaticKeys();
+
+      expect(staticKeys).toHaveLength(1);
+      expect(staticKeys[0].key).toBe('common.hello');
+      expect(staticKeys[0].isDynamic).toBe(false);
+    });
+  });
+
+  describe('<Trans> component', () => {
+    it('extracts i18nKey from Trans component', () => {
+      const code = `<Trans i18nKey="common.richText" />`;
+
+      transformWithReact(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('common.richText');
+    });
+
+    it('extracts i18nKey with namespace prefix', () => {
+      const code = `<Trans i18nKey="auth.terms" />`;
+
+      transformWithReact(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].namespace).toBe('auth');
+      expect(keys[0].localKey).toBe('terms');
+    });
+
+    it('extracts i18nKey from JSX expression', () => {
+      const code = `<Trans i18nKey={"common.richText"} />`;
+
+      transformWithReact(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].key).toBe('common.richText');
+    });
+
+    it('marks dynamic i18nKey as isDynamic', () => {
+      const code = `<Trans i18nKey={dynamicKey} />`;
+
+      transformWithReact(code);
+      const dynamicKeys = plugin.globalRegistry.getDynamicKeys();
+
+      expect(dynamicKeys).toHaveLength(1);
+      expect(dynamicKeys[0].isDynamic).toBe(true);
+    });
+  });
+
+  describe('multiple files', () => {
+    it('aggregates keys from multiple transforms', () => {
+      const code1 = `const a = t('common.key1');`;
+      const code2 = `const b = t('common.key2');`;
+
+      transform(code1, {}, 'file1.tsx');
+      transform(code2, {}, 'file2.tsx');
+
+      const keys = plugin.globalRegistry.getUniqueKeys();
+      expect(keys).toHaveLength(2);
+      expect(keys).toContain('common.key1');
+      expect(keys).toContain('common.key2');
+    });
+
+    it('tracks same key used in multiple files', () => {
+      transform(`const a = t('common.shared');`, {}, 'file1.tsx');
+      transform(`const b = t('common.shared');`, {}, 'file2.tsx');
+
+      const usages = plugin.globalRegistry.getKeyUsages('common.shared');
+      expect(usages).toHaveLength(2);
+      expect(usages[0].file).toContain('file1.tsx');
+      expect(usages[1].file).toContain('file2.tsx');
+    });
+  });
+
+  describe('source locations', () => {
+    it('captures line and column numbers', () => {
+      const code = `const label = t('common.test');`;
+
+      transform(code);
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].line).toBeGreaterThan(0);
+      expect(keys[0].column).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('default namespace', () => {
+    it('uses configured default namespace', () => {
+      const code = `const label = t('buttonLabel');`;
+
+      transform(code, { defaultNamespace: 'ui' });
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].namespace).toBe('ui');
+      expect(keys[0].localKey).toBe('buttonLabel');
+    });
+
+    it('uses translation as default when not configured', () => {
+      const code = `const label = t('buttonLabel');`;
+
+      transform(code, {});
+      const keys = plugin.globalRegistry.getStaticKeys();
+
+      expect(keys).toHaveLength(1);
+      expect(keys[0].namespace).toBe('translation');
+    });
+  });
+});
+
+describe('Babel Plugin - Report Generation (via generateReport)', () => {
+  // Note: Full report generation through the plugin is tested in reporter.test.ts
+  // These tests verify the plugin correctly passes keys to the report generator
+
+  it('passes extracted keys for report generation', () => {
+    plugin.globalRegistry.clear();
+
+    const code1 = `const a = t('common.hello');`;
+    const code2 = `const b = t('common.world');`;
+
+    transform(code1, {}, 'file1.tsx');
+    transform(code2, {}, 'file2.tsx');
+
+    // Verify keys are in registry
+    const keys = plugin.globalRegistry.getStaticKeys();
+    expect(keys).toHaveLength(2);
+
+    // Generate report using the plugin's exported function
+    const report = plugin.generateReport(keys, {
+      translationFiles: [],
+      languages: ['en', 'es'],
+      defaultNamespace: 'common',
+    });
+
+    expect(report.totalKeys).toBe(2);
+    expect(report.languages).toContain('en');
+    expect(report.languages).toContain('es');
+  });
+
+  it('includes dynamic keys in report', () => {
+    plugin.globalRegistry.clear();
+
+    const code = `
+      const key = dynamicVar;
+      const label = t(key);
+    `;
+
+    transform(code);
+
+    const report = plugin.generateReport(plugin.globalRegistry.getAllKeys(), {
+      translationFiles: [],
+      languages: ['en'],
+      defaultNamespace: 'common',
+    });
+
+    expect(report.dynamicKeys).toHaveLength(1);
+    expect(report.dynamicKeys[0].isDynamic).toBe(true);
+  });
+
+  it('exports generateReport and writeReport functions', () => {
+    expect(typeof plugin.generateReport).toBe('function');
+    expect(typeof plugin.writeReport).toBe('function');
+    expect(typeof plugin.parseKey).toBe('function');
+  });
+});