@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/circuit-breaker.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Circuit Breaker Pattern
+ *
+ * Prevents cascading failures by stopping requests to failing services
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = exports.CircuitState = void 0;
+exports.getCircuitBreaker = getCircuitBreaker;
+var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "closed";
+    CircuitState["OPEN"] = "open";
+    CircuitState["HALF_OPEN"] = "half-open";
+})(CircuitState || (exports.CircuitState = CircuitState = {}));
+class CircuitBreaker {
+    constructor(name, options = {
+        failureThreshold: 5,
+        resetTimeout: 60000, // 1 minute
+        halfOpenMaxCalls: 3,
+    }) {
+        this.name = name;
+        this.options = options;
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.halfOpenCalls = 0;
+        this.successCount = 0;
+    }
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    async execute(fn) {
+        if (this.state === CircuitState.OPEN) {
+            if (Date.now() - this.lastFailureTime > this.options.resetTimeout) {
+                this.state = CircuitState.HALF_OPEN;
+                this.halfOpenCalls = 0;
+                this.successCount = 0;
+            }
+            else {
+                throw new Error(`Circuit breaker ${this.name} is OPEN`);
+            }
+        }
+        if (this.state === CircuitState.HALF_OPEN) {
+            if (this.halfOpenCalls >= this.options.halfOpenMaxCalls) {
+                // Too many calls in half-open, open the circuit
+                this.state = CircuitState.OPEN;
+                this.lastFailureTime = Date.now();
+                throw new Error(`Circuit breaker ${this.name} is OPEN`);
+            }
+            this.halfOpenCalls++;
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure();
+            throw error;
+        }
+    }
+    onSuccess() {
+        this.failureCount = 0;
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.successCount++;
+            if (this.successCount >= this.options.halfOpenMaxCalls) {
+                // Service recovered
+                this.state = CircuitState.CLOSED;
+                this.halfOpenCalls = 0;
+                this.successCount = 0;
+            }
+        }
+    }
+    onFailure() {
+        this.failureCount++;
+        this.lastFailureTime = Date.now();
+        if (this.state === CircuitState.HALF_OPEN) {
+            // Failed in half-open, open the circuit
+            this.state = CircuitState.OPEN;
+            this.halfOpenCalls = 0;
+            this.successCount = 0;
+        }
+        else if (this.failureCount >= this.options.failureThreshold) {
+            // Too many failures, open the circuit
+            this.state = CircuitState.OPEN;
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    getStats() {
+        return {
+            name: this.name,
+            state: this.state,
+            failureCount: this.failureCount,
+            lastFailureTime: this.lastFailureTime,
+        };
+    }
+    reset() {
+        this.state = CircuitState.CLOSED;
+        this.failureCount = 0;
+        this.lastFailureTime = 0;
+        this.halfOpenCalls = 0;
+        this.successCount = 0;
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+// Global circuit breakers
+const circuitBreakers = new Map();
+/**
+ * Get or create a circuit breaker
+ */
+function getCircuitBreaker(name, options) {
+    if (!circuitBreakers.has(name)) {
+        circuitBreakers.set(name, new CircuitBreaker(name, options));
+    }
+    return circuitBreakers.get(name);
+}

package/dist/utils/concurrent-map.d.ts

@@ -0,0 +1,4 @@
+export declare function concurrentMap<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<{
+    results: R[];
+    errors: Error[];
+}>;

package/dist/utils/concurrent-map.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrentMap = concurrentMap;
+async function concurrentMap(items, fn, concurrency) {
+    const results = new Array(items.length);
+    const errors = [];
+    let nextIndex = 0;
+    const worker = async () => {
+        while (nextIndex < items.length) {
+            const i = nextIndex++;
+            try {
+                results[i] = await fn(items[i], i);
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return { results, errors };
+}

package/dist/utils/detect-format.d.ts

@@ -0,0 +1,5 @@
+import type { DetectedFormat } from '../runtime/types';
+export declare function extractCurrency(raw: string): DetectedFormat | null;
+export declare function extractDate(raw: string): DetectedFormat | null;
+export declare function extractNumber(raw: string): DetectedFormat | null;
+export declare function detectFormat(text: string): DetectedFormat | null;

package/dist/utils/detect-format.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCurrency = extractCurrency;
+exports.extractDate = extractDate;
+exports.extractNumber = extractNumber;
+exports.detectFormat = detectFormat;
+// ─────────────────────────────────────────────────────────────
+// Currency Detection
+// ─────────────────────────────────────────────────────────────
+const CURRENCY_CODES = ['USD', 'EUR', 'GBP', 'JPY', 'CNY', 'INR', 'KRW', 'RUB', 'TRY', 'VND', 'UAH', 'NGN', 'PHP', 'GHS', 'ARS', 'BRL', 'MXN', 'CAD', 'AUD', 'CHF', 'SEK', 'NOK', 'DKK', 'NZD', 'SGD', 'HKD', 'TWD', 'THB', 'MYR', 'IDR'];
+const CURRENCY_PATTERNS = [
+    /^[€$£¥₹₩₽₺\u20B9\u20A8]?\s?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?\s?[€$£¥₹₩₽₺A-Z]*$/,
+    /^[A-Z]{3}\s?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?$/,
+    /^\d{1,3}(?:[.,]\d{3})*(?:[.,]\d{2})?\s?[€$£¥€]$/,
+];
+function extractCurrency(raw) {
+    const trimmed = raw.trim();
+    if (!CURRENCY_PATTERNS.some((p) => p.test(trimmed)))
+        return null;
+    const match = trimmed.match(/[\d,.\s]+(?:\.[0-9]{2})?/);
+    if (!match)
+        return null;
+    const numericPart = match[0].replace(/[^\d,.]/g, '').trim();
+    if (!numericPart)
+        return null;
+    const symbolMatch = trimmed.match(/[€$£¥₹₩₽₺\u20B9\u20A8]/);
+    const codeMatch = trimmed.match(/\b([A-Z]{3})\b/);
+    let detectedCurrency;
+    if (symbolMatch) {
+        const symbolToCode = {
+            '$': 'USD', '€': 'EUR', '£': 'GBP', '¥': 'JPY',
+            '₹': 'INR', '₩': 'KRW', '₽': 'RUB', '₺': 'TRY',
+            '₫': 'VND', '₴': 'UAH', '₦': 'NGN', '₱': 'PHP',
+            '₵': 'GHS', '₿': 'BTC',
+        };
+        detectedCurrency = symbolToCode[symbolMatch[0]] || symbolMatch[0];
+    }
+    else if (codeMatch && CURRENCY_CODES.includes(codeMatch[1])) {
+        detectedCurrency = codeMatch[1];
+    }
+    const rawNumber = numericPart.replace(/,/g, '');
+    const parsed = parseFloat(rawNumber);
+    if (isNaN(parsed))
+        return null;
+    return {
+        class: 'currency',
+        rawValue: numericPart,
+        originalString: trimmed,
+        confidence: 0.85,
+        detectedCurrency,
+    };
+}
+// ─────────────────────────────────────────────────────────────
+// Date Detection
+// ─────────────────────────────────────────────────────────────
+const DATE_PATTERNS = [
+    { regex: /^(0[1-9]|1[012])[-/](0[1-9]|[12]\d|3[01])[-/](\d{4})$/, options: { month: '2-digit', day: '2-digit', year: 'numeric' }, source: 'MM/DD/YYYY' },
+    { regex: /^(0[1-9]|[12]\d|3[01])[-/](0[1-9]|1[012])[-/](\d{4})$/, options: { day: '2-digit', month: '2-digit', year: 'numeric' }, source: 'DD/MM/YYYY' },
+    { regex: /^(\d{4})[-/](0[1-9]|1[012])[-/](0[1-9]|[12]\d|3[01])$/, options: { year: 'numeric', month: '2-digit', day: '2-digit' }, source: 'YYYY-MM-DD' },
+    { regex: /^(0[1-9]|[12]\d|3[01])\.(0[1-9]|1[012])\.(\d{4})$/, options: { day: '2-digit', month: '2-digit', year: 'numeric' }, source: 'DD.MM.YYYY' },
+    { regex: /^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+(0[1-9]|[12]\d|3[01]),\s+(\d{4})$/, options: { month: 'short', day: '2-digit', year: 'numeric' }, source: 'MMM DD, YYYY' },
+    { regex: /^(0[1-9]|[12]\d|3[01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[a-z]*\s+(\d{4})$/, options: { day: '2-digit', month: 'short', year: 'numeric' }, source: 'DD MMM YYYY' },
+];
+function extractDate(raw) {
+    const trimmed = raw.trim();
+    for (const { regex, options, source } of DATE_PATTERNS) {
+        const match = trimmed.match(regex);
+        if (match) {
+            return {
+                class: 'date',
+                rawValue: trimmed,
+                originalString: trimmed,
+                confidence: 0.9,
+                dateOptions: options,
+                dateSource: source,
+            };
+        }
+    }
+    return null;
+}
+// ─────────────────────────────────────────────────────────────
+// Number Detection
+// ─────────────────────────────────────────────────────────────
+const NUMBER_PATTERNS = [
+    /^-?\d{1,3}(?:,\d{3})+(?:\.\d+)?$/,
+    /^-?\d{1,3}(?:\.\d{3})+(?:,\d+)?$/,
+    /^-?\d+(?:\.\d+)?$/,
+];
+function extractNumber(raw) {
+    const trimmed = raw.trim();
+    if (!NUMBER_PATTERNS.some((p) => p.test(trimmed)))
+        return null;
+    const hasDotDecimal = /\.\d+$/.test(trimmed);
+    const hasCommaDecimal = /,\d+$/.test(trimmed);
+    const numberOptions = {};
+    if (hasDotDecimal || hasCommaDecimal) {
+        numberOptions.minimumFractionDigits = 0;
+        numberOptions.maximumFractionDigits = 10;
+    }
+    return {
+        class: 'number',
+        rawValue: trimmed,
+        originalString: trimmed,
+        confidence: 0.75,
+        numberOptions: Object.keys(numberOptions).length > 0 ? numberOptions : undefined,
+    };
+}
+// ─────────────────────────────────────────────────────────────
+// Dispatch
+// ─────────────────────────────────────────────────────────────
+function detectFormat(text) {
+    if (!text || text.length < 2)
+        return null;
+    const trimmed = text.trim();
+    const dateResult = extractDate(trimmed);
+    if (dateResult)
+        return dateResult;
+    const currencyResult = extractCurrency(trimmed);
+    if (currencyResult)
+        return currencyResult;
+    const numberResult = extractNumber(trimmed);
+    if (numberResult)
+        return numberResult;
+    return null;
+}

package/dist/utils/dtl-mask.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Mask Django Template Language tags with private-use sentinels
+ * so node-html-parser treats them as opaque text.
+ *
+ * Handles: {% %}, {{ }}, {# #}
+ *
+ * After masking, the HTML can be safely parsed by node-html-parser
+ * and run through the standard HTML injection pipeline.
+ */
+/**
+ * Mask DTL template tags in content.
+ * Returns the masked string and a restore function to undo masking.
+ */
+export declare function maskTemplateTags(content: string): {
+    masked: string;
+    restore: (masked: string) => string;
+};
+/**
+ * Check if content contains any Django template tags.
+ */
+export declare function hasTemplateTags(content: string): boolean;
+/**
+ * Extract all DTL template tags from content for inspection.
+ */
+export declare function extractTemplateTags(content: string): string[];

package/dist/utils/dtl-mask.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Mask Django Template Language tags with private-use sentinels
+ * so node-html-parser treats them as opaque text.
+ *
+ * Handles: {% %}, {{ }}, {# #}
+ *
+ * After masking, the HTML can be safely parsed by node-html-parser
+ * and run through the standard HTML injection pipeline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maskTemplateTags = maskTemplateTags;
+exports.hasTemplateTags = hasTemplateTags;
+exports.extractTemplateTags = extractTemplateTags;
+// Unicode Private Use Area block tag characters used as sentinels
+const BLOCK_START = '\uE000';
+const BLOCK_END = '\uE001';
+/**
+ * Mask DTL template tags in content.
+ * Returns the masked string and a restore function to undo masking.
+ */
+function maskTemplateTags(content) {
+    const replacements = [];
+    let counter = 0;
+    // Unified pattern for {% %}, {{ }}, {# #}
+    // Match opening braces with space-or-tag or closing braces with space-or-tag
+    const tagPattern = /(\{%.*?%\}|\{\{.*?\}\}|\{#.*?#\})/gs;
+    const masked = content.replace(tagPattern, (match) => {
+        const sentinel = `${BLOCK_START}${counter}${BLOCK_END}`;
+        replacements.push({ sentinel, original: match });
+        counter++;
+        return sentinel;
+    });
+    return {
+        masked,
+        restore: (maskedContent) => {
+            let restored = maskedContent;
+            for (const { sentinel, original } of replacements) {
+                // Escape sentinel for safe use in regex replacement
+                restored = restored.split(sentinel).join(original);
+            }
+            return restored;
+        },
+    };
+}
+/**
+ * Check if content contains any Django template tags.
+ */
+function hasTemplateTags(content) {
+    return /\{%.*?%\}|\{\{.*?\}\}|\{#.*?#\}/s.test(content);
+}
+/**
+ * Extract all DTL template tags from content for inspection.
+ */
+function extractTemplateTags(content) {
+    const tagPattern = /\{%.*?%\}|\{\{.*?\}\}|\{#.*?#\}/gs;
+    return content.match(tagPattern) || [];
+}

package/dist/utils/extraction-options.d.ts

@@ -0,0 +1,23 @@
+import type { WorkspaceInfo } from '../runtime/types';
+/**
+ * How a run treats ICU, resolved once from the project and the translator
+ * and shared by extraction, translation and the sync detector, so they agree.
+ */
+export interface ResolvedIcuOptions {
+    /** Group JSX sentences into one message (needs ICU placeholders at runtime for react-i18next). */
+    sentences: boolean;
+    /** Generate ICU plurals in source sentences ("{count, plural, …}"): ICU runtime + LLM translator. */
+    plurals: boolean;
+    /**
+     * The project's runtime formats ICU messages: next-intl, or react-i18next
+     * with i18next-icu. Not vue-i18n, the vanilla runtime or static HTML.
+     */
+    icuRuntime: boolean;
+    /** A translation may add an ICU plural over a count (`{files} files`): ICU runtime + LLM translator. */
+    targetPlurals: boolean;
+}
+/**
+ * @param llm the run's translator is an LLM (BYOK or an injected provider);
+ *            the NLLB service can't translate ICU plural messages.
+ */
+export declare function resolveIcuOptions(workspace: WorkspaceInfo, llm: boolean): Promise<ResolvedIcuOptions>;

package/dist/utils/extraction-options.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIcuOptions = resolveIcuOptions;
+const StrategyFactory_1 = require("../injection/StrategyFactory");
+const i18next_icu_1 = require("./i18next-icu");
+/**
+ * @param llm the run's translator is an LLM (BYOK or an injected provider);
+ *            the NLLB service can't translate ICU plural messages.
+ */
+async function resolveIcuOptions(workspace, llm) {
+    const deps = { ...workspace.packageJson?.dependencies, ...workspace.packageJson?.devDependencies };
+    const strategy = ['react', 'nextjs'].includes(workspace.framework) ? StrategyFactory_1.StrategyFactory.getStrategy(workspace.framework, deps).id : 'other';
+    let icuRuntime = false;
+    let sentences = true;
+    if (strategy === 'next-intl') {
+        icuRuntime = true;
+    }
+    else if (strategy === 'react-i18next') {
+        icuRuntime = (await (0, i18next_icu_1.detectI18nextIcu)(workspace)).available;
+        sentences = icuRuntime;
+    }
+    return { sentences, plurals: icuRuntime && llm, icuRuntime, targetPlurals: icuRuntime && llm };
+}

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,33 @@
+export declare function clearFindFilesCache(): void;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function writeFile(filePath: string, content: string, allowedBaseDir?: string): Promise<void>;
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function isDirectory(filePath: string): Promise<boolean>;
+export declare function findFiles(dir: string, extensions: string[], excludePatterns?: string[]): Promise<string[]>;
+export declare function getRelativePath(workspacePath: string, filePath: string): string;
+export declare function readJsonFile<T = any>(filePath: string): Promise<T | null>;
+export declare function writeJsonFile(filePath: string, data: any, sortKeys?: boolean): Promise<void>;
+export declare function localeExtension(format: string): string;
+/**
+ * Compute the locale directory and file path for a given target locale.
+ * Django uses `locale/<lang>/LC_MESSAGES/django.po`,
+ * other frameworks use `<publicDir>/locales/<lang>.json`.
+ */
+export declare function localeFilePath(workspacePath: string, publicDir: string, localeFormat: string, targetLocale: string): {
+    dir: string;
+    file: string;
+    relativeFile: string;
+};
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function copyFile(src: string, dest: string): Promise<void>;
+export declare function deleteFile(filePath: string): Promise<void>;
+export declare function readDir(dirPath: string): Promise<string[]>;
+/**
+ * Process items with bounded concurrency.
+ * Unlike Promise.all, this limits the number of concurrent operations.
+ * Errors are collected and returned alongside results.
+ */
+export declare function concurrentMap<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<{
+    results: R[];
+    errors: Error[];
+}>;