lokal-core 1.0.0

package/src/index.ts

@@ -0,0 +1,14 @@
+// Core exports
+export { ASTParser, type ExtractedString, type ScanOptions, type ScanResult } from './ast/parser';
+export { ConfigLoader, type LokalConfig, defaultConfig } from './config/loader';
+export { FileStorage, ContentHasher, type LocaleData, type LocaleFile } from './storage/file-storage';
+export { 
+  AITranslator, 
+  TranslationProviderFactory,
+  OpenAIProvider, 
+  GeminiProvider,
+  type TranslationProvider,
+  type TranslationRequest,
+  type TranslationResult,
+  type TranslationBatch
+} from './ai/translator';

package/src/lokal-core.d.ts

@@ -0,0 +1,113 @@
+declare module 'lokal-core' {
+    export class ASTParser {
+        constructor(options: {
+            filePath: string;
+            functionName?: string;
+            componentName?: string;
+        });
+        scanDirectory(dirPath: string): ScanResult;
+    }
+
+    export interface ExtractedString {
+        key: string;
+        value: string;
+        location?: {
+            file: string;
+            line: number;
+            column: number;
+        };
+    }
+
+    export interface ScanResult {
+        strings: ExtractedString[];
+        errors: string[];
+    }
+
+    export interface ScanOptions {
+        filePath: string;
+        functionName?: string;
+        componentName?: string;
+    }
+
+    export class ConfigLoader {
+        load(configPath?: string): Promise<LokalConfig>;
+        loadSync(configPath?: string): LokalConfig;
+    }
+
+    export interface LokalConfig {
+        sourceDir: string;
+        outputDir: string;
+        defaultLocale: string;
+        functionName: string;
+        componentName: string;
+    }
+
+    export const defaultConfig: LokalConfig;
+
+    export class FileStorage {
+        constructor(outputDir: string);
+        loadLocale(locale: string): LocaleFile | null;
+        saveLocale(locale: string, data: LocaleData): void;
+        mergeLocaleData(locale: string, newData: Record<string, string>): LocaleData;
+        getAvailableLocales(): string[];
+    }
+
+    export interface LocaleData {
+        [key: string]: string;
+    }
+
+    export interface LocaleFile {
+        locale: string;
+        data: LocaleData;
+    }
+
+    export class ContentHasher {
+        static hash(content: string): string;
+    }
+
+    export class AITranslator {
+        constructor(provider: TranslationProvider, options?: {
+            batchSize?: number;
+        });
+        translateBatch(request: TranslationBatch): Promise<TranslationResult[]>;
+    }
+
+    export interface TranslationProvider {
+        translate(request: TranslationRequest): Promise<TranslationResult>;
+    }
+
+    export interface TranslationRequest {
+        text: string;
+        sourceLocale: string;
+        targetLocale: string;
+        context?: string;
+    }
+
+    export interface TranslationResult {
+        translatedText: string;
+        success: boolean;
+        error?: string;
+    }
+
+    export interface TranslationBatch {
+        items: TranslationRequest[];
+    }
+
+    export class OpenAIProvider implements TranslationProvider {
+        constructor(apiKey: string, options?: {
+            model?: string;
+            temperature?: number;
+        });
+        translate(request: TranslationRequest): Promise<TranslationResult>;
+    }
+
+    export class GeminiProvider implements TranslationProvider {
+        constructor(apiKey: string, options?: {
+            model?: string;
+            temperature?: number;
+        });
+        translate(request: TranslationRequest): Promise<TranslationResult>;
+    }
+
+    export function TranslationProviderFactory(provider: 'openai' | 'gemini', apiKey: string, options?: object): TranslationProvider;
+}

package/src/storage/file-storage.ts

@@ -0,0 +1,200 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export interface LocaleData {
+    [key: string]: string | LocaleData;
+}
+
+export interface LocaleFile {
+    locale: string;
+    data: LocaleData;
+    hash: string;
+    lastUpdated: string;
+}
+
+/**
+ * Content hash for incremental sync
+ */
+export class ContentHasher {
+    /**
+     * Generate a hash for content to detect changes
+     */
+    static hash(content: string): string {
+        return crypto.createHash('md5').update(content).digest('hex');
+    }
+
+    /**
+     * Generate a hash for a locale data object
+     */
+    static hashLocaleData(data: LocaleData): string {
+        const content = JSON.stringify(data, Object.keys(data).sort());
+        return this.hash(content);
+    }
+}
+
+/**
+ * File system persistence for locale files
+ */
+export class FileStorage {
+    private basePath: string;
+
+    constructor(basePath: string) {
+        this.basePath = basePath;
+        this.ensureDirectoryExists(basePath);
+    }
+
+    /**
+     * Ensure directory exists
+     */
+    private ensureDirectoryExists(dirPath: string): void {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+
+    /**
+     * Load locale data from file
+     */
+    loadLocale(locale: string): LocaleFile | null {
+        const filePath = this.getLocalePath(locale);
+
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content) as LocaleFile;
+        } catch (error) {
+            console.warn(`Failed to load locale ${locale}: ${error}`);
+            return null;
+        }
+    }
+
+    /**
+     * Save locale data to file
+     */
+    saveLocale(locale: string, data: LocaleData): void {
+        const filePath = this.getLocalePath(locale);
+        const hash = ContentHasher.hashLocaleData(data);
+
+        const localeFile: LocaleFile = {
+            locale,
+            data,
+            hash,
+            lastUpdated: new Date().toISOString(),
+        };
+
+        const content = JSON.stringify(localeFile, null, 2);
+        fs.writeFileSync(filePath, content, 'utf-8');
+    }
+
+    /**
+     * Get all locale files
+     */
+    loadAllLocales(): Map<string, LocaleFile> {
+        const locales = new Map<string, LocaleFile>();
+
+        if (!fs.existsSync(this.basePath)) {
+            return locales;
+        }
+
+        const files = fs.readdirSync(this.basePath);
+
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const locale = file.replace('.json', '');
+                const localeFile = this.loadLocale(locale);
+                if (localeFile) {
+                    locales.set(locale, localeFile);
+                }
+            }
+        }
+
+        return locales;
+    }
+
+    /**
+     * Get the file path for a locale
+     */
+    private getLocalePath(locale: string): string {
+        return path.join(this.basePath, `${locale}.json`);
+    }
+
+    /**
+     * Check if a locale file exists
+     */
+    localeExists(locale: string): boolean {
+        return fs.existsSync(this.getLocalePath(locale));
+    }
+
+    /**
+     * Delete a locale file
+     */
+    deleteLocale(locale: string): boolean {
+        const filePath = this.getLocalePath(locale);
+
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Get all available locales
+     */
+    getAvailableLocales(): string[] {
+        if (!fs.existsSync(this.basePath)) {
+            return [];
+        }
+
+        return fs.readdirSync(this.basePath)
+            .filter(file => file.endsWith('.json'))
+            .map(file => file.replace('.json', ''));
+    }
+
+    /**
+     * Merge new data with existing locale data
+     */
+    mergeLocaleData(locale: string, newData: LocaleData, preserveExisting: boolean = true): LocaleData {
+        const existing = this.loadLocale(locale);
+
+        if (!existing) {
+            return newData;
+        }
+
+        if (preserveExisting) {
+            return this.deepMerge(existing.data, newData);
+        }
+
+        return newData;
+    }
+
+    /**
+     * Deep merge two objects
+     */
+    private deepMerge(target: any, source: any): any {
+        if (typeof target !== 'object' || typeof source !== 'object') {
+            return source;
+        }
+
+        const result = { ...target };
+
+        for (const key in source) {
+            if (source.hasOwnProperty(key)) {
+                if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+                    result[key] = this.deepMerge(target[key] || {}, source[key]);
+                } else {
+                    result[key] = source[key];
+                }
+            }
+        }
+
+        return result;
+    }
+}
+
+export default FileStorage;

package/src/types/@babel/traverse.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Type declarations for @babel/traverse
+ * This file provides type definitions when the package's built-in types are not detected
+ */
+
+declare module '@babel/traverse' {
+    import { Node as BabelNode } from '@babel/types';
+
+    export interface NodePath<T = BabelNode> {
+        node: T;
+        parent: BabelNode | null;
+        parentPath: NodePath | null;
+        scope: Scope;
+        hub: any;
+        context: any;
+        state: any;
+        opts: any;
+
+        get(key: string): any;
+        pushContext(context: any): void;
+        popContext(): void;
+        call(callback: (path: NodePath) => void, key: string): void;
+        isReferencedIdentifier(): boolean;
+        isBindingIdentifier(): boolean;
+        replaceWith(node: BabelNode | NodePath): void;
+        remove(): void;
+        find(callback: (path: NodePath) => boolean): NodePath | null;
+        findParent(callback: (path: NodePath) => boolean): NodePath | null;
+        traverse(visitors: Visitor<any>): void;
+    }
+
+    export interface Scope {
+        parent: Scope | null;
+        parentBlock: BabelNode;
+        block: BabelNode;
+        path: NodePath;
+        references: Map<string, NodePath[]>;
+        bindings: Map<string, Binding>;
+
+        getBinding(name: string): Binding | undefined;
+        hasBinding(name: string): boolean;
+        getOwnBinding(name: string): Binding | undefined;
+    }
+
+    export interface Binding {
+        kind: 'var' | 'let' | 'const' | 'module' | 'param' | 'local' | 'unknown';
+        path: NodePath;
+        scope: Scope;
+        constant: boolean;
+        constantViolations: NodePath[];
+        referencers: NodePath[];
+        references: number;
+    }
+
+    export interface Visitor<T> {
+        [key: string]: (path: NodePath<T>, state: any) => void;
+    }
+
+    export interface TraverseOptions {
+        scope?: boolean;
+        pragma?: string;
+        createParentMap?: boolean;
+    }
+
+    export default function traverse<S extends BabelNode = BabelNode>(
+        parent: S,
+        visitors: Visitor,
+        scope?: Scope,
+        state?: any,
+        opts?: TraverseOptions
+    ): void;
+
+    export { BabelNode as Node };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "module": "ESNext",
+        "target": "ES2020"
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.test.ts"
+    ]
+}