@zntc/init 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { PACKAGE_MANAGERS, detectPackageManager, type FileAction, type FileChange, type PackageManager, type PlannedFile, } from './shared.ts';
+export { DEFAULT_RN_ENTRY, DEFAULT_RN_PLATFORM, createReactNativeConfig, initReactNativeProject, planReactNativeInit, type InitReactNativeOptions, type InitReactNativeResult, type ReactNativePlatform, } from './react-native.ts';
+export { createViteConfig, initViteProject, planViteInit, type InitViteOptions, type InitViteResult, } from './vite.ts';
+export { createRspackConfig, initRspackProject, planRspackInit, type InitRspackOptions, type InitRspackResult, type RspackBundler, } from './rspack.ts';
+export { WEB_FRAMEWORKS, initWebProject, planWebInit, type InitWebOptions, type InitWebResult, type WebFramework, } from './web.ts';

package/dist/index.js

@@ -0,0 +1,603 @@
+// src/shared.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var PACKAGE_MANAGERS = ["bun", "npm", "pnpm", "yarn"];
+var PACKAGE_JSON = "package.json";
+var ZNTC_CONFIG = "zntc.config.ts";
+var DEFAULT_ZNTC_VERSION = "latest";
+function readText(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+function formatJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function parsePackageJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`failed to parse ${PACKAGE_JSON}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function ensureObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function hasAnyDependency(pkg, names) {
+  const deps = ensureObject(pkg.dependencies);
+  const dev = ensureObject(pkg.devDependencies);
+  const peer = ensureObject(pkg.peerDependencies);
+  return names.some((name) => Boolean(deps[name] ?? dev[name] ?? peer[name]));
+}
+function addDevDependency(pkg, name, version) {
+  const deps = ensureObject(pkg.dependencies);
+  const dev = { ...ensureObject(pkg.devDependencies) };
+  if (deps[name] || dev[name])
+    return pkg;
+  dev[name] = version;
+  return { ...pkg, devDependencies: dev };
+}
+function toChange(file) {
+  if (file.manualInstructions && !file.changed) {
+    return { path: file.path, action: "manual", manualInstructions: file.manualInstructions };
+  }
+  if (!file.changed)
+    return { path: file.path, action: "unchanged" };
+  return { path: file.path, action: file.before === null ? "create" : "update" };
+}
+function detectPackageManager(root) {
+  if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb")))
+    return "bun";
+  if (existsSync(join(root, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (existsSync(join(root, "yarn.lock")))
+    return "yarn";
+  const rawPackageJson = readText(join(root, PACKAGE_JSON));
+  if (rawPackageJson) {
+    try {
+      const packageManager = JSON.parse(rawPackageJson).packageManager;
+      if (typeof packageManager === "string") {
+        for (const pm of PACKAGE_MANAGERS) {
+          if (packageManager.startsWith(`${pm}@`))
+            return pm;
+        }
+      }
+    } catch {}
+  }
+  return "npm";
+}
+function installCommand(pm) {
+  return `${pm} install`;
+}
+function applyPlan(opts) {
+  if (!opts.dryRun) {
+    for (const file of opts.planned) {
+      if (!file.changed)
+        continue;
+      mkdirSync(dirname(file.path), { recursive: true });
+      writeFileSync(file.path, file.after);
+    }
+  }
+  const pm = opts.packageManager ?? detectPackageManager(opts.root);
+  return {
+    root: opts.root,
+    changes: opts.planned.map(toChange),
+    dryRun: opts.dryRun,
+    installCommand: installCommand(pm)
+  };
+}
+function planOverlayConfig(opts) {
+  for (const name of opts.candidates) {
+    const path2 = join(opts.root, name);
+    const before = readText(path2);
+    if (before === null)
+      continue;
+    if (!opts.force) {
+      return {
+        path: path2,
+        before,
+        after: before,
+        changed: false,
+        manualInstructions: opts.manualInstructions
+      };
+    }
+    const after = opts.generate();
+    return { path: path2, before, after, changed: before !== after };
+  }
+  const path = join(opts.root, opts.defaultName);
+  return { path, before: null, after: opts.generate(), changed: true };
+}
+// src/react-native.ts
+import { join as join2, resolve } from "node:path";
+var DEFAULT_RN_ENTRY = "index.js";
+var DEFAULT_RN_PLATFORM = "ios";
+function bundleOut(platform) {
+  return platform === "ios" ? "--bundle-output ios/main.jsbundle --assets-dest ios" : "--bundle-output android/app/src/main/assets/index.android.bundle --assets-dest android/app/src/main/res";
+}
+function zntcBundleScript(platform) {
+  return `zntc --bundle ${DEFAULT_RN_ENTRY} --platform=react-native --rn-platform=${platform} --minify ${bundleOut(platform)}`;
+}
+function metroBundleScript(platform) {
+  return `react-native bundle --platform ${platform} --dev false --entry-file ${DEFAULT_RN_ENTRY} ${bundleOut(platform)}`;
+}
+function patchPackageJson(pkg, options) {
+  let next = addDevDependency(pkg, "@zntc/core", options.zntcVersion);
+  next = addDevDependency(next, "@zntc/react-native", options.zntcVersion);
+  const scripts = { ...ensureObject(next.scripts) };
+  const zntcStart = `zntc dev --platform=react-native --rn-platform=${options.defaultPlatform} ${DEFAULT_RN_ENTRY}`;
+  const previousStart = typeof scripts.start === "string" ? scripts.start : undefined;
+  if (options.metroFallback && previousStart && previousStart !== zntcStart) {
+    scripts["start:metro"] = scripts["start:metro"] ?? previousStart;
+  }
+  scripts.start = zntcStart;
+  scripts["start:zntc"] = scripts["start:zntc"] ?? zntcStart;
+  scripts["bundle:ios"] = scripts["bundle:ios"] ?? zntcBundleScript("ios");
+  scripts["bundle:android"] = scripts["bundle:android"] ?? zntcBundleScript("android");
+  if (options.metroFallback) {
+    scripts["bundle:metro:ios"] = scripts["bundle:metro:ios"] ?? metroBundleScript("ios");
+    scripts["bundle:metro:android"] = scripts["bundle:metro:android"] ?? metroBundleScript("android");
+  }
+  return { ...next, scripts };
+}
+function createReactNativeConfig() {
+  return `// ZNTC dev server + bundler config for React Native CLI.
+// Generated by @zntc/init.
+
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export default {
+  root: __dirname,
+  entry: "${DEFAULT_RN_ENTRY}",
+  dev: true,
+  minify: false,
+  transformer: {
+    babel: {},
+  },
+  serializer: {
+    polyfills: [],
+    prelude: [],
+  },
+  server: {
+    port: 8081,
+    host: "localhost",
+    useGlobalHotkey: true,
+    forwardClientLogs: true,
+  },
+};
+`;
+}
+function planPackageJson(root, options) {
+  const path = join2(root, PACKAGE_JSON);
+  const before = readText(path);
+  if (before === null) {
+    throw new Error(`package.json not found in ${root}`);
+  }
+  const pkg = parsePackageJson(before);
+  if (!hasAnyDependency(pkg, ["react-native"])) {
+    throw new Error("react-native dependency not found; use `zntc-init vite|rspack|web` for non-RN projects");
+  }
+  const after = formatJson(patchPackageJson(pkg, options));
+  return { path, before, after, changed: before !== after };
+}
+function planConfig(root, force) {
+  const path = join2(root, ZNTC_CONFIG);
+  const before = readText(path);
+  const after = before !== null && !force ? before : createReactNativeConfig();
+  return { path, before, after, changed: before !== after };
+}
+function planReactNativeInit(options = {}) {
+  const root = resolve(options.root ?? process.cwd());
+  const force = options.force ?? false;
+  const normalized = {
+    defaultPlatform: options.defaultPlatform ?? DEFAULT_RN_PLATFORM,
+    metroFallback: options.metroFallback ?? true,
+    zntcVersion: options.zntcVersion ?? DEFAULT_ZNTC_VERSION
+  };
+  if (normalized.defaultPlatform !== "ios" && normalized.defaultPlatform !== "android") {
+    throw new Error(`unsupported default platform: ${normalized.defaultPlatform}`);
+  }
+  return [planPackageJson(root, normalized), planConfig(root, force)];
+}
+function initReactNativeProject(options = {}) {
+  const root = resolve(options.root ?? process.cwd());
+  const planned = planReactNativeInit({ ...options, root });
+  return applyPlan({
+    root,
+    planned,
+    dryRun: options.dryRun ?? false,
+    packageManager: options.packageManager
+  });
+}
+// src/vite.ts
+import { join as join3, resolve as resolve2 } from "node:path";
+var VITE_CONFIG_CANDIDATES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+var DEFAULT_VITE_CONFIG = "vite.config.ts";
+function createViteConfig() {
+  return `// Generated by @zntc/init — replaces Vite의 esbuild transform 을 ZNTC 로.
+import { defineConfig } from 'vite';
+import { zntc } from '@zntc/vite-plugin';
+
+export default defineConfig({
+  plugins: [zntc()],
+  esbuild: false,
+});
+`;
+}
+function planPackageJson2(root, zntcVersion) {
+  const path = join3(root, PACKAGE_JSON);
+  const before = readText(path);
+  if (before === null) {
+    throw new Error(`package.json not found in ${root}`);
+  }
+  const pkg = parsePackageJson(before);
+  if (!hasAnyDependency(pkg, ["vite"])) {
+    throw new Error("vite dependency not found; install Vite first, or use `zntc-init web` for a standalone setup");
+  }
+  let next = addDevDependency(pkg, "@zntc/core", zntcVersion);
+  next = addDevDependency(next, "@zntc/vite-plugin", zntcVersion);
+  const after = formatJson(next);
+  return { path, before, after, changed: before !== after };
+}
+var MANUAL_PATCH = [
+  "Add ZNTC to your existing vite.config:",
+  "",
+  "  import { zntc } from '@zntc/vite-plugin';",
+  "",
+  "  export default defineConfig({",
+  "    plugins: [zntc()],   // 기존 plugins 배열에 합쳐 주세요",
+  "    esbuild: false,      // ZNTC 가 .ts/.tsx/.jsx 변환을 담당",
+  "  });",
+  "",
+  "Re-run with --force to overwrite the existing config instead."
+].join(`
+`);
+function planViteInit(options = {}) {
+  const root = resolve2(options.root ?? process.cwd());
+  const zntcVersion = options.zntcVersion ?? DEFAULT_ZNTC_VERSION;
+  const force = options.force ?? false;
+  return [
+    planPackageJson2(root, zntcVersion),
+    planOverlayConfig({
+      root,
+      candidates: VITE_CONFIG_CANDIDATES,
+      defaultName: DEFAULT_VITE_CONFIG,
+      generate: createViteConfig,
+      manualInstructions: MANUAL_PATCH,
+      force
+    })
+  ];
+}
+function initViteProject(options = {}) {
+  const root = resolve2(options.root ?? process.cwd());
+  const planned = planViteInit({ ...options, root });
+  return applyPlan({
+    root,
+    planned,
+    dryRun: options.dryRun ?? false,
+    packageManager: options.packageManager
+  });
+}
+// src/rspack.ts
+import { join as join4, resolve as resolve3 } from "node:path";
+var CONFIG_CANDIDATES = {
+  rspack: ["rspack.config.ts", "rspack.config.mts", "rspack.config.js", "rspack.config.mjs"],
+  webpack: ["webpack.config.ts", "webpack.config.mts", "webpack.config.js", "webpack.config.mjs"]
+};
+var DEFAULT_CONFIG_NAME = {
+  rspack: "rspack.config.mjs",
+  webpack: "webpack.config.mjs"
+};
+function createRspackConfig(bundler) {
+  const header = bundler === "rspack" ? "// Generated by @zntc/init — Rspack with @zntc/rspack-loader (replaces swc-loader / esbuild-loader)." : "// Generated by @zntc/init — Webpack 5 with @zntc/rspack-loader (replaces babel-loader / swc-loader).";
+  return `${header}
+export default {
+  module: {
+    rules: [
+      {
+        test: /\\.(?:tsx?|jsx?)$/,
+        exclude: /node_modules/,
+        loader: '@zntc/rspack-loader',
+        options: {
+          transpileOptions: { target: 'es2020', jsx: 'automatic' },
+        },
+      },
+    ],
+  },
+};
+`;
+}
+function detectBundler(pkg, hint) {
+  if (hint)
+    return hint;
+  if (hasAnyDependency(pkg, ["@rspack/core", "@rspack/cli"]))
+    return "rspack";
+  if (hasAnyDependency(pkg, ["webpack", "webpack-cli"]))
+    return "webpack";
+  throw new Error("@rspack/core or webpack dependency not found; install one of them first or pass --bundler");
+}
+function planPackageJson3(root, zntcVersion, hint) {
+  const path = join4(root, PACKAGE_JSON);
+  const before = readText(path);
+  if (before === null) {
+    throw new Error(`package.json not found in ${root}`);
+  }
+  const pkg = parsePackageJson(before);
+  const bundler = detectBundler(pkg, hint);
+  let next = addDevDependency(pkg, "@zntc/core", zntcVersion);
+  next = addDevDependency(next, "@zntc/rspack-loader", zntcVersion);
+  const after = formatJson(next);
+  return { plan: { path, before, after, changed: before !== after }, bundler };
+}
+function manualPatch(bundler) {
+  const product = bundler === "rspack" ? "rspack.config" : "webpack.config";
+  return [
+    `Add the ZNTC loader to your existing ${product}:`,
+    "",
+    "  module: {",
+    "    rules: [",
+    "      {",
+    "        test: /\\.(?:tsx?|jsx?)$/,",
+    "        exclude: /node_modules/,",
+    "        loader: '@zntc/rspack-loader',",
+    "        options: { transpileOptions: { target: 'es2020', jsx: 'automatic' } },",
+    "      },",
+    "    ],",
+    "  },",
+    "",
+    "Re-run with --force to overwrite the existing config instead."
+  ].join(`
+`);
+}
+function planRspackInit(options = {}) {
+  const root = resolve3(options.root ?? process.cwd());
+  const zntcVersion = options.zntcVersion ?? DEFAULT_ZNTC_VERSION;
+  const force = options.force ?? false;
+  const { plan: pkgPlan, bundler } = planPackageJson3(root, zntcVersion, options.bundler);
+  const configPlan = planOverlayConfig({
+    root,
+    candidates: CONFIG_CANDIDATES[bundler],
+    defaultName: DEFAULT_CONFIG_NAME[bundler],
+    generate: () => createRspackConfig(bundler),
+    manualInstructions: manualPatch(bundler),
+    force
+  });
+  return { files: [pkgPlan, configPlan], bundler };
+}
+function initRspackProject(options = {}) {
+  const root = resolve3(options.root ?? process.cwd());
+  const { files: planned, bundler } = planRspackInit({ ...options, root });
+  const applied = applyPlan({
+    root,
+    planned,
+    dryRun: options.dryRun ?? false,
+    packageManager: options.packageManager
+  });
+  return { ...applied, bundler };
+}
+// src/web.ts
+import { basename, join as join5, resolve as resolve4 } from "node:path";
+var WEB_FRAMEWORKS = ["react", "vanilla"];
+var REACT_DEPS = {
+  react: "^19.0.0",
+  "react-dom": "^19.0.0"
+};
+var REACT_DEV_DEPS = {
+  "@types/react": "^19.0.0",
+  "@types/react-dom": "^19.0.0",
+  typescript: "^5.6.0"
+};
+var VANILLA_DEV_DEPS = {
+  typescript: "^5.6.0"
+};
+function entryFile(framework) {
+  return framework === "react" ? "src/main.tsx" : "src/main.ts";
+}
+function projectName(root, name) {
+  return name ?? basename(root);
+}
+function createPackageJson(root, framework, options) {
+  const pkg = {
+    name: projectName(root, options.name),
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "zntc dev",
+      build: "zntc build",
+      preview: "zntc preview"
+    },
+    devDependencies: {
+      "@zntc/core": options.zntcVersion
+    }
+  };
+  if (framework === "react") {
+    pkg.dependencies = { ...REACT_DEPS };
+    pkg.devDependencies = { ...pkg.devDependencies, ...REACT_DEV_DEPS };
+  } else {
+    pkg.devDependencies = { ...pkg.devDependencies, ...VANILLA_DEV_DEPS };
+  }
+  return formatJson(pkg);
+}
+function createTsconfig(framework) {
+  const compilerOptions = {
+    target: "ES2022",
+    module: "ESNext",
+    moduleResolution: "Bundler",
+    lib: ["ES2022", "DOM", "DOM.Iterable"],
+    strict: true,
+    skipLibCheck: true,
+    noEmit: true,
+    isolatedModules: true,
+    esModuleInterop: true,
+    resolveJsonModule: true,
+    allowSyntheticDefaultImports: true
+  };
+  if (framework === "react")
+    compilerOptions.jsx = "react-jsx";
+  return formatJson({
+    compilerOptions,
+    include: ["src/**/*", "zntc.config.ts"]
+  });
+}
+function createZntcConfig(framework) {
+  const entry = entryFile(framework);
+  const compilerLine = framework === "react" ? `
+  // React 17+ automatic JSX runtime — @zntc/core 가 _jsx import 자동 삽입.` : "";
+  return `import { defineConfig } from "@zntc/core";
+
+export default defineConfig({
+  entryPoints: ["${entry}"],
+  outdir: "dist",
+  format: "esm",
+  platform: "browser",
+  target: "es2022",${framework === "react" ? `
+  jsx: "automatic",` : ""}
+  sourcemap: true,${compilerLine}
+});
+`;
+}
+function createIndexHtml(framework, name) {
+  const entry = `/${entryFile(framework)}`;
+  const body = framework === "react" ? `    <div id="root"></div>
+` : `    <div id="app"></div>
+`;
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${name}</title>
+  </head>
+  <body>
+${body}    <script type="module" src="${entry}"></script>
+  </body>
+</html>
+`;
+}
+function createReactEntry() {
+  return `import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+
+import { App } from "./App";
+
+const root = document.getElementById("root");
+if (!root) throw new Error("#root not found");
+
+createRoot(root).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);
+`;
+}
+function createReactApp() {
+  return `export function App() {
+  return (
+    <main>
+      <h1>ZNTC + React</h1>
+      <p>
+        Edit <code>src/App.tsx</code> and save — HMR will reflect changes instantly.
+      </p>
+    </main>
+  );
+}
+`;
+}
+function createVanillaEntry() {
+  return `const app = document.getElementById("app");
+if (!app) throw new Error("#app not found");
+
+app.innerHTML = \`
+  <main>
+    <h1>ZNTC web starter</h1>
+    <p>Edit <code>src/main.ts</code> and save — HMR will reflect changes instantly.</p>
+  </main>
+\`;
+`;
+}
+function scaffoldFiles(root, framework, zntcVersion, name) {
+  const files = [
+    { relPath: PACKAGE_JSON, content: createPackageJson(root, framework, { name, zntcVersion }) },
+    { relPath: "tsconfig.json", content: createTsconfig(framework) },
+    { relPath: "zntc.config.ts", content: createZntcConfig(framework) },
+    { relPath: "index.html", content: createIndexHtml(framework, projectName(root, name)) }
+  ];
+  if (framework === "react") {
+    files.push({ relPath: "src/main.tsx", content: createReactEntry() });
+    files.push({ relPath: "src/App.tsx", content: createReactApp() });
+  } else {
+    files.push({ relPath: "src/main.ts", content: createVanillaEntry() });
+  }
+  return files;
+}
+function planScaffoldFile(root, file, force) {
+  const path = join5(root, file.relPath);
+  const before = readText(path);
+  if (before === null)
+    return { path, before, after: file.content, changed: true };
+  if (force && before !== file.content) {
+    return { path, before, after: file.content, changed: true };
+  }
+  return { path, before, after: before, changed: false };
+}
+function planWebInit(options = {}) {
+  const root = resolve4(options.root ?? process.cwd());
+  const framework = options.framework ?? "react";
+  if (!WEB_FRAMEWORKS.includes(framework)) {
+    throw new Error(`unsupported framework: ${framework}`);
+  }
+  const force = options.force ?? false;
+  const zntcVersion = options.zntcVersion ?? DEFAULT_ZNTC_VERSION;
+  const files = scaffoldFiles(root, framework, zntcVersion, options.name);
+  const existingPkg = readText(join5(root, PACKAGE_JSON));
+  if (existingPkg !== null && !force) {
+    throw new Error(`package.json already exists in ${root}; re-run with --force to overwrite (this is a scaffold mode)`);
+  }
+  return { files: files.map((f) => planScaffoldFile(root, f, force)), framework };
+}
+function initWebProject(options = {}) {
+  const root = resolve4(options.root ?? process.cwd());
+  const { files: planned, framework } = planWebInit({ ...options, root });
+  const applied = applyPlan({
+    root,
+    planned,
+    dryRun: options.dryRun ?? false,
+    packageManager: options.packageManager
+  });
+  return { ...applied, framework };
+}
+export {
+  planWebInit,
+  planViteInit,
+  planRspackInit,
+  planReactNativeInit,
+  initWebProject,
+  initViteProject,
+  initRspackProject,
+  initReactNativeProject,
+  detectPackageManager,
+  createViteConfig,
+  createRspackConfig,
+  createReactNativeConfig,
+  WEB_FRAMEWORKS,
+  PACKAGE_MANAGERS,
+  DEFAULT_RN_PLATFORM,
+  DEFAULT_RN_ENTRY
+};

package/dist/react-native.d.ts

@@ -0,0 +1,22 @@
+import { type FileChange, type PackageManager, type PlannedFile } from './shared.ts';
+export type ReactNativePlatform = 'ios' | 'android';
+export interface InitReactNativeOptions {
+    root?: string;
+    defaultPlatform?: ReactNativePlatform;
+    dryRun?: boolean;
+    force?: boolean;
+    metroFallback?: boolean;
+    packageManager?: PackageManager;
+    zntcVersion?: string;
+}
+export interface InitReactNativeResult {
+    root: string;
+    changes: FileChange[];
+    dryRun: boolean;
+    installCommand: string;
+}
+export declare const DEFAULT_RN_ENTRY = "index.js";
+export declare const DEFAULT_RN_PLATFORM: ReactNativePlatform;
+export declare function createReactNativeConfig(): string;
+export declare function planReactNativeInit(options?: InitReactNativeOptions): PlannedFile[];
+export declare function initReactNativeProject(options?: InitReactNativeOptions): InitReactNativeResult;

package/dist/rspack.d.ts

@@ -0,0 +1,24 @@
+import { type FileChange, type PackageManager, type PlannedFile } from './shared.ts';
+export type RspackBundler = 'rspack' | 'webpack';
+export interface InitRspackOptions {
+    root?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    packageManager?: PackageManager;
+    zntcVersion?: string;
+    /** 강제로 bundler 종류를 지정 (default: package.json 으로 자동 추론) */
+    bundler?: RspackBundler;
+}
+export interface InitRspackResult {
+    root: string;
+    changes: FileChange[];
+    dryRun: boolean;
+    installCommand: string;
+    bundler: RspackBundler;
+}
+export declare function createRspackConfig(bundler: RspackBundler): string;
+export declare function planRspackInit(options?: InitRspackOptions): {
+    files: PlannedFile[];
+    bundler: RspackBundler;
+};
+export declare function initRspackProject(options?: InitRspackOptions): InitRspackResult;