@babelize/engine 0.0.0-stage → 0.1.0

package/dist/modules/finalization/index.d.ts

@@ -0,0 +1 @@
+export { finalizeProject } from './finalize';

package/dist/modules/finalization/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalizeProject = void 0;
+var finalize_1 = require("./finalize");
+Object.defineProperty(exports, "finalizeProject", { enumerable: true, get: function () { return finalize_1.finalizeProject; } });

package/dist/modules/finalization/nextjs-finalize.d.ts

@@ -0,0 +1,37 @@
+import type { WorkspaceInfo } from '../../runtime/types';
+/**
+ * Next.js finalization for next-intl.
+ *
+ * Injection rewrites Next.js components to next-intl (`getTranslations` in
+ * Server Components, `useTranslations` in Client Components — see
+ * NextIntlStrategy), so the project must be wired for next-intl or every
+ * page throws at runtime. This sets up next-intl's "without i18n routing"
+ * mode: the locale comes from a NEXT_LOCALE cookie or the browser's
+ * Accept-Language header, and messages are the generated
+ * `public/locales/<locale>.json` files. URLs don't change.
+ *
+ * Every edit is a minimal text splice (the user's formatting is kept), and
+ * anything that can't be wired automatically becomes a warning — never a
+ * silently half-configured project.
+ */
+export declare const NEXT_INTL_DEPENDENCIES: Record<string, string>;
+export interface NextIntlFinalizeResult {
+    configFileCreated: boolean;
+    entryPointModified: boolean;
+    warnings: string[];
+}
+export declare function buildRequestConfig(opts: {
+    sourceLocale: string;
+    locales: string[];
+    /** Import path from the request config file to a locale file, with `__LOCALE__` as placeholder. */
+    messagesImportPath: string;
+    typescript: boolean;
+}): string;
+/** Wrap the next.config default export / module.exports with next-intl's plugin. */
+export declare function wrapNextConfig(content: string, requestConfigPath: string, typescript: boolean): string | null;
+/** Wrap `{children}` inside the root layout's <body> with <NextIntlClientProvider>. */
+export declare function wrapRootLayout(content: string, typescript: boolean): string | null;
+export declare function finalizeNextIntl(workspace: WorkspaceInfo, dryRun: boolean, options: {
+    sourceLocale?: string;
+    targetLocales?: string[];
+}): Promise<NextIntlFinalizeResult>;

package/dist/modules/finalization/nextjs-finalize.js

@@ -0,0 +1,329 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEXT_INTL_DEPENDENCIES = void 0;
+exports.buildRequestConfig = buildRequestConfig;
+exports.wrapNextConfig = wrapNextConfig;
+exports.wrapRootLayout = wrapRootLayout;
+exports.finalizeNextIntl = finalizeNextIntl;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("../../utils/file-utils");
+const ast_helpers_1 = require("../../utils/ast-helpers");
+/**
+ * Next.js finalization for next-intl.
+ *
+ * Injection rewrites Next.js components to next-intl (`getTranslations` in
+ * Server Components, `useTranslations` in Client Components — see
+ * NextIntlStrategy), so the project must be wired for next-intl or every
+ * page throws at runtime. This sets up next-intl's "without i18n routing"
+ * mode: the locale comes from a NEXT_LOCALE cookie or the browser's
+ * Accept-Language header, and messages are the generated
+ * `public/locales/<locale>.json` files. URLs don't change.
+ *
+ * Every edit is a minimal text splice (the user's formatting is kept), and
+ * anything that can't be wired automatically becomes a warning — never a
+ * silently half-configured project.
+ */
+exports.NEXT_INTL_DEPENDENCIES = {
+    'next-intl': '^4.0.0',
+};
+const GENERATED_MARKER = '@babelize-generated next-intl request config';
+const NEXT_CONFIG_FILES = ['next.config.ts', 'next.config.mjs', 'next.config.js', 'next.config.cjs'];
+const LAYOUT_FILES = ['layout.tsx', 'layout.jsx', 'layout.js', 'layout.ts'];
+function applySplices(content, splices) {
+    let out = content;
+    for (const s of [...splices].sort((a, b) => b.at - a.at)) {
+        out = out.slice(0, s.at) + s.insert + out.slice(s.at + (s.remove ?? 0));
+    }
+    return out;
+}
+/** Offset right after the last top-level import (or after leading directives), plus a newline prefix if needed. */
+function importInsertionPoint(ast) {
+    let at = 0;
+    for (const node of ast.program.body) {
+        if (ast_helpers_1.t.isImportDeclaration(node) && node.end != null)
+            at = node.end;
+    }
+    if (at === 0 && ast.program.directives.length > 0) {
+        at = ast.program.directives[ast.program.directives.length - 1].end ?? 0;
+    }
+    return at;
+}
+function insertTopLevel(ast, lines) {
+    const at = importInsertionPoint(ast);
+    return at === 0 ? { at: 0, insert: `${lines}\n` } : { at, insert: `\n${lines}` };
+}
+function toPosix(p) {
+    return p.split(path.sep).join('/');
+}
+async function findFirst(dir, names) {
+    for (const name of names) {
+        const candidate = path.join(dir, name);
+        if (await (0, file_utils_1.pathExists)(candidate))
+            return candidate;
+    }
+    return null;
+}
+function buildRequestConfig(opts) {
+    const locales = [opts.sourceLocale, ...opts.locales.filter((l) => l !== opts.sourceLocale)];
+    const ts = opts.typescript;
+    const importPath = opts.messagesImportPath.replace('__LOCALE__', '${locale}');
+    return `// ${GENERATED_MARKER}
+// Babelize regenerates this file (to update the locale list) while the line
+// above is present. Remove that line to take it over.
+import { getRequestConfig } from 'next-intl/server';
+import { cookies, headers } from 'next/headers';
+
+export const sourceLocale = ${JSON.stringify(opts.sourceLocale)};
+export const locales = ${JSON.stringify(locales)};
+
+function pickLocale(candidates${ts ? ': Array<string | undefined>' : ''})${ts ? ': string' : ''} {
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const wanted = candidate.toLowerCase();
+    const exact = locales.find((l) => l.toLowerCase() === wanted);
+    if (exact) return exact;
+    const base = locales.find((l) => l.split('-')[0].toLowerCase() === wanted.split('-')[0]);
+    if (base) return base;
+  }
+  return sourceLocale;
+}
+
+export default getRequestConfig(async () => {
+  // Locale preference: the NEXT_LOCALE cookie, then the browser's Accept-Language.
+  const cookieLocale = (await cookies()).get('NEXT_LOCALE')?.value;
+  const acceptLanguage = ((await headers()).get('accept-language') ?? '')
+    .split(',')
+    .map((part) => part.split(';')[0].trim());
+  const locale = pickLocale([cookieLocale, ...acceptLanguage]);
+  return {
+    locale,
+    messages: (await import(\`${importPath}\`)).default,
+  };
+});
+`;
+}
+/** Wrap the next.config default export / module.exports with next-intl's plugin. */
+function wrapNextConfig(content, requestConfigPath, typescript) {
+    if (content.includes('next-intl/plugin'))
+        return content;
+    let ast;
+    try {
+        ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript: typescript, isJSX: false });
+    }
+    catch {
+        return null;
+    }
+    const pluginArg = JSON.stringify(requestConfigPath);
+    for (const node of ast.program.body) {
+        if (ast_helpers_1.t.isExportDefaultDeclaration(node) &&
+            ast_helpers_1.t.isExpression(node.declaration) &&
+            node.declaration.start != null &&
+            node.declaration.end != null) {
+            return applySplices(content, [
+                insertTopLevel(ast, `import createNextIntlPlugin from 'next-intl/plugin';\n\nconst withNextIntl = createNextIntlPlugin(${pluginArg});`),
+                { at: node.declaration.start, insert: 'withNextIntl(' },
+                { at: node.declaration.end, insert: ')' },
+            ]);
+        }
+        if (ast_helpers_1.t.isExpressionStatement(node) &&
+            ast_helpers_1.t.isAssignmentExpression(node.expression) &&
+            ast_helpers_1.t.isMemberExpression(node.expression.left) &&
+            ast_helpers_1.t.isIdentifier(node.expression.left.object, { name: 'module' }) &&
+            ast_helpers_1.t.isIdentifier(node.expression.left.property, { name: 'exports' }) &&
+            node.expression.right.start != null &&
+            node.expression.right.end != null) {
+            return applySplices(content, [
+                {
+                    at: 0,
+                    insert: `const createNextIntlPlugin = require('next-intl/plugin');\n\nconst withNextIntl = createNextIntlPlugin(${pluginArg});\n\n`,
+                },
+                { at: node.expression.right.start, insert: 'withNextIntl(' },
+                { at: node.expression.right.end, insert: ')' },
+            ]);
+        }
+    }
+    return null;
+}
+/** Wrap `{children}` inside the root layout's <body> with <NextIntlClientProvider>. */
+function wrapRootLayout(content, typescript) {
+    if (content.includes('NextIntlClientProvider'))
+        return content;
+    let ast;
+    try {
+        ast = (0, ast_helpers_1.parseCode)(content, { isTypeScript: typescript });
+    }
+    catch {
+        return null;
+    }
+    let target = null;
+    (0, ast_helpers_1.traverse)(ast, {
+        JSXElement(p) {
+            const name = p.node.openingElement.name;
+            if (!ast_helpers_1.t.isJSXIdentifier(name, { name: 'body' }))
+                return;
+            p.traverse({
+                JSXExpressionContainer(inner) {
+                    if (ast_helpers_1.t.isIdentifier(inner.node.expression, { name: 'children' }) && inner.node.start != null && inner.node.end != null) {
+                        target = { start: inner.node.start, end: inner.node.end };
+                        inner.stop();
+                    }
+                },
+            });
+            p.stop();
+        },
+    });
+    if (!target)
+        return null;
+    const { start, end } = target;
+    return applySplices(content, [
+        insertTopLevel(ast, `import { NextIntlClientProvider } from 'next-intl';`),
+        { at: start, insert: '<NextIntlClientProvider>' },
+        { at: end, insert: '</NextIntlClientProvider>' },
+    ]);
+}
+/**
+ * Locales the request config should offer: every locale file on disk (this
+ * run's and earlier runs') plus this run's source and targets, so a later run
+ * with a different `--to` never hides locales that still have files.
+ */
+async function availableLocales(workspace, options) {
+    const found = new Set(options.targetLocales ?? []);
+    const dir = path.dirname((0, file_utils_1.localeFilePath)(workspace.path, workspace.publicDir, 'json', '__LOCALE__').file);
+    const entries = await fs.promises.readdir(dir).catch(() => []);
+    for (const entry of entries) {
+        if (entry.endsWith('.json'))
+            found.add(entry.slice(0, -'.json'.length));
+    }
+    const source = options.sourceLocale ?? 'en';
+    found.delete(source);
+    // This run's targets in the order given, then the other locales found on disk.
+    const targets = (options.targetLocales ?? []).filter((l) => l !== source);
+    return [...new Set([...targets, ...[...found].sort()])];
+}
+async function finalizeNextIntl(workspace, dryRun, options) {
+    const warnings = [];
+    let configFileCreated = false;
+    let entryPointModified = false;
+    const root = workspace.path;
+    const typescript = await (0, file_utils_1.pathExists)(path.join(root, 'tsconfig.json'));
+    const appDir = (await (0, file_utils_1.pathExists)(path.join(root, 'app')))
+        ? path.join(root, 'app')
+        : (await (0, file_utils_1.pathExists)(path.join(root, 'src', 'app')))
+            ? path.join(root, 'src', 'app')
+            : null;
+    if (!appDir) {
+        const pagesRouter = (await (0, file_utils_1.pathExists)(path.join(root, 'pages'))) || (await (0, file_utils_1.pathExists)(path.join(root, 'src', 'pages')));
+        warnings.push(pagesRouter
+            ? 'Next.js Pages Router detected: Babelize injected next-intl calls but cannot wire next-intl into pages/_app automatically yet. ' +
+                'Add NextIntlClientProvider to _app and load messages from public/locales — see https://next-intl.dev/docs/getting-started/pages-router.'
+            : 'No Next.js app/ directory found: next-intl was not wired up. See https://next-intl.dev/docs/getting-started/app-router.');
+        return { configFileCreated, entryPointModified, warnings };
+    }
+    // 1. i18n/request.ts — next-intl's request config (next to app/, i.e. in src/ when app/ is).
+    // An existing request file (ours or the user's) decides the file name, so
+    // the content's syntax always matches its extension and next.config points
+    // at a file that exists.
+    const requestDir = path.join(path.dirname(appDir), 'i18n');
+    const existingRequest = await findFirst(requestDir, ['request.ts', 'request.tsx', 'request.js', 'request.jsx', 'request.mjs']);
+    const requestFile = existingRequest ?? path.join(requestDir, `request.${typescript ? 'ts' : 'js'}`);
+    const requestIsTs = /\.tsx?$/.test(requestFile);
+    const existingContent = existingRequest ? await (0, file_utils_1.readFile)(existingRequest).catch(() => '') : null;
+    if (existingRequest && existingContent !== null && !existingContent.includes(GENERATED_MARKER)) {
+        warnings.push(`${toPosix(path.relative(root, existingRequest))} already exists and was not generated by Babelize; left untouched. ` +
+            `Make sure it loads messages from ${toPosix(workspace.publicDir)}/locales/<locale>.json.`);
+    }
+    else {
+        const sampleLocale = (0, file_utils_1.localeFilePath)(root, workspace.publicDir, 'json', '__LOCALE__').file;
+        let messagesImportPath = toPosix(path.relative(requestDir, sampleLocale));
+        if (!messagesImportPath.startsWith('.'))
+            messagesImportPath = `./${messagesImportPath}`;
+        const content = buildRequestConfig({
+            sourceLocale: options.sourceLocale ?? 'en',
+            locales: await availableLocales(workspace, options),
+            messagesImportPath,
+            typescript: requestIsTs,
+        });
+        if (content !== existingContent) {
+            if (!dryRun)
+                await (0, file_utils_1.writeFile)(requestFile, content);
+            configFileCreated = true;
+        }
+    }
+    // 2. next.config — wrap with the next-intl plugin.
+    const pluginPath = `./${toPosix(path.relative(root, requestFile))}`;
+    const nextConfigPath = await findFirst(root, NEXT_CONFIG_FILES);
+    if (!nextConfigPath) {
+        const created = `import createNextIntlPlugin from 'next-intl/plugin';\n\n` +
+            `const withNextIntl = createNextIntlPlugin(${JSON.stringify(pluginPath)});\n\n` +
+            `/** @type {import('next').NextConfig} */\nconst nextConfig = {};\n\nexport default withNextIntl(nextConfig);\n`;
+        if (!dryRun)
+            await (0, file_utils_1.writeFile)(path.join(root, 'next.config.mjs'), created);
+        configFileCreated = true;
+    }
+    else {
+        const content = await (0, file_utils_1.readFile)(nextConfigPath);
+        const wrapped = wrapNextConfig(content, pluginPath, nextConfigPath.endsWith('.ts'));
+        if (wrapped === null) {
+            warnings.push(`Could not wire next-intl into ${path.basename(nextConfigPath)} automatically. Wrap your config with ` +
+                `createNextIntlPlugin(${JSON.stringify(pluginPath)}) from 'next-intl/plugin'.`);
+        }
+        else if (wrapped !== content) {
+            if (!dryRun)
+                await (0, file_utils_1.writeFile)(nextConfigPath, wrapped);
+            configFileCreated = true;
+        }
+    }
+    // 3. Root layout — NextIntlClientProvider so Client Components can use useTranslations().
+    const layoutPath = await findFirst(appDir, LAYOUT_FILES);
+    if (!layoutPath) {
+        warnings.push('No root layout found in app/: wrap your app in <NextIntlClientProvider> from next-intl.');
+    }
+    else {
+        const content = await (0, file_utils_1.readFile)(layoutPath);
+        const wrapped = wrapRootLayout(content, /\.tsx?$/.test(layoutPath));
+        if (wrapped === null) {
+            warnings.push(`Could not find {children} inside <body> in ${toPosix(path.relative(root, layoutPath))}: ` +
+                'wrap it in <NextIntlClientProvider> from next-intl so Client Components can translate.');
+        }
+        else if (wrapped !== content) {
+            if (!dryRun)
+                await (0, file_utils_1.writeFile)(layoutPath, wrapped);
+            entryPointModified = true;
+        }
+    }
+    return { configFileCreated, entryPointModified, warnings };
+}

package/dist/modules/finalization/static-runtime.d.ts

@@ -0,0 +1,9 @@
+export declare const STATIC_RUNTIME_VERSION = "1.0.0";
+export declare const RUNTIME_HEADER = "/* babelize:static-runtime v1.0.0 */";
+export declare function buildStaticRuntime(config: {
+    sourceLocale: string;
+    targetLocales: string[];
+    baseDir?: string;
+}): string;
+export declare function buildSwitcherPlaceholder(): string;
+export declare function checkRuntimeNeedsRegeneration(existingContent: string): 'missing' | 'ours' | 'user';

package/dist/modules/finalization/static-runtime.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_HEADER = exports.STATIC_RUNTIME_VERSION = void 0;
+exports.buildStaticRuntime = buildStaticRuntime;
+exports.buildSwitcherPlaceholder = buildSwitcherPlaceholder;
+exports.checkRuntimeNeedsRegeneration = checkRuntimeNeedsRegeneration;
+exports.STATIC_RUNTIME_VERSION = '1.0.0';
+exports.RUNTIME_HEADER = `/* babelize:static-runtime v${exports.STATIC_RUNTIME_VERSION} */`;
+function buildStaticRuntime(config) {
+    const locales = JSON.stringify([config.sourceLocale, ...config.targetLocales]);
+    const baseDir = config.baseDir ? JSON.stringify(config.baseDir) : 'null';
+    return `${exports.RUNTIME_HEADER}
+(function () {
+  'use strict';
+  var SOURCE = ${JSON.stringify(config.sourceLocale)};
+  var LOCALES = ${locales};
+  var BASE_DIR = ${baseDir};
+
+  var loadedLocales = {};
+  var fetching = {};
+  var lang = null;
+
+  function resolveBase() {
+    var script = document.currentScript;
+    if (script && script.src) {
+      var url = new URL(script.src, window.location.href);
+      return url.href.replace(/\\/[^/]*$/, '/');
+    }
+    var el = document.querySelector('[data-babelize-base]');
+    if (el) {
+      var attr = el.getAttribute('data-babelize-base');
+      if (attr) return attr;
+    }
+    if (BASE_DIR) return BASE_DIR;
+    return './';
+  }
+
+  var BASE = resolveBase();
+
+  function fetchLocale(locale, cb) {
+    if (loadedLocales[locale]) {
+      cb(null, loadedLocales[locale]);
+      return;
+    }
+    if (fetching[locale]) {
+      fetching[locale].push(cb);
+      return;
+    }
+    fetching[locale] = [cb];
+
+    var url = BASE + 'locales/' + locale + '.json';
+
+    function done(err, data) {
+      if (!err && data) {
+        loadedLocales[locale] = data;
+      }
+      var cbs = fetching[locale];
+      delete fetching[locale];
+      for (var i = 0; i < cbs.length; i++) {
+        cbs[i](err, data);
+      }
+    }
+
+    if (typeof window.fetch === 'function') {
+      window.fetch(url).then(function (res) {
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        return res.json();
+      }).then(function (data) {
+        done(null, data);
+      }).catch(function (e) {
+        fallbackXhr(url, done);
+      });
+    } else {
+      fallbackXhr(url, done);
+    }
+  }
+
+  function fallbackXhr(url, cb) {
+    try {
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', url, true);
+      xhr.onreadystatechange = function () {
+        if (xhr.readyState === 4) {
+          if (xhr.status === 200) {
+            try {
+              cb(null, JSON.parse(xhr.responseText));
+            } catch (e) {
+              cb(e, null);
+            }
+          } else {
+            cb(new Error('HTTP ' + xhr.status), null);
+          }
+        }
+      };
+      xhr.onerror = function () { cb(new Error('Network error'), null); };
+      xhr.send();
+    } catch (e) {
+      cb(e, null);
+    }
+  }
+
+  function getTranslation(key) {
+    var parts = key.split('.');
+    var current = loadedLocales[lang] || {};
+    for (var i = 0; i < parts.length; i++) {
+      if (current === null || current === undefined) break;
+      current = current[parts[i]];
+    }
+    if (current !== undefined) return current;
+    current = loadedLocales[lang] || {};
+    if (current[key] !== undefined) return current[key];
+    return undefined;
+  }
+
+  function applyTranslations() {
+    var walk = document.createTreeWalker(
+      document.body,
+      NodeFilter.SHOW_ELEMENT,
+      null,
+      false
+    );
+    var node;
+    while ((node = walk.nextNode())) {
+      var key = node.getAttribute('data-i18n');
+      if (key) {
+        var val = getTranslation(key);
+        if (val === undefined) continue;
+        var argsStr = node.getAttribute('data-i18n-args');
+        if (argsStr) {
+          try {
+            var args = JSON.parse(argsStr);
+            val = String(val).split('{').map(function(part, i) {
+              if (i === 0) return part;
+              var closeIdx = part.indexOf('}');
+              if (closeIdx === -1) return '{' + part;
+              var name = part.substring(0, closeIdx);
+              var rest = part.substring(closeIdx + 1);
+              return (args[name] !== undefined ? args[name] : '{' + name + '}') + rest;
+            }).join('');
+          } catch (e) {}
+        }
+        if (node.getAttribute('data-i18n-html') === '1') {
+          node.innerHTML = val;
+        } else {
+          var tw = document.createTreeWalker(node, NodeFilter.SHOW_TEXT, null, false);
+          var textNodes = [];
+          while (tw.nextNode()) textNodes.push(tw.currentNode);
+          for (var i = 0; i < textNodes.length; i++) {
+            textNodes[i].textContent = val;
+          }
+        }
+      }
+      var attrNames = ['alt', 'title', 'placeholder', 'aria-label', 'aria-description'];
+      for (var a = 0; a < attrNames.length; a++) {
+        var attrKey = node.getAttribute('data-i18n-' + attrNames[a]);
+        if (attrKey) {
+          var attrVal = getTranslation(attrKey);
+          if (attrVal !== undefined) node.setAttribute(attrNames[a], attrVal);
+        }
+      }
+    }
+  }
+
+  function updateHtmlAttributes() {
+    var meta = (loadedLocales[lang] || {})._meta;
+    if (!meta) return;
+    var html = document.documentElement;
+    if (meta.language) html.setAttribute('lang', meta.language);
+    if (meta.dir) html.setAttribute('dir', meta.dir);
+  }
+
+  function resolveLanguage() {
+    var params = new URLSearchParams(window.location.search);
+    var fromParam = params.get('lang') || params.get('hl');
+    if (fromParam) return fromParam;
+    try {
+      var stored = window.localStorage.getItem('babelize-lang');
+      if (stored) return stored;
+    } catch (e) {}
+    var match = document.cookie.match(/(?:^|;\\s*)lang=([^;]*)/);
+    if (match) return match[1];
+    return (navigator.language || 'en').split('-')[0];
+  }
+
+  function switchLanguage(locale) {
+    lang = locale;
+    document.cookie = 'lang=' + locale + ';path=/;max-age=31536000';
+    try { window.localStorage.setItem('babelize-lang', locale); } catch (e) {}
+    fetchLocale(locale, function (err) {
+      if (!err) {
+        updateHtmlAttributes();
+        applyTranslations();
+      }
+      document.dispatchEvent(new CustomEvent('babelize:languagechange', {
+        detail: { language: locale }
+      }));
+    });
+  }
+
+  function init() {
+    lang = resolveLanguage();
+    fetchLocale(lang, function (err) {
+      if (err) {
+        if (lang !== SOURCE) {
+          lang = SOURCE;
+          fetchLocale(SOURCE, function () {
+            updateHtmlAttributes();
+            applyTranslations();
+          });
+        }
+        return;
+      }
+      updateHtmlAttributes();
+      applyTranslations();
+    });
+  }
+
+  window.switchLanguage = switchLanguage;
+
+  window.babelize = {
+    switchLanguage: switchLanguage,
+    t: getTranslation,
+    apply: applyTranslations,
+    getLanguage: function () { return lang; },
+    locales: LOCALES
+  };
+
+  var switcher = document.querySelector('[data-babelize-switcher]');
+  if (switcher) {
+    var sel = document.createElement('select');
+    sel.setAttribute('data-babelize-switcher-select', '');
+    for (var i = 0; i < LOCALES.length; i++) {
+      var opt = document.createElement('option');
+      opt.value = LOCALES[i];
+      opt.textContent = LOCALES[i];
+      sel.appendChild(opt);
+    }
+    sel.addEventListener('change', function () { switchLanguage(this.value); });
+    switcher.appendChild(sel);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+})();
+`;
+}
+function buildSwitcherPlaceholder() {
+    return '<div data-babelize-switcher></div>';
+}
+function checkRuntimeNeedsRegeneration(existingContent) {
+    if (!existingContent || existingContent.trim().length === 0) {
+        return 'missing';
+    }
+    if (existingContent.includes(exports.RUNTIME_HEADER)) {
+        return 'ours';
+    }
+    return 'user';
+}

package/dist/modules/format-injection/index.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractedString, FileInjection, SkippedFile, WorkspaceInfo } from '../../runtime/types';
+import type { FormatLocaleConfig } from '@babelize/types';
+export interface FormatInjectionResult {
+    modifiedFiles: FileInjection[];
+    skippedFiles: SkippedFile[];
+    totalInjections: number;
+}
+/**
+ * Run format injection for all format strings.
+ *
+ * Replaces hardcoded currency, date, and number values in source files
+ * with Intl.* API calls (e.g., Intl.NumberFormat, Intl.DateTimeFormat).
+ */
+export declare function injectFormats(workspace: WorkspaceInfo, formatStrings: ExtractedString[], formatConfig: FormatLocaleConfig, dryRun?: boolean): Promise<FormatInjectionResult>;
+/**
+ * Filter format strings out of an array of extracted strings.
+ * Returns [translatableStrings, formatStrings].
+ */
+export declare function partitionFormatStrings(strings: ExtractedString[]): [translatable: ExtractedString[], format: ExtractedString[]];