@babelize/vite 0.0.1

package/README.md

@@ -0,0 +1,215 @@
+# @babelize/vite
+
+**Vite plugin for Babelize** — automatically discover strings, translate them, and generate a lockfile at build time. Zero configuration required.
+
+```ts
+// vite.config.ts
+import babelize from "@babelize/vite";
+
+export default defineConfig({
+  plugins: [
+    react(),
+    babelize({
+      locales: ["ja", "fr", "de"],
+    }),
+  ],
+});
+```
+
+---
+
+## Install
+
+```bash
+bun add @babelize/vite -D
+```
+
+---
+
+## How It Works
+
+At build time, the plugin:
+
+1. **Scans** every source file for `babelize("...")`, `babelize.p(...)`, and `<BabelizeTag>` calls using AST analysis
+2. **Extracts** all unique strings and plural templates
+3. **Translates** them via the Babelize API for each configured locale
+4. **Generates** `babelize-lock.json` with all translations
+
+At runtime, the lockfile is served via a virtual module `virtual:babelize-lockfile` so the SDK can load it without any manual import path configuration.
+
+---
+
+## Quick Start
+
+### 1. Configure the plugin
+
+```ts
+// vite.config.ts
+import babelize from "@babelize/vite";
+
+export default defineConfig({
+  plugins: [
+    react(),
+    babelize({
+      locales: ["ja", "fr", "de"],
+    }),
+  ],
+});
+```
+
+### 2. Set your API key
+
+```env
+# .env
+BABELIZE_API_KEY=blz_sk_xxxxxxxxx
+```
+
+### 3. Use the lockfile in your app
+
+```tsx
+// src/main.tsx
+import { babelize } from "@babelize/sdk";
+import lockfile from "virtual:babelize-lockfile";
+
+lockfile && babelize.loadLockfile(lockfile);
+babelize.init(import.meta.env.VITE_BABELIZE_API_KEY);
+```
+
+### 4. Build
+
+```bash
+bun run build
+```
+
+The lockfile is automatically generated at `babelize-lock.json` in your project root.
+
+---
+
+## Options
+
+```ts
+interface BabelizePluginOptions {
+  apiKey?: string;
+  locales?: string[];
+  output?: string;
+  functionName?: string;
+  apiUrl?: string;
+  mock?: boolean;
+}
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `locales` | `string[]` | — | Target locales to translate to (e.g. `["ja", "fr"]`) |
+| `apiKey` | `string` | `process.env.BABELIZE_API_KEY` | Babelize API key |
+| `functionName` | `string` | `"babelize"` | Function name to scan for |
+| `output` | `string` | `"babelize-lock.json"` | Output path for the lockfile |
+| `apiUrl` | `string` | `"https://api.babelize.co/api"` | API base URL |
+| `mock` | `boolean` | `false` | Generate fake translations (`"Welcome [ja]"`) for testing without API key |
+
+---
+
+## What Gets Scanned
+
+The plugin scans these patterns in your source files:
+
+### `babelize("static string")`
+
+```tsx
+babelize("Welcome")                    // ✓ extracted
+babelize("Hello {name}", { name })     // ✓ extracted (variables stripped)
+babelize(dynamicVariable)              // ✗ skipped (can't statically analyze)
+```
+
+### `babelize.p(singular, plural, count)`
+
+```tsx
+babelize.p("{count} item", "{count} items", items.length)
+// ✓ extracted as plural with forms ["one", "other"]
+```
+
+### `babelize.plural({...}, vars)`
+
+```tsx
+babelize.plural({ one: "1 item", other: "{count} items" }, { count })
+// ✓ extracted as plural with explicit forms
+```
+
+### `<BabelizeTag template="..." />`
+
+```tsx
+<BabelizeTag
+  template="Welcome to {Babelize}, a platform {for localization}"
+  segments={{ Babelize: <strong>Babelize</strong> }}
+/>
+// ✓ template extracted as a single translation unit
+```
+
+---
+
+## Lockfile Output
+
+The plugin generates `babelize-lock.json` in your project root:
+
+```json
+{
+  "version": 1,
+  "meta": {
+    "generatedAt": "2026-07-30T12:00:00Z",
+    "locales": ["ja", "fr", "de"],
+    "totalStrings": 42
+  },
+  "strings": {
+    "Welcome": {
+      "ja": "ようこそ",
+      "fr": "Bienvenue"
+    },
+    "Hello {name}": {
+      "ja": "こんにちは {name}",
+      "fr": "Bonjour {name}"
+    }
+  },
+  "plurals": {
+    "{count} item": {
+      "forms": ["one", "other"],
+      "ja": { "other": "{count} 項目" },
+      "fr": { "one": "{count} élément", "other": "{count} éléments" }
+    }
+  }
+}
+```
+
+---
+
+## Virtual Module
+
+The plugin provides a virtual module `virtual:babelize-lockfile` that serves the current lockfile content. If a lockfile exists from a previous build, its data is used. If not, an empty lockfile is returned.
+
+```ts
+// Type declaration for the virtual module
+declare module "virtual:babelize-lockfile" {
+  const data: {
+    version: number;
+    strings: Record<string, Record<string, string>>;
+    plurals?: Record<string, any>;
+  };
+  export default data;
+}
+```
+
+---
+
+## TypeScript
+
+```ts
+import type { BabelizePluginOptions } from "@babelize/vite";
+
+interface BabelizePluginOptions {
+  apiKey?: string;
+  locales?: string[];
+  output?: string;
+  functionName?: string;
+  apiUrl?: string;
+  mock?: boolean;
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'vite';
+
+interface BabelizePluginOptions {
+    apiKey?: string;
+    locales?: string[];
+    output?: string;
+    functionName?: string;
+    apiUrl?: string;
+    mock?: boolean;
+}
+declare function babelize(options?: BabelizePluginOptions): Plugin;
+
+export { type BabelizePluginOptions, babelize, babelize as default };

package/dist/index.js

@@ -0,0 +1,311 @@
+// src/index.ts
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
+import { resolve, extname } from "path";
+
+// src/scanner.ts
+import { createRequire } from "module";
+import { parse } from "@babel/parser";
+var _require = createRequire(import.meta.url);
+var _traverse = _require("@babel/traverse");
+var traverse = _traverse.default?.default ?? _traverse.default ?? _traverse;
+var DEFAULT_FUNCTION_NAME = "babelize";
+var PLURAL_FORMS = ["zero", "one", "two", "few", "many", "other"];
+function extractLiteralArg(node) {
+  if (!node) return null;
+  if (node.type === "StringLiteral") return node.value;
+  if (node.type === "TemplateLiteral") {
+    if (node.expressions.length > 0) {
+      let pattern = "";
+      for (let i = 0; i < node.quasis.length; i++) {
+        pattern += node.quasis[i].value.cooked ?? "";
+        if (i < node.expressions.length) {
+          const expr = node.expressions[i];
+          if (expr.type === "Identifier") {
+            pattern += `{${expr.name}}`;
+          } else {
+            pattern += "{*}";
+          }
+        }
+      }
+      return pattern;
+    }
+    return node.quasis[0]?.value?.cooked ?? null;
+  }
+  return null;
+}
+function extractStrings(source, options) {
+  const fnName = options?.functionName ?? DEFAULT_FUNCTION_NAME;
+  const strings = [];
+  let ast;
+  try {
+    ast = parse(source, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx", "decorators-legacy"]
+    });
+  } catch {
+    return strings;
+  }
+  traverse(ast, {
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (callee.type === "Identifier" && callee.name === fnName) {
+        const arg = path.node.arguments[0];
+        const val = extractLiteralArg(arg);
+        if (val) strings.push(val);
+        return;
+      }
+    },
+    JSXOpeningElement(path) {
+      const name = path.node.name;
+      if (name.type !== "JSXIdentifier" || name.name !== "BabelizeTag") return;
+      const templateAttr = path.node.attributes.find(
+        (attr) => attr.type === "JSXAttribute" && attr.name?.name === "template"
+      );
+      if (!templateAttr?.value) return;
+      const extractLiteral = (node) => {
+        if (node.type === "StringLiteral") return node.value;
+        if (node.type === "TemplateLiteral") {
+          if (node.expressions.length > 0) return null;
+          return node.quasis[0]?.value?.cooked ?? null;
+        }
+        return null;
+      };
+      const value = templateAttr.value.type === "JSXExpressionContainer" ? extractLiteral(templateAttr.value.expression) : extractLiteral(templateAttr.value);
+      if (value) strings.push(value);
+    }
+  });
+  return strings;
+}
+function extractPlurals(source, options) {
+  const fnName = options?.functionName ?? DEFAULT_FUNCTION_NAME;
+  const plurals = [];
+  let ast;
+  try {
+    ast = parse(source, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx", "decorators-legacy"]
+    });
+  } catch {
+    return plurals;
+  }
+  traverse(ast, {
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === fnName && callee.property.type === "Identifier" && (callee.property.name === "p" || callee.property.name === "plural")) {
+        const singular = extractLiteralArg(path.node.arguments[0]);
+        const plural = extractLiteralArg(path.node.arguments[1]);
+        if (singular && plural) {
+          plurals.push({
+            canonical: singular,
+            forms: ["one", "other"],
+            templates: [singular, plural]
+          });
+        }
+      }
+      if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === fnName && callee.property.type === "Identifier" && callee.property.name === "plural") {
+        const formsArg = path.node.arguments[0];
+        if (formsArg?.type !== "ObjectExpression") return;
+        const formNames = [];
+        const templates = [];
+        for (const prop of formsArg.properties) {
+          if (prop.type !== "ObjectProperty") continue;
+          const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
+          if (!key || !PLURAL_FORMS.includes(key)) continue;
+          const val = extractLiteralArg(prop.value);
+          if (val) {
+            formNames.push(key);
+            templates.push(val);
+          }
+        }
+        const otherIdx = formNames.indexOf("other");
+        const canonical = otherIdx >= 0 ? templates[otherIdx] : templates[0];
+        if (canonical) {
+          plurals.push({ canonical, forms: formNames, templates });
+        }
+      }
+    }
+  });
+  return plurals;
+}
+
+// src/lockfile.ts
+function createLockfile(strings, translationsByLocale, plurals, pluralTranslationsByLocale) {
+  const locales = Object.keys(translationsByLocale);
+  const uniqueStrings = [...new Set(strings)];
+  const stringsMap = {};
+  for (const str of uniqueStrings) {
+    stringsMap[str] = {};
+    for (const locale of locales) {
+      stringsMap[str][locale] = translationsByLocale[locale]?.[str] ?? str;
+    }
+  }
+  const result = {
+    version: 1,
+    meta: {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      locales,
+      totalStrings: uniqueStrings.length
+    },
+    strings: stringsMap
+  };
+  if (plurals && plurals.length > 0) {
+    const pluralsMap = {};
+    for (const plural of plurals) {
+      pluralsMap[plural.canonical] = { forms: plural.forms };
+      for (const locale of locales) {
+        const localeTranslations = pluralTranslationsByLocale?.[locale]?.[plural.canonical];
+        if (localeTranslations) {
+          pluralsMap[plural.canonical][locale] = {};
+          for (const form of plural.forms) {
+            pluralsMap[plural.canonical][locale][form] = localeTranslations[form] ?? plural.templates[plural.forms.indexOf(form)];
+          }
+        } else {
+          pluralsMap[plural.canonical][locale] = {};
+          for (let i = 0; i < plural.forms.length; i++) {
+            pluralsMap[plural.canonical][locale][plural.forms[i]] = plural.templates[i];
+          }
+        }
+      }
+    }
+    result.plurals = pluralsMap;
+  }
+  return result;
+}
+
+// src/index.ts
+var DEFAULT_OUTPUT = "babelize-lock.json";
+var DEFAULT_API_URL = "https://api.babelize.co/api";
+var VALID_EXTS = /* @__PURE__ */ new Set([".tsx", ".ts", ".jsx", ".js"]);
+var VIRTUAL_MODULE_ID = "virtual:babelize-lockfile";
+var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+function collectSourceFiles(dir) {
+  const files = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === "dist" || entry === ".git") continue;
+      const fullPath = resolve(dir, entry);
+      if (statSync(fullPath).isDirectory()) {
+        files.push(...collectSourceFiles(fullPath));
+      } else if (VALID_EXTS.has(extname(entry))) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function babelize(options) {
+  const mock = options?.mock ?? false;
+  const apiKey = options?.apiKey ?? process.env.BABELIZE_API_KEY;
+  const locales = options?.locales;
+  const output = options?.output ?? DEFAULT_OUTPUT;
+  const fnName = options?.functionName ?? "babelize";
+  const apiUrl = options?.apiUrl ?? DEFAULT_API_URL;
+  let config;
+  function generateMockTranslations(strings, locales2) {
+    const result = {};
+    for (const locale of locales2) {
+      result[locale] = {};
+      for (const str of strings) {
+        result[locale][str] = `${str} [${locale}]`;
+      }
+    }
+    return result;
+  }
+  return {
+    name: "babelize",
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) return;
+      const outputPath = resolve(config.root, output);
+      let lockfile = { version: 1, strings: {} };
+      if (existsSync(outputPath)) {
+        try {
+          lockfile = JSON.parse(readFileSync(outputPath, "utf-8"));
+        } catch {
+        }
+      }
+      return `export default ${JSON.stringify(lockfile)};`;
+    },
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async closeBundle() {
+      const srcDir = resolve(config.root, "src");
+      if (!existsSync(srcDir)) return;
+      const sourceFiles = collectSourceFiles(srcDir);
+      if (sourceFiles.length === 0) return;
+      const allStrings = [];
+      const allPlurals = [];
+      for (const file of sourceFiles) {
+        try {
+          const code = readFileSync(file, "utf-8");
+          const strings = extractStrings(code, { functionName: fnName });
+          allStrings.push(...strings);
+          const plurals = extractPlurals(code, { functionName: fnName });
+          allPlurals.push(...plurals);
+        } catch {
+        }
+      }
+      if (allStrings.length === 0 && allPlurals.length === 0) return;
+      const uniqueStrings = [...new Set(allStrings)];
+      const uniquePlurals = allPlurals.filter(
+        (p, i, arr) => arr.findIndex((x) => x.canonical === p.canonical) === i
+      );
+      const translationsByLocale = {};
+      const pluralTranslationsByLocale = {};
+      if (locales && locales.length > 0) {
+        if (mock) {
+          Object.assign(translationsByLocale, generateMockTranslations(uniqueStrings, locales));
+        } else if (apiKey) {
+          for (const locale of locales) {
+            try {
+              const response = await fetch(`${apiUrl}/v1/translate`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  Authorization: `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                  locale,
+                  strings: uniqueStrings,
+                  plurals: uniquePlurals.map((p) => ({
+                    canonical: p.canonical,
+                    forms: p.forms,
+                    templates: p.templates
+                  }))
+                })
+              });
+              if (response.ok) {
+                const data = await response.json();
+                translationsByLocale[locale] = data.translations;
+                if (data.plurals) {
+                  pluralTranslationsByLocale[locale] = data.plurals;
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      const lockfile = createLockfile(
+        uniqueStrings,
+        translationsByLocale,
+        uniquePlurals,
+        pluralTranslationsByLocale
+      );
+      const outputPath = resolve(config.root, output);
+      writeFileSync(outputPath, JSON.stringify(lockfile, null, 2));
+    }
+  };
+}
+var index_default = babelize;
+export {
+  babelize,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@babelize/vite",
+  "version": "0.0.1",
+  "description": "Vite plugin for Babelize — auto-discover strings and generate translation lockfile at build time",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --external vite --external @babel/parser --external @babel/traverse",
+    "dev": "tsup src/index.ts --format esm --dts --watch --external vite --external @babel/parser --external @babel/traverse",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "vite": "^5.x || ^6.x"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.28.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3",
+    "vite": "^6.x"
+  }
+}