@nutin/cli 2.1.0 → 3.0.0

package/templates/base/tools/builder/core/styles/tailwind.js.hbs

@@ -1,77 +1,37 @@
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import path from 'path';
-import { print, runCommand, promptBoolean, errorExit } from '../../../utils/index.js';
+import { ensureDeps, errorExit } from '../../../utils/index.js';
 import { PATHS } from '../app/paths.js';
 import { builderConfig } from '../../builder.config.js';
 
-const REQUIRED_DEPS = [
-  { name: 'tailwindcss', version: '^4.3.0' },
-  { name: '@tailwindcss/cli', version: '^4.3.0' },
-];
-
-const isInstalled = (depName) => fs.existsSync(path.join(process.cwd(), 'node_modules', depName, 'package.json'));
-
-const getPackageManager = () => {
-  if (fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml'))) return 'pnpm';
-  if (fs.existsSync(path.join(process.cwd(), 'yarn.lock'))) return 'yarn';
-  if (fs.existsSync(path.join(process.cwd(), 'bun.lock')) || fs.existsSync(path.join(process.cwd(), 'bun.lockb'))) return 'bun';
-  return 'npm';
-};
-
-const getInstallCommand = (packageManager, deps) => {
-  const pkgList = deps.map(dep => `${dep.name}@${dep.version}`).join(' ');
-  switch (packageManager) {
-    case 'yarn': return `yarn add -D ${pkgList}`;
-    case 'pnpm': return `pnpm add -D ${pkgList}`;
-    case 'bun': return `bun add -D ${pkgList}`;
-    default: return `npm install -D ${pkgList}`;
-  }
-};
-
-const missingDeps = REQUIRED_DEPS.filter(dep => !isInstalled(dep.name));
-
-if (missingDeps.length) {
-  if (builderConfig.isProd) {
-    errorExit('Tailwind CSS is enabled (tailwind: true) but its dependencies are missing.\nRun "npm install" before rebuilding');
-  }
-  const packageManager = getPackageManager();
-  const installCommand = getInstallCommand(packageManager, missingDeps);
-
-  print.warn('Tailwind CSS is enabled (tailwind: true) but its dependencies are missing.');
-  print.gray('Required packages:');
-  missingDeps.forEach(dep => print.gray(`  - ${dep.name}@${dep.version}`));
-
-  let shouldInstall = true;
-  if (process.stdin.isTTY) {
-    shouldInstall = await promptBoolean('Install them now?');
-  } else {
-    print.gray(`Non-interactive shell detected. Installing automatically: ${installCommand}`);
-  }
-
-  if (!shouldInstall) {
-    print.boldError(`Aborting. Run manually: ${installCommand}`);
-    process.exit(1);
-  }
-
-  const [command, ...args] = installCommand.split(' ');
-  try {
-    await runCommand(command, args);
-  } catch (err) {
-    errorExit(err, 'tailwind-install');
-  }
+await ensureDeps({
+  feature: 'Tailwind CSS (tailwind: true)',
+  deps: [
+    { name: 'tailwindcss', version: '^4.3.0' },
+    { name: '@tailwindcss/cli', version: '^4.3.0' },
+  ],
+  isProd: builderConfig.isProd,
+  origin: 'tailwind',
+});
+
+// Run the CLI's JS entry with node rather than node_modules/.bin/tailwindcss, which is a
+// .cmd shim on Windows that execFileSync can't launch without a shell.
+function tailwindEntry() {
+  const cliDir = path.join(process.cwd(), 'node_modules', '@tailwindcss', 'cli');
+  const { bin } = JSON.parse(fs.readFileSync(path.join(cliDir, 'package.json'), 'utf-8'));
+  return path.join(cliDir, typeof bin === 'string' ? bin : bin.tailwindcss);
 }
 
-const twBin = path.join(process.cwd(), 'node_modules', '.bin', 'tailwindcss');
 const input = path.join(PATHS.source, 'styles', 'tailwind.css');
 const output = path.join(PATHS.tempSource, 'tw-out.css');
 const mainCss = path.join(PATHS.tempSource, 'main.css');
 
-const args = ['-i', input, '-o', output, '--silent'];
+const args = [tailwindEntry(), '-i', input, '-o', output, '--silent'];
 if (builderConfig.isProd) args.push('--minify');
 
 try {
-  execFileSync(twBin, args, { stdio: 'inherit' });
+  execFileSync(process.execPath, args, { stdio: 'inherit' });
 } catch (err) {
   errorExit(err, 'tailwind');
 }

package/templates/base/tools/dev/dev-serve.js.hbs

@@ -1,12 +1,22 @@
 #!/usr/bin/env node
 
-import { spawn } from 'child_process';
-import { print, runCommand } from '../utils/index.js';
+import { spawn, spawnSync } from 'child_process';
+import { print, resolvePort, runCommand } from '../utils/index.js';
+
+const isWindows = process.platform === 'win32';
 
 async function startDev() {
   console.clear();
   print.blue('🚀 Starting Dev Environment...\n');
 
+  let port;
+  try {
+    port = resolvePort();
+  } catch (err) {
+    print.boldError(err.message);
+    process.exit(1);
+  }
+
   try {
     await runCommand('{{packageManager}}', ['run', 'build', '--silent']);
   } catch (err) {
@@ -14,22 +24,76 @@ async function startDev() {
     process.exit(1);
   }
 
-  const serve = spawn(['{{packageManager}}', 'run', 'serve:only', '--silent'].join(' '), { stdio: 'inherit', shell: true });
-  const watcher = spawn(['node', 'tools/dev/watcher.js', '--silent'].join(' '), { stdio: 'inherit', shell: true });
+  // detached: true makes each child the leader of its own process group, so its
+  // descendants (watcher.js's own `exec('{{packageManager}} run build')` included) can be
+  // killed as a group below. Without this, a shutdown that doesn't cleanly propagate
+  // SIGINT down the shell layers (backgrounded, launched by a task runner, a closed
+  // terminal tab instead of Ctrl-C, ...) leaves them running as orphans — multiple
+  // stray watcher.js processes then race each other's builds.
+  // Not on Windows: there, detached children leave the console, so Ctrl-C would no
+  // longer reach them, and negative-pid group kills aren't supported — taskkill /T
+  // walks the process tree instead.
+  // Hand serve.js the already-resolved port via PORT; npm_config_port is dropped so it
+  // can't take precedence over it in the child.
+  const { npm_config_port, ...serveEnv } = process.env;
+  serveEnv.PORT = String(port);
+  // Both run node directly (no shell/npm layer) with an IPC channel, used as a relay:
+  // serve.js reports the URL it listens on (watcher.js reprints it after every rebuild),
+  // and watcher.js reports each successful rebuild (serve.js reloads open pages).
+  const stdio = ['inherit', 'inherit', 'inherit', 'ipc'];
+  const serve = spawn(process.execPath, ['tools/dev/serve.js'], { stdio, detached: !isWindows, env: serveEnv });
+  const watcher = spawn(process.execPath, ['tools/dev/watcher.js'], { stdio, detached: !isWindows });
+
+  serve.on('message', (msg) => {
+    if (msg?.type === 'server-url' && watcher.connected) watcher.send(msg);
+  });
+  watcher.on('message', (msg) => {
+    if (msg?.type === 'reload' && serve.connected) serve.send(msg);
+  });
+
+  const children = [serve, watcher];
+  let shuttingDown = false;
+
+  function killGroup(child, signal) {
+    if (!child.pid) return;
+    if (isWindows) {
+      spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
+      return;
+    }
+    try {
+      process.kill(-child.pid, signal);
+    } catch {
+      // group already gone
+    }
+  }
+
+  function shutdown(signal, exitCode = 0) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    children.forEach((child) => killGroup(child, signal));
+    process.exit(exitCode);
+  }
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  // Closing the terminal tab/window sends SIGHUP; the detached children don't get it.
+  process.on('SIGHUP', () => shutdown('SIGTERM'));
 
   serve.on('error', (err) => {
-    print.boldError(`live-server failed to start: ${err.message}`);
+    print.boldError(`dev server failed to start: ${err.message}`);
     process.exit(1);
   });
   serve.on('close', (code) => {
-    print.error(`live-server exited with code ${code}`);
-    process.exit(code ?? 1);
+    if (shuttingDown) return;
+    print.error(`dev server exited with code ${code}`);
+    shutdown('SIGTERM', code ?? 1);
   });
   watcher.on('error', (err) => {
     print.boldError(`watcher failed to start: ${err.message}`);
     process.exit(1);
   });
   watcher.on('close', (code) => {
+    if (shuttingDown) return;
     print.error(`watcher exited with code ${code}`);
   });
 }

package/templates/base/tools/dev/serve.js.hbs

@@ -1,33 +1,163 @@
 #!/usr/bin/env node
 
-import liveServer from 'live-server';
-import { print } from '../utils/index.js';
-
-const params = {
-  port: 9090,
-  root: 'dist/src',
-  open: false, // set to true to open a new window in browser
-  logLevel: 0, // 0 = errors only, 1 = some info, 2 = verbose
-  entryFile: 'index.html',
-  wait: 100, // debounce reloads
-  middleware: [
-    function(req, res, next) {
-      if (req.url.includes('.') && !req.url.endsWith('/')) {
-        return next();
-      }
-      req.url = '/index.html';
-      next();
-    }
-  ]
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { print, resolvePort } from '../utils/index.js';
+
+const ROOT = path.resolve('dist', 'src');
+const RELOAD_EVENTS = '/__nutin/reload';
+const RELOAD_SCRIPT = '/__nutin/reload.js';
+const RELOAD_TAG = `<script src="${RELOAD_SCRIPT}"></script>`;
+// External rather than inline, so a page CSP without 'unsafe-inline' doesn't block it.
+const RELOAD_CLIENT = `new EventSource('${RELOAD_EVENTS}').addEventListener('reload', () => location.reload());\n`;
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.txt': 'text/plain; charset=utf-8',
+  '.xml': 'application/xml; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.pdf': 'application/pdf',
 };
 
+let port;
 try {
-  liveServer.start(params);
+  port = resolvePort(); // --port <n> or PORT env, defaults to 9090
 } catch (err) {
+  print.boldError(err.message);
+  process.exit(1);
+}
+
+// Live reload only when started by dev-serve.js (IPC channel present): watcher.js
+// reports each successful rebuild, relayed here as { type: 'reload' }.
+const liveReload = Boolean(process.send);
+const reloadClients = new Set();
+
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// Exact file, then a directory's index.html (prerendered SEO pages), else nothing.
+function resolveFile(pathname) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  const candidate = path.join(ROOT, decoded);
+  if (candidate !== ROOT && !candidate.startsWith(ROOT + path.sep)) return null;
+  if (isFile(candidate)) return candidate;
+  const index = path.join(candidate, 'index.html');
+  return isFile(index) ? index : null;
+}
+
+// Browsers send Accept: text/html for page navigations — those get the SPA shell when no
+// file matches (whatever the URL looks like, dots included); a missing asset gets a 404.
+function wantsHtml(req) {
+  return (req.headers.accept ?? '').includes('text/html');
+}
+
+function send(res, status, body, headers = {}) {
+  res.writeHead(status, { 'Cache-Control': 'no-store', ...headers });
+  res.end(body);
+}
+
+function serveFile(req, res, filePath) {
+  const type = MIME_TYPES[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+  let body = fs.readFileSync(filePath);
+
+  if (liveReload && type.startsWith('text/html')) {
+    const html = body.toString('utf-8');
+    body = html.includes('</body>') ? html.replace('</body>', () => `${RELOAD_TAG}</body>`) : html + RELOAD_TAG;
+  }
+
+  send(res, 200, req.method === 'HEAD' ? undefined : body, { 'Content-Type': type });
+}
+
+function openReloadStream(req, res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-store',
+    Connection: 'keep-alive',
+  });
+  res.write(': connected\n\n');
+  reloadClients.add(res);
+  req.on('close', () => reloadClients.delete(res));
+}
+
+const server = http.createServer((req, res) => {
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    return send(res, 405, 'Method Not Allowed', { Allow: 'GET, HEAD' });
+  }
+
+  const { pathname } = new URL(req.url, 'http://localhost');
+
+  if (liveReload && pathname === RELOAD_EVENTS) return openReloadStream(req, res);
+  if (liveReload && pathname === RELOAD_SCRIPT) {
+    return send(res, 200, RELOAD_CLIENT, { 'Content-Type': MIME_TYPES['.js'] });
+  }
+
+  const filePath = resolveFile(pathname) ?? (wantsHtml(req) ? resolveFile('/index.html') : null);
+  if (!filePath) return send(res, 404, 'Not Found', { 'Content-Type': MIME_TYPES['.txt'] });
+
+  serveFile(req, res, filePath);
+});
+
+server.on('error', (err) => {
   if (err.code === 'EADDRINUSE') {
-    print.boldError(`Port ${params.port} is already in use — stop the process using it or change the dev port.`);
+    print.boldError(`Port ${port} is already in use. Pass another one with --port <n> (or PORT=<n>).`);
   } else {
-    print.boldError(`live-server failed to start: ${err.message}`);
+    print.boldError(`Dev server failed to start: ${err.message}`);
   }
   process.exit(1);
+});
+
+// Loopback only, like the URL printed below: the dev server isn't exposed to the network.
+server.listen(port, '127.0.0.1', () => {
+  const url = `http://127.0.0.1:${port}`;
+  print.boldInfo(`Serving at ${url}`);
+  // Started by dev-serve.js: report the URL so watcher.js can reprint it after rebuilds.
+  if (process.send) process.send({ type: 'server-url', url });
+});
+
+if (liveReload) {
+  process.on('message', (msg) => {
+    if (msg?.type !== 'reload') return;
+    for (const client of reloadClients) client.write('event: reload\ndata: {}\n\n');
+  });
+
+  // Keeps idle event streams from being closed by proxies/browsers.
+  setInterval(() => {
+    for (const client of reloadClients) client.write(': ping\n\n');
+  }, 30_000).unref();
+
+  // Started by dev-serve.js: exit with it even if it dies without cleaning up (kill -9, crash).
+  process.on('disconnect', () => process.exit(0));
 }

package/templates/base/tools/dev/watcher.js.hbs

@@ -2,49 +2,96 @@ import chokidar from 'chokidar';
 import { exec } from 'child_process';
 import path from 'path';
 import { print } from '../utils/index.js'
+{{#if markdown}}
+import nutinConfig from '../../nutin.config.js';
+{{/if}}
 
-const watcher = chokidar.watch(['src'], {
+// config/, nutin.config.js and public/ are copied into the build too.
+const watcher = chokidar.watch(['src', 'config', 'public', 'nutin.config.js'], {
   ignored: /(^|[/\\])\../,
   persistent: true,
+  ignoreInitial: true,
 });
+{{#if markdown}}
+
+// Markdown folders live outside src/ but still feed the build.
+watcher.add(
+  (nutinConfig.markdownSources?.sourceFolders ?? [])
+    .map((entry) => (typeof entry === 'string' ? entry : entry?.folder))
+    .filter(Boolean)
+);
+{{/if}}
 
 let isBuilding = false;
+let pendingRebuild = false;
 let buildTimeout = null;
+let lastChangedPath = null;
+let serverUrl = null;
+
+function printWatching() {
+  if (serverUrl) print.boldInfo(`Serving at ${serverUrl}`);
+  print.boldBlue('Watching for changes...');
+}
+
+// Sent by dev-serve.js (relayed from serve.js) once the server is listening.
+process.on('message', (msg) => {
+  if (msg?.type === 'server-url') serverUrl = msg.url;
+});
+// Exit with dev-serve.js even if it dies without cleaning up (kill -9, crash).
+if (process.send) process.on('disconnect', () => process.exit(0));
+
+function runBuild() {
+  isBuilding = true;
+  pendingRebuild = false;
+
+  console.clear();
+  print.boldInfo(`\n🔄 File changed: ${path.relative(process.cwd(), lastChangedPath)}\n`);
+  print.info('\nRebuilding...');
+
+  const command = '{{packageManager}} run build --silent';
+
+  exec(command, { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+    if (err) {
+      if (err.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+        print.boldError(`\nBuild output exceeded the buffer size — raise maxBuffer in tools/dev/watcher.js.`);
+      } else {
+        print.boldError(`\nBuild failed: ${err.message}`);
+      }
+    } else {
+      printWatching();
+      // Relayed by dev-serve.js to serve.js, which tells open pages to reload.
+      if (process.send && process.connected) process.send({ type: 'reload' });
+    }
+    isBuilding = false;
+
+    // A change arrived while this build was running — it was never picked up by
+    // any debounce timer (isBuilding used to make those just silently return,
+    // dropping the change for good), so build again now instead of missing it.
+    if (pendingRebuild) runBuild();
+  });
+}
 
 watcher.on('error', (err) => {
   print.boldError(`\nWatcher error: ${err.message}`);
 });
 
-watcher.on('change', (filePath) => {
+// New files (e.g. from `{{packageManager}} run generate`) and deletions need a rebuild too.
+watcher.on('all', (event, filePath) => {
+  if (!['add', 'change', 'unlink'].includes(event)) return;
+  lastChangedPath = filePath;
+
+  if (isBuilding) {
+    pendingRebuild = true;
+    return;
+  }
+
   if (buildTimeout) {
     clearTimeout(buildTimeout);
   }
-  
-  buildTimeout = setTimeout(() => {
-    if (isBuilding) return;
-    isBuilding = true;
-
-    console.clear();
-    print.boldInfo(`\n🔄 File changed: ${path.relative(process.cwd(), filePath)}\n`);
-    print.info('\nRebuilding...');
-
-    const command = '{{packageManager}} run build --silent';
-
-    exec(command, { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
-      if (stdout) process.stdout.write(stdout);
-      if (stderr) process.stderr.write(stderr);
-      if (err) {
-        if (err.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
-          print.boldError(`\nBuild output exceeded the buffer size — raise maxBuffer in tools/dev/watcher.js.`);
-        } else {
-          print.boldError(`\nBuild failed: ${err.message}`);
-        }
-      } else {
-        print.boldBlue('Watching for changes...');
-      }
-      isBuilding = false;
-    });
-  }, 100);
+
+  buildTimeout = setTimeout(runBuild, 100);
 });
 
 watcher.on('ready', () => {

package/templates/base/tools/generator/generator.js.hbs

@@ -1,24 +1,12 @@
 #!/usr/bin/env node
 
 import path from "path";
-import { allFormats, getLastWord, print, promptBoolean, errorExit } from "../utils/index.js";
-import { generateFile, appendToIndex, generateLocalesJson } from "./handle-file.js";
+import { allFormats, getLastWord, print, errorExit } from "../utils/index.js";
+import fs from "fs";
+import { generateFile, generateLocalesJson } from "./handle-file.js";
 import { serviceTemplate, componentTemplate, viewTemplate, htmlTemplate, scssTemplate, testTemplate } from "./templates/index.js";
 import nutinConfig from "../../nutin.config.js";
 
-// Constants and Setup
-const [, , rawType, rawFullPath] = process.argv;
-
-if (!rawType || !rawFullPath) {
-  showUsageAndExit("Missing arguments.");
-  process.exit(1);
-}
-
-const type = allFormats(rawType);
-const fullPath = allFormats(rawFullPath);
-const name = allFormats(getLastWord(fullPath.kebab));
-const targetPath = path.join('src', 'app', `${type.kebab}s/${fullPath.kebab}`);
-
 // Creator Mapping
 const creators = {
   service: async (name, targetPath) => {
@@ -26,7 +14,6 @@ const creators = {
     print.section(`Generating service: ${name.capitalized}`);
     try {
       generateFile({ name, targetPath, templateFn: serviceTemplate, suffix: suffix });
-      appendToIndex({ name, targetPath, suffix: suffix });
       await generateTest({ name, targetPath, suffix: suffix });
     } catch (err) {
       handleError("Failed to generate service", err);
@@ -41,7 +28,6 @@ const creators = {
       generateFile({ name, targetPath, templateFn: htmlTemplate, suffix: suffix, extension: 'html' });
       generateFile({ name, targetPath, templateFn: scssTemplate, suffix: suffix, extension: 'scss' });
       await generateLocales({ targetPath, name, isView: false });
-      appendToIndex({ name, targetPath, suffix: suffix });
       await generateTest({ name, targetPath, suffix });
     } catch (err) {
       handleError("Failed to generate component", err);
@@ -56,7 +42,6 @@ const creators = {
       generateFile({ name, targetPath, templateFn: htmlTemplate, suffix: suffix, extension: 'html' });
       generateFile({ name, targetPath, templateFn: scssTemplate, suffix: suffix, extension: 'scss' });
       await generateLocales({ targetPath, name, isView: true });
-      appendToIndex({ name, targetPath, suffix: suffix });
       await generateTest({ name, targetPath, suffix });
     } catch (err) {
       handleError("Failed to generate view", err);
@@ -64,10 +49,30 @@ const creators = {
   },
 };
 
+// Constants and Setup
+const [, , rawType, rawFullPath] = process.argv;
+
+if (!rawType || !rawFullPath) {
+  showUsageAndExit("Missing arguments.");
+  process.exit(1);
+}
+
+const type = allFormats(rawType);
+const fullPath = allFormats(rawFullPath);
+const name = allFormats(getLastWord(fullPath.kebab));
+const targetPath = path.join('src', 'app', fullPath.kebab);
+
 // Main Execution
 const create = creators[type.kebab];
 
 if (create) {
+  // Folder names carry no type suffix, so a view and a component with the same path would
+  // share one folder (and clobber each other's locales/) — refuse before writing anything.
+  if (fs.existsSync(targetPath) && fs.readdirSync(targetPath).length > 0) {
+    print.boldError(`\nA folder with this name already exists: ${targetPath}`);
+    print.warn("Pick another path, e.g. user/user-view and user/user-card.");
+    process.exit(1);
+  }
   await create(name, targetPath);
   print.boldSuccess(`\n${type.capitalized} ${name.capitalized} generated in ${targetPath}.\n`)
 } else {

package/templates/base/tools/generator/handle-file.js.hbs

@@ -1,6 +1,7 @@
 import fs from 'fs';
-import path from 'path';
-import { print, LANGUAGES } from '../utils/index.js';
+import { print } from '../utils/index.js';
+// Imported directly, not via the utils barrel: it reads config/languages.json on load.
+import { LANGUAGES } from '../utils/languages.js';
 import { localeTemplate } from './templates/index.js';
 
 export function generateFile({
@@ -8,7 +9,7 @@ export function generateFile({
   targetPath,
   templateFn,
   suffix,
-  extension = 'ts',
+  extension = '{{#if (eq lang "js")}}js{{else}}ts{{/if}}',
 }) {
   fs.mkdirSync(targetPath, { recursive: true });
   const template = templateFn(name, targetPath, suffix);
@@ -22,27 +23,6 @@ export function generateFile({
   fs.writeFileSync(filePath, template);
 }
 
-export function appendToIndex({ name, targetPath, suffix }) {
-  const absTargetPath = path.resolve(process.cwd(), targetPath);
-
-  const parts = targetPath.split(path.sep);
-  const basePath = parts.slice(0, 3).join(path.sep);
-
-  const indexFilePath = path.join(basePath, 'index.ts');
-
-  const absFilePath = path.join(absTargetPath, `${name.kebab}.${suffix}.js`);
-  const relPath = path.relative(basePath, absFilePath).replace(/\\/g, '/');
-
-  const lineToAppend = `export * from './${relPath}';\n`;
-
-  try {
-    fs.appendFileSync(indexFilePath, lineToAppend, 'utf8');
-    print.gray(`${suffix}s/index.ts updated.`);
-  } catch (err) {
-    throw new Error(`Failed to update ${indexFilePath}: ${err.message}`, { cause: err });
-  }
-}
-
 export function generateLocalesJson({ targetPath, name, isView }) {
   const localesDir = `${targetPath}/locales`;
   fs.mkdirSync(localesDir, { recursive: true });