@babelize/next 0.0.1

package/README.md

@@ -0,0 +1,126 @@
+# @babelize/next
+
+**Next.js build plugin for Babelize** — automatically discover and pre-translate strings during `next build`.
+
+```ts
+// next.config.ts
+import withBabelize from "@babelize/next";
+
+export default withBabelize(
+  { /* your Next.js config */ },
+  { locales: ["ja", "fr", "de"] },
+);
+```
+
+---
+
+## Install
+
+```bash
+bun add @babelize/next -D
+```
+
+---
+
+## Quick Start
+
+### 1. Wrap your Next.js config
+
+```ts
+// next.config.ts
+import withBabelize from "@babelize/next";
+
+const nextConfig = {
+  // your existing config
+};
+
+export default withBabelize(nextConfig, {
+  locales: ["ja", "fr", "de"],
+});
+```
+
+### 2. Set your API key
+
+```env
+# .env.local
+BABELIZE_API_KEY=blz_sk_xxxxxxxxx
+```
+
+### 3. Build
+
+```bash
+bun run build
+```
+
+The plugin scans your source files during the build, translates discovered strings, and writes `babelize-lock.json` to your project root.
+
+---
+
+## How It Works
+
+The plugin integrates with Next.js's webpack build pipeline:
+
+1. **Scans** source files for `babelize("...")`, `babelize.p(...)`, and `<BabelizeTag>` calls
+2. **Translates** via the Babelize API for each configured locale
+3. **Writes** `babelize-lock.json` after the build completes
+
+The lockfile is then consumed by `@babelize/sdk-next` at runtime:
+
+```tsx
+// app/page.tsx
+import { babelizeRSC, loadLockfile } from "@babelize/sdk-next";
+import lockfile from "./babelize-lock.json";
+
+loadLockfile(lockfile);
+
+export default async function Home() {
+  return <h1>{await babelizeRSC("Welcome to Babelize")}</h1>;
+}
+```
+
+---
+
+## Options
+
+```ts
+interface BabelizeNextPluginOptions {
+  apiKey?: string;
+  locales?: string[];
+  output?: string;
+  functionName?: string;
+  apiUrl?: string;
+  include?: string[];
+}
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `locales` | `string[]` | — | Target locales to translate to |
+| `apiKey` | `string` | `process.env.BABELIZE_API_KEY` | Babelize API key |
+| `output` | `string` | `"babelize-lock.json"` | Output path for the lockfile |
+| `functionName` | `string` | `"babelize"` | Function name to scan for |
+| `apiUrl` | `string` | `"https://api.babelize.co/api"` | API base URL |
+| `include` | `string[]` | `["src/**/*.{tsx,ts,jsx,js}", "app/**/*.{tsx,ts,jsx,js}", "pages/**/*.{tsx,ts,jsx,js}"]` | Glob patterns for source files |
+
+---
+
+## Lockfile
+
+The generated `babelize-lock.json` is identical in format to the one produced by `@babelize/vite`. See the [Vite plugin documentation](https://github.com/babelize/babelize-dashboard/tree/main/packages/sdk-plugin-vite) for the full format reference.
+
+---
+
+## TypeScript
+
+```ts
+import type { BabelizeNextPluginOptions } from "@babelize/next";
+
+interface BabelizeNextPluginOptions {
+  apiKey?: string;
+  locales?: string[];
+  output?: string;
+  functionName?: string;
+  apiUrl?: string;
+  include?: string[];
+}
+```

package/dist/index.cjs

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  withBabelize: () => withBabelize
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_glob = require("glob");
+var DEFAULT_INCLUDE = ["src/**/*.{tsx,ts,jsx,js}", "app/**/*.{tsx,ts,jsx,js}", "pages/**/*.{tsx,ts,jsx,js}"];
+var DEFAULT_OUTPUT = "babelize-lock.json";
+var DEFAULT_API_URL = "https://api.babelize.co/api";
+var BABELIZE_CALL_REGEX = /\bbabelize\s*\(\s*(["'`])((?:[^\\"']|\\.)*?)\1\s*[),]/g;
+function scanFiles(rootDir, patterns) {
+  const strings = [];
+  for (const pattern of patterns) {
+    const files = (0, import_glob.globSync)(pattern, { cwd: rootDir, ignore: ["**/node_modules/**"] });
+    for (const file of files) {
+      try {
+        const content = (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(rootDir, file), "utf-8");
+        const matches = content.matchAll(BABELIZE_CALL_REGEX);
+        for (const match of matches) {
+          strings.push(match[2]);
+        }
+      } catch {
+      }
+    }
+  }
+  return strings;
+}
+var BabelizeWebpackPlugin = class {
+  constructor(rootDir, options, output) {
+    this.rootDir = rootDir;
+    this.options = options;
+    this.output = output;
+  }
+  apply(compiler) {
+    compiler.hooks.done.tapPromise("BabelizeWebpackPlugin", async () => {
+      const apiKey = this.options.apiKey ?? process.env.BABELIZE_API_KEY;
+      const locales = this.options.locales;
+      const apiUrl = this.options.apiUrl ?? DEFAULT_API_URL;
+      const include = this.options.include ?? DEFAULT_INCLUDE;
+      const strings = scanFiles(this.rootDir, include);
+      const uniqueStrings = [...new Set(strings)];
+      if (uniqueStrings.length === 0) return;
+      const translationsByLocale = {};
+      if (apiKey && locales && locales.length > 0) {
+        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 })
+            });
+            if (response.ok) {
+              const data = await response.json();
+              translationsByLocale[locale] = data.translations;
+            }
+          } catch {
+          }
+        }
+      }
+      const lockfile = {
+        version: 1,
+        meta: {
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          locales: Object.keys(translationsByLocale),
+          totalStrings: uniqueStrings.length
+        },
+        strings: Object.fromEntries(
+          uniqueStrings.map((str) => [
+            str,
+            Object.fromEntries(
+              Object.entries(translationsByLocale).map(([locale, t]) => [
+                locale,
+                t[str] ?? str
+              ])
+            )
+          ])
+        )
+      };
+      (0, import_node_fs.writeFileSync)((0, import_node_path.resolve)(this.rootDir, this.output), JSON.stringify(lockfile, null, 2));
+    });
+  }
+};
+function withBabelize(nextConfig = {}, pluginOptions = {}) {
+  const output = pluginOptions.output ?? DEFAULT_OUTPUT;
+  const originalWebpack = nextConfig.webpack;
+  return {
+    ...nextConfig,
+    webpack(config, options) {
+      if (!options.isServer) {
+        config.plugins.push(new BabelizeWebpackPlugin(options.dir, pluginOptions, output));
+      }
+      if (originalWebpack) return originalWebpack(config, options);
+      return config;
+    }
+  };
+}
+var index_default = withBabelize;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withBabelize
+});

package/dist/index.d.cts

@@ -0,0 +1,14 @@
+interface BabelizeNextPluginOptions {
+    apiKey?: string;
+    locales?: string[];
+    output?: string;
+    functionName?: string;
+    apiUrl?: string;
+    include?: string[];
+}
+interface NextConfig {
+    [key: string]: unknown;
+}
+declare function withBabelize(nextConfig?: NextConfig, pluginOptions?: BabelizeNextPluginOptions): NextConfig;
+
+export { type BabelizeNextPluginOptions, withBabelize as default, withBabelize };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+interface BabelizeNextPluginOptions {
+    apiKey?: string;
+    locales?: string[];
+    output?: string;
+    functionName?: string;
+    apiUrl?: string;
+    include?: string[];
+}
+interface NextConfig {
+    [key: string]: unknown;
+}
+declare function withBabelize(nextConfig?: NextConfig, pluginOptions?: BabelizeNextPluginOptions): NextConfig;
+
+export { type BabelizeNextPluginOptions, withBabelize as default, withBabelize };

package/dist/index.js

@@ -0,0 +1,102 @@
+// src/index.ts
+import { readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { globSync } from "glob";
+var DEFAULT_INCLUDE = ["src/**/*.{tsx,ts,jsx,js}", "app/**/*.{tsx,ts,jsx,js}", "pages/**/*.{tsx,ts,jsx,js}"];
+var DEFAULT_OUTPUT = "babelize-lock.json";
+var DEFAULT_API_URL = "https://api.babelize.co/api";
+var BABELIZE_CALL_REGEX = /\bbabelize\s*\(\s*(["'`])((?:[^\\"']|\\.)*?)\1\s*[),]/g;
+function scanFiles(rootDir, patterns) {
+  const strings = [];
+  for (const pattern of patterns) {
+    const files = globSync(pattern, { cwd: rootDir, ignore: ["**/node_modules/**"] });
+    for (const file of files) {
+      try {
+        const content = readFileSync(resolve(rootDir, file), "utf-8");
+        const matches = content.matchAll(BABELIZE_CALL_REGEX);
+        for (const match of matches) {
+          strings.push(match[2]);
+        }
+      } catch {
+      }
+    }
+  }
+  return strings;
+}
+var BabelizeWebpackPlugin = class {
+  constructor(rootDir, options, output) {
+    this.rootDir = rootDir;
+    this.options = options;
+    this.output = output;
+  }
+  apply(compiler) {
+    compiler.hooks.done.tapPromise("BabelizeWebpackPlugin", async () => {
+      const apiKey = this.options.apiKey ?? process.env.BABELIZE_API_KEY;
+      const locales = this.options.locales;
+      const apiUrl = this.options.apiUrl ?? DEFAULT_API_URL;
+      const include = this.options.include ?? DEFAULT_INCLUDE;
+      const strings = scanFiles(this.rootDir, include);
+      const uniqueStrings = [...new Set(strings)];
+      if (uniqueStrings.length === 0) return;
+      const translationsByLocale = {};
+      if (apiKey && locales && locales.length > 0) {
+        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 })
+            });
+            if (response.ok) {
+              const data = await response.json();
+              translationsByLocale[locale] = data.translations;
+            }
+          } catch {
+          }
+        }
+      }
+      const lockfile = {
+        version: 1,
+        meta: {
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          locales: Object.keys(translationsByLocale),
+          totalStrings: uniqueStrings.length
+        },
+        strings: Object.fromEntries(
+          uniqueStrings.map((str) => [
+            str,
+            Object.fromEntries(
+              Object.entries(translationsByLocale).map(([locale, t]) => [
+                locale,
+                t[str] ?? str
+              ])
+            )
+          ])
+        )
+      };
+      writeFileSync(resolve(this.rootDir, this.output), JSON.stringify(lockfile, null, 2));
+    });
+  }
+};
+function withBabelize(nextConfig = {}, pluginOptions = {}) {
+  const output = pluginOptions.output ?? DEFAULT_OUTPUT;
+  const originalWebpack = nextConfig.webpack;
+  return {
+    ...nextConfig,
+    webpack(config, options) {
+      if (!options.isServer) {
+        config.plugins.push(new BabelizeWebpackPlugin(options.dir, pluginOptions, output));
+      }
+      if (originalWebpack) return originalWebpack(config, options);
+      return config;
+    }
+  };
+}
+var index_default = withBabelize;
+export {
+  index_default as default,
+  withBabelize
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@babelize/next",
+  "version": "0.0.1",
+  "description": "Next.js build plugin for Babelize — auto-discover strings and generate lockfile during Next.js builds",
+  "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,cjs --dts --clean --external next",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch --external next",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "next": "^14.x || ^15.x"
+  },
+  "dependencies": {
+    "glob": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "next": "^15.x",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3"
+  }
+}