@uipkge/nuxt 0.1.35 → 0.1.36

package/bin/cli.mjs

@@ -1,109 +1,331 @@
 #!/usr/bin/env node
-import { execSync } from 'child_process'
-import fs from 'fs'
-import path from 'path'
-import { createInterface } from 'readline'
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { createInterface } from "readline";
 
-const PKG_DIR = path.resolve(import.meta.dirname, '..')
-const TARGET_DIR = process.cwd()
-const distDir = path.join(PKG_DIR, 'dist')
+const TARGET_DIR = process.cwd();
 
-const isInstalled = fs.existsSync(distDir)
+// ── Helpers ──────────────────────────────────────────────────────────
 
-function run(cmd, opts = {}) {
-  console.log(`> ${cmd}`)
-  execSync(cmd, { stdio: 'inherit', ...opts })
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (ans) => {
+      rl.close();
+      resolve(ans.trim());
+    });
+  });
 }
 
-function exists(file) {
-  return fs.existsSync(path.join(TARGET_DIR, file))
+function parseFlags(args) {
+  const flags = {};
+  for (const arg of args) {
+    const match = arg.match(/^--([a-zA-Z-]+)=(.+)$/);
+    if (match) {
+      // Normalize camelCase to kebab-case: projectId → project-id
+      const key = match[1].replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+      flags[key] = match[2];
+    }
+  }
+  return flags;
 }
 
-function prompt(question) {
-  return new Promise(resolve => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout })
-    rl.question(question, ans => { rl.close(); resolve(ans) })
-  })
+function detectPackageManager() {
+  if (fs.existsSync(path.join(TARGET_DIR, "bun.lock")) || fs.existsSync(path.join(TARGET_DIR, "bun.lockb")))
+    return "bun";
+  if (fs.existsSync(path.join(TARGET_DIR, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(TARGET_DIR, "yarn.lock"))) return "yarn";
+  return "npm";
 }
 
-async function getInput(question, defaultValue) {
-  const answer = await prompt(question)
-  return answer.trim() || defaultValue
+function run(cmd) {
+  execSync(cmd, { stdio: "inherit", cwd: TARGET_DIR });
 }
 
-async function main() {
-  console.log('\n🚀 @uipkge/nuxt setup\n')
+function isInstalled(pkg) {
+  try {
+    const pkgJson = JSON.parse(fs.readFileSync(path.join(TARGET_DIR, "package.json"), "utf-8"));
+    const all = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    return pkg in all;
+  } catch {
+    return false;
+  }
+}
 
-  if (isInstalled) {
-    console.log('📦 Package ready')
+function findNuxtConfig() {
+  for (const name of ["nuxt.config.ts", "nuxt.config.js"]) {
+    const p = path.join(TARGET_DIR, name);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function devCommand(pm) {
+  if (pm === "npm") return "npm run dev";
+  return `${pm} dev`;
+}
+
+function validateProjectId(id) {
+  const trimmed = id.trim();
+  return trimmed.length > 0 && trimmed.length <= 100;
+}
+
+function validateApiKey(key) {
+  const trimmed = key.trim();
+  return trimmed.length >= 8 && trimmed.length <= 200;
+}
+
+function maskApiKey(key) {
+  if (key.length < 8) return "*".repeat(key.length);
+  const start = key.slice(0, 4);
+  const end = key.slice(-4);
+  return `${start}${"*".repeat(key.length - 8)}${end}`;
+}
+
+function writeEnvFile(apiKey) {
+  const envPath = path.join(TARGET_DIR, ".env");
+  if (fs.existsSync(envPath)) {
+    let content = fs.readFileSync(envPath, "utf-8");
+    if (content.match(/^I18NOW_API_KEY=.*/m)) {
+      content = content.replace(/^I18NOW_API_KEY=.*/m, `I18NOW_API_KEY=${apiKey}`);
+    } else {
+      content = content.trimEnd() + `\nI18NOW_API_KEY=${apiKey}\n`;
+    }
+    fs.writeFileSync(envPath, content);
   } else {
-    console.log('📦 Building package...')
-    run('npm run build', { cwd: PKG_DIR })
-  }
-
-  console.log('\n📥 Installing @nuxtjs/i18n...')
-  run('npm install @nuxtjs/i18n@latest', { cwd: TARGET_DIR })
-
-  if (!isInstalled) {
-    run('npm link', { cwd: PKG_DIR })
-    run('npm link @uipkge/nuxt', { cwd: TARGET_DIR })
-  }
-
-  console.log('\n⚙️  i18now configuration:')
-  const projectId = await getInput('Enter projectId (or press Enter to skip): ', '')
-  const apiKey = await getInput('Enter apiKey (or press Enter to skip): ', '')
-
-  const nuxtConfigPath = path.join(TARGET_DIR, 'nuxt.config.ts')
-  const nuxtConfigContent = `export default defineNuxtConfig({
-  compatibilityDate: '2025-07-15',
-  devtools: { enabled: true },
-  modules: ['@nuxtjs/i18n', '@uipkge/nuxt'],
-  i18n: {
-    defaultLocale: 'en',
-  },
-  i18now: {
-    projectId: '${projectId}',
-    apiKey: '${apiKey}',
-  },
-})
-`
-  fs.writeFileSync(nuxtConfigPath, nuxtConfigContent)
-
-  const pagesDir = path.join(TARGET_DIR, 'app/pages')
-  if (!fs.existsSync(pagesDir)) {
-    fs.mkdirSync(pagesDir, { recursive: true })
-  }
-
-  const testPagePath = path.join(TARGET_DIR, 'app/pages/i18now-test.vue')
-  if (!fs.existsSync(testPagePath)) {
-    console.log('📄 Creating test page at /i18now-test...')
-    fs.writeFileSync(testPagePath, `<script setup>
+    fs.writeFileSync(envPath, `I18NOW_API_KEY=${apiKey}\n`);
+  }
+}
+
+// ── Smart Merge ──────────────────────────────────────────────────────
+
+async function smartMerge(configPath, projectId) {
+  const { loadFile, writeFile, builders } = await import("magicast");
+  const { addNuxtModule } = await import("magicast/helpers");
+
+  const mod = await loadFile(configPath);
+  const config = mod.exports.default.$type === "function-call"
+    ? mod.exports.default.$args[0]
+    : mod.exports.default;
+
+  // Add modules (addNuxtModule takes the full magicast object)
+  addNuxtModule(mod, "@nuxtjs/i18n");
+  addNuxtModule(mod, "@uipkge/nuxt");
+
+  // Add i18n config if missing
+  if (!config.i18n) {
+    config.i18n = {
+      defaultLocale: "en",
+      locales: ["en"],
+    };
+  } else if (!config.i18n.defaultLocale) {
+    config.i18n.defaultLocale = "en";
+  }
+
+  // Add/update i18now config (preserve existing options)
+  if (!config.i18now) {
+    config.i18now = {};
+  }
+  config.i18now.projectId = projectId;
+  config.i18now.apiKey = builders.raw("process.env.I18NOW_API_KEY");
+
+  await writeFile(mod, configPath);
+}
+
+// ── Test Page ────────────────────────────────────────────────────────
+
+function createTestPage() {
+  // Check both Nuxt 3 page directories
+  const appPagesDir = path.join(TARGET_DIR, "app/pages");
+  const pagesDir = path.join(TARGET_DIR, "pages");
+
+  // Use app/pages if app/ dir exists, otherwise pages/
+  const targetPagesDir = fs.existsSync(path.join(TARGET_DIR, "app")) ? appPagesDir : pagesDir;
+  const testPagePath = path.join(targetPagesDir, "i18now-test.vue");
+
+  if (fs.existsSync(testPagePath)) {
+    console.log("  Test page already exists, skipping");
+    return false;
+  }
+
+  fs.mkdirSync(targetPagesDir, { recursive: true });
+  fs.writeFileSync(
+    testPagePath,
+    `<script setup>
 const { t, locale } = useI18now()
 </script>
 
 <template>
   <div style="padding: 20px; font-family: sans-serif; max-width: 600px;">
     <h1>i18now Test Page</h1>
-    
+
     <h2>Translation Keys (try adding new ones):</h2>
     <p>{{ t('welcome_message', 'Welcome to i18now!') }}</p>
     <p>{{ t('description', 'This is a test page for translations.') }}</p>
     <p>{{ t('feature_sync', 'Key sync is enabled in development mode.') }}</p>
-    
+
     <h2>Language Switcher:</h2>
     <select v-model="locale" style="padding: 8px; margin: 10px 0;">
       <option value="en">English</option>
-      <option value="es">Español</option>
+      <option value="es">Espa\u00f1ol</option>
     </select>
-    
+
     <p><small>Current locale: {{ locale }}</small></p>
     <p><small>Add new t() calls above to test key sync!</small></p>
   </div>
 </template>
-`)
+`,
+  );
+  return true;
+}
+
+// ── Main ─────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(pkg.version);
+    process.exit(0);
+  }
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+@uipkge/nuxt v${pkg.version}
+
+Usage: npx @uipkge/nuxt init [options]
+
+Options:
+  --project-id=<id>   Your i18now project ID
+  --api-key=<key>     Your i18now API key
+  --help, -h          Show this help message
+  --version, -v       Show version number
+
+Aliases: --projectId, --apiKey (camelCase also accepted)
+`);
+    process.exit(0);
+  }
+
+  const command = args[0];
+
+  if (command !== "init") {
+    console.log(`\n@uipkge/nuxt v${pkg.version}\n`);
+    console.log("Usage: npx @uipkge/nuxt init [--project-id=xxx] [--api-key=xxx]");
+    console.log("       npx @uipkge/nuxt --help\n");
+    process.exit(command ? 1 : 0);
+  }
+
+  console.log(`\n@uipkge/nuxt v${pkg.version} setup\n`);
+
+  // 1. Verify Nuxt project
+  const configPath = findNuxtConfig();
+  if (!configPath) {
+    console.error("No nuxt.config.ts or nuxt.config.js found. Run this inside a Nuxt project.");
+    process.exit(1);
+  }
+
+  // 2. Parse flags or prompt
+  const flags = parseFlags(args.slice(1));
+  let projectId = flags["project-id"] || "";
+  let apiKey = flags["api-key"] || "";
+
+  const isTTY = process.stdin.isTTY;
+
+  if (!projectId) {
+    if (!isTTY) {
+      console.error("Provide --project-id flag (non-interactive terminal detected).");
+      process.exit(1);
+    }
+    projectId = await prompt("Project ID: ");
+    if (!projectId) {
+      console.error("Project ID is required.");
+      process.exit(1);
+    }
+  }
+
+  if (!apiKey) {
+    if (!isTTY) {
+      console.error("Provide --api-key flag (non-interactive terminal detected).");
+      process.exit(1);
+    }
+    apiKey = await prompt("API Key: ");
+    if (!apiKey) {
+      console.error("API Key is required.");
+      process.exit(1);
+    }
+  }
+
+  // 3. Validate inputs
+  if (!validateProjectId(projectId)) {
+    console.error("Invalid Project ID. Must be 1-100 characters.");
+    process.exit(1);
+  }
+  if (!validateApiKey(apiKey)) {
+    console.error("Invalid API Key. Must be 8-200 characters.");
+    process.exit(1);
+  }
+
+  // 4. Detect package manager
+  const pm = detectPackageManager();
+
+  // 5. Install @nuxtjs/i18n if missing
+  if (!isInstalled("@nuxtjs/i18n")) {
+    console.log("Installing @nuxtjs/i18n...");
+    const installCmd = {
+      bun: "bun add @nuxtjs/i18n",
+      pnpm: "pnpm add @nuxtjs/i18n",
+      yarn: "yarn add @nuxtjs/i18n",
+      npm: "npm install @nuxtjs/i18n",
+    };
+    run(installCmd[pm]);
+  } else {
+    console.log("@nuxtjs/i18n already installed");
+  }
+
+  // 6. Install @uipkge/nuxt if missing
+  if (!isInstalled("@uipkge/nuxt")) {
+    console.log("Installing @uipkge/nuxt...");
+    const installCmd = {
+      bun: "bun add @uipkge/nuxt",
+      pnpm: "pnpm add @uipkge/nuxt",
+      yarn: "yarn add @uipkge/nuxt",
+      npm: "npm install @uipkge/nuxt",
+    };
+    run(installCmd[pm]);
+  }
+
+  // 7. Save API key to .env
+  writeEnvFile(apiKey);
+  console.log("  Saved API key to .env (add .env to .gitignore!)");
+
+  // 8. Smart merge nuxt.config
+  console.log("Updating nuxt.config...");
+  try {
+    await smartMerge(configPath, projectId);
+    console.log("  Added @uipkge/nuxt to nuxt.config");
+  } catch (err) {
+    console.error(`Failed to update nuxt.config: ${err.message}`);
+    console.log("\nAdd this manually to your nuxt.config:\n");
+    console.log(`  modules: ['@nuxtjs/i18n', '@uipkge/nuxt'],`);
+    console.log(`  i18n: { defaultLocale: 'en', locales: ['en'] },`);
+    console.log(`  i18now: { projectId: '${projectId}', apiKey: process.env.I18NOW_API_KEY },`);
+    console.log(`  (API key is in your .env file: ${maskApiKey(apiKey)})\n`);
+    process.exit(1);
+  }
+
+  // 9. Create test page
+  if (createTestPage()) {
+    console.log("  Created test page at /i18now-test");
   }
 
-  console.log('\n✅ Ready! Run: npm run dev\n')
+  // 10. Done
+  console.log(`\nDone! Start your dev server and visit /i18now-test:\n`);
+  console.log(`  ${devCommand(pm)}\n`);
 }
 
-main()
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "0.1.35",
+  "version": "0.1.36",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@uipkge/nuxt",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "i18now-nuxt": "./bin/cli.mjs"
+    "i18now-nuxt": "./bin/cli.mjs",
+    "uipkge-nuxt": "./bin/cli.mjs"
   },
   "exports": {
     ".": {
@@ -19,7 +20,8 @@
     "bin"
   ],
   "dependencies": {
-    "@nuxt/kit": "^3.0.0"
+    "@nuxt/kit": "^3.0.0",
+    "magicast": "^0.3.0"
   },
   "peerDependencies": {
     "vue-i18n": "^9.0.0 || ^10.0.0 || ^11.0.0",