@weapp-core/init 2.1.5 → 3.0.0

package/dist/index.js

@@ -1,9 +1,8 @@
 // src/index.ts
 import process2 from "process";
-import { fileURLToPath } from "url";
+
+// src/configFiles.ts
 import logger from "@weapp-core/logger";
-import { defu, get, set } from "@weapp-core/shared";
-import fs from "fs-extra";
 
 // ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 var _lazyMatch = () => {
@@ -423,119 +422,35 @@ var mix = (del = delimiter) => {
 var posix = /* @__PURE__ */ mix(":");
 var win32 = /* @__PURE__ */ mix(";");
 
-// ../../packages/weapp-vite/package.json
-var version = "5.1.8";
-
 // src/context.ts
 function createContext() {
   return {
-    projectConfig: {
-      name: "",
-      path: "",
-      value: {}
-    },
-    packageJson: {
-      name: "",
-      path: "",
-      value: {}
-    },
-    viteConfig: {
-      name: "",
-      path: "",
-      value: ""
-    },
-    tsconfig: {
-      name: "",
-      path: "",
-      value: {}
-    },
-    tsconfigNode: {
-      name: "",
-      path: "",
-      value: {}
-    },
-    dts: {
-      name: "",
-      path: "",
-      value: ""
-    }
+    projectConfig: createDocument(),
+    packageJson: createDocument(),
+    viteConfig: createDocument(),
+    tsconfig: createDocument(),
+    tsconfigNode: createDocument(),
+    dts: createDocument()
   };
 }
-
-// src/enums.ts
-var TemplateName = /* @__PURE__ */ ((TemplateName2) => {
-  TemplateName2["default"] = "default";
-  TemplateName2["tailwindcss"] = "tailwindcss";
-  TemplateName2["vant"] = "vant";
-  TemplateName2["tdesign"] = "tdesign";
-  return TemplateName2;
-})(TemplateName || {});
-
-// src/gitignore.ts
-function getDefaultGitignore() {
-  return `# dependencies
-node_modules
-.pnp
-.pnp.js
-
-# testing
-coverage
-
-# next.js
-.next/
-out/
-build
-
-# misc
-.DS_Store
-*.pem
-
-# debug
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-.pnpm-debug.log*
-
-# local env files
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# turbo
-.turbo
-
-dist
-dist-plugin
-vite.config.ts.timestamp-*.mjs`;
+function createDocument() {
+  return {
+    name: "",
+    path: "",
+    value: null
+  };
 }
 
-// src/npm.ts
-import https from "https";
-function getLatestVersionFromNpm(packageName) {
-  return new Promise((resolve2, reject) => {
-    const url = `https://registry.npmjs.org/${packageName}/latest`;
-    https.get(url, (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        try {
-          const json = JSON.parse(data);
-          resolve2(json.version);
-        } catch (err) {
-          reject(err);
-        }
-      });
-    }).on("error", reject);
-  });
-}
-async function latestVersion(packageName, prefix = "^") {
-  let version2 = "latest";
-  try {
-    version2 = `${prefix}${await getLatestVersionFromNpm(packageName)}`;
-  } catch {
-  }
-  return version2;
+// src/state.ts
+var ctx = createContext();
+function resetContext() {
+  const next = createContext();
+  Object.assign(ctx.projectConfig, next.projectConfig);
+  Object.assign(ctx.packageJson, next.packageJson);
+  Object.assign(ctx.viteConfig, next.viteConfig);
+  Object.assign(ctx.tsconfig, next.tsconfig);
+  Object.assign(ctx.tsconfigNode, next.tsconfigNode);
+  Object.assign(ctx.dts, next.dts);
 }
 
 // src/tsconfigJson.ts
@@ -608,6 +523,69 @@ function getDefaultTsDts() {
 `;
 }
 
+// src/utils/fs.ts
+import fs from "fs-extra";
+async function readJsonIfExists(filepath) {
+  try {
+    if (!await fs.pathExists(filepath)) {
+      return null;
+    }
+    return await fs.readJSON(filepath);
+  } catch (error) {
+    throw new FsReadError(filepath, error);
+  }
+}
+async function readFileIfExists(filepath) {
+  try {
+    if (!await fs.pathExists(filepath)) {
+      return null;
+    }
+    return await fs.readFile(filepath, "utf8");
+  } catch (error) {
+    throw new FsReadError(filepath, error);
+  }
+}
+async function writeJsonFile(filepath, data, spaces = 2) {
+  try {
+    await fs.outputJSON(filepath, data, {
+      spaces
+    });
+  } catch (error) {
+    throw new FsWriteError(filepath, error);
+  }
+}
+async function writeFile(filepath, contents) {
+  try {
+    await fs.outputFile(filepath, contents, "utf8");
+  } catch (error) {
+    throw new FsWriteError(filepath, error);
+  }
+}
+var FsReadError = class extends Error {
+  constructor(filepath, cause) {
+    super(`Failed to read ${filepath}`);
+    this.filepath = filepath;
+    this.cause = cause;
+    this.name = "FsReadError";
+  }
+};
+var FsWriteError = class extends Error {
+  constructor(filepath, cause) {
+    super(`Failed to write ${filepath}`);
+    this.filepath = filepath;
+    this.cause = cause;
+    this.name = "FsWriteError";
+  }
+};
+
+// src/utils/path.ts
+function resolveOutputPath(root, dest, fallback) {
+  if (!dest) {
+    return fallback;
+  }
+  return posix.isAbsolute(dest) ? dest : posix.resolve(root, dest);
+}
+
 // src/viteConfig.ts
 function getDefaultViteConfig() {
   return `import { defineConfig } from 'weapp-vite/config'
@@ -620,104 +598,277 @@ export default defineConfig({
 `;
 }
 
-// src/index.ts
-var __dirname2 = posix.dirname(fileURLToPath(import.meta.url));
-var ctx = createContext();
-async function createOrUpdateProjectConfig(options) {
-  const { root, dest, cb, write, filename } = defu(
-    options,
-    {
-      write: true,
-      filename: "project.config.json"
-    }
-  );
-  const projectConfigFilename = ctx.projectConfig.name = filename;
-  const projectConfigPath = ctx.projectConfig.path = posix.resolve(root, projectConfigFilename);
-  if (await fs.exists(projectConfigPath)) {
-    try {
-      const projectConfig = await fs.readJSON(projectConfigPath);
-      set(projectConfig, "miniprogramRoot", "dist/");
-      set(projectConfig, "srcMiniprogramRoot", "dist/");
-      set(projectConfig, "setting.packNpmManually", true);
-      const compileType = get(projectConfig, "compileType");
-      if (compileType === "plugin") {
-        set(projectConfig, "pluginRoot", "dist-plugin");
+// src/configFiles.ts
+async function initViteConfigFile(options) {
+  const { root, dest, write = true } = options;
+  const packageType = ctx.packageJson.value?.type ?? "module";
+  const targetFilename = ctx.viteConfig.name = packageType === "module" ? "vite.config.ts" : "vite.config.mts";
+  const viteConfigFilePath = ctx.viteConfig.path = posix.resolve(root, targetFilename);
+  const outputPath = resolveOutputPath(root, dest, viteConfigFilePath);
+  const code = getDefaultViteConfig();
+  ctx.viteConfig.value = code;
+  if (write) {
+    await writeFile(outputPath, code);
+    logger.log(`\u2728 \u5199\u5165 ${posix.relative(root, outputPath)} \u6210\u529F!`);
+  }
+  return code;
+}
+async function initTsDtsFile(options) {
+  const { root, dest, write = true } = options;
+  const targetFilename = ctx.dts.name = "vite-env.d.ts";
+  const viteDtsFilePath = ctx.dts.path = posix.resolve(root, targetFilename);
+  const outputPath = resolveOutputPath(root, dest, viteDtsFilePath);
+  const code = getDefaultTsDts();
+  ctx.dts.value = code;
+  if (write) {
+    await writeFile(outputPath, code);
+    logger.log(`\u2728 \u5199\u5165 ${posix.relative(root, outputPath)} \u6210\u529F!`);
+  }
+  return code;
+}
+async function initTsJsonFiles(options) {
+  const { root, dest, write = true } = options;
+  const tsJsonFilename = ctx.tsconfig.name = "tsconfig.json";
+  const tsJsonFilePath = ctx.tsconfig.path = posix.resolve(root, tsJsonFilename);
+  const tsNodeJsonFilename = ctx.tsconfigNode.name = "tsconfig.node.json";
+  const tsNodeJsonFilePath = ctx.tsconfigNode.path = posix.resolve(root, tsNodeJsonFilename);
+  const tsconfig = getDefaultTsconfigJson();
+  const includeFiles = ctx.viteConfig.name ? [ctx.viteConfig.name] : [];
+  const tsconfigNode = getDefaultTsconfigNodeJson(includeFiles);
+  ctx.tsconfig.value = tsconfig;
+  ctx.tsconfigNode.value = tsconfigNode;
+  if (write) {
+    const tsconfigOutputPath = resolveOutputPath(root, dest, tsJsonFilePath);
+    const tsconfigNodeOutputPath = tsNodeJsonFilePath;
+    await writeJsonFile(tsconfigOutputPath, tsconfig);
+    await writeJsonFile(tsconfigNodeOutputPath, tsconfigNode);
+    logger.log(`\u2728 \u5199\u5165 ${posix.relative(root, tsconfigOutputPath)} \u4E0E ${posix.relative(root, tsconfigNodeOutputPath)} \u6210\u529F!`);
+  }
+  return {
+    tsconfig,
+    tsconfigNode
+  };
+}
+
+// src/createProject.ts
+import { fileURLToPath } from "url";
+import logger3 from "@weapp-core/logger";
+import fs2 from "fs-extra";
+
+// ../../packages/weapp-vite/package.json
+var version = "5.2.0";
+
+// src/enums.ts
+var TemplateName = /* @__PURE__ */ ((TemplateName2) => {
+  TemplateName2["default"] = "default";
+  TemplateName2["tailwindcss"] = "tailwindcss";
+  TemplateName2["vant"] = "vant";
+  TemplateName2["tdesign"] = "tdesign";
+  return TemplateName2;
+})(TemplateName || {});
+
+// src/npm.ts
+import https from "https";
+function getLatestVersionFromNpm(packageName) {
+  return new Promise((resolve2, reject) => {
+    const url = `https://registry.npmjs.org/${packageName}/latest`;
+    https.get(url, (res) => {
+      if (!res || res.statusCode && res.statusCode >= 400) {
+        res?.resume();
+        reject(new Error(`Request to ${url} failed with status ${res?.statusCode ?? "unknown"}`));
+        return;
       }
-      cb?.(
-        (...args) => {
-          set(projectConfig, ...args);
-        }
-      );
-      if (Array.isArray(get(projectConfig, "setting.packNpmRelationList"))) {
-        const x = projectConfig.setting.packNpmRelationList.find(
-          (x2) => x2.packageJsonPath === "./package.json" && x2.miniprogramNpmDistDir === "./dist"
-        );
-        if (!x) {
-          projectConfig.setting.packNpmRelationList.push({
-            packageJsonPath: "./package.json",
-            miniprogramNpmDistDir: "./dist"
-          });
-        }
-      } else {
-        set(projectConfig, "setting.packNpmRelationList", [
-          {
-            packageJsonPath: "./package.json",
-            miniprogramNpmDistDir: "./dist"
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (!json.version || typeof json.version !== "string") {
+            reject(new Error(`Unexpected response when fetching ${packageName}: missing version`));
+            return;
           }
-        ]);
-      }
-      if (write) {
-        await fs.outputJSON(dest ?? projectConfigPath, projectConfig, {
-          spaces: 2
-        });
-        logger.log(`\u2728 \u8BBE\u7F6E ${projectConfigFilename} \u914D\u7F6E\u6587\u4EF6\u6210\u529F!`);
+          resolve2(json.version);
+        } catch (err) {
+          reject(err);
+        }
+      });
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+async function latestVersion(packageName, prefix = "^") {
+  try {
+    const resolved = await getLatestVersionFromNpm(packageName);
+    return resolved ? `${prefix}${resolved}` : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/updateGitignore.ts
+import logger2 from "@weapp-core/logger";
+
+// src/gitignore.ts
+var DEFAULT_GITIGNORE = `# dependencies
+node_modules
+.pnp
+.pnp.js
+
+# testing
+coverage
+
+# next.js
+.next/
+out/
+build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# local env files
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# turbo
+.turbo
+
+dist
+dist-plugin
+vite.config.ts.timestamp-*.mjs`;
+function mergeGitignore(existing) {
+  const normalizedExisting = normalizeLineEndings(existing ?? "");
+  const existingLines = normalizedExisting.length ? normalizedExisting.split("\n") : [];
+  const merged = [...existingLines];
+  while (merged.length > 0 && merged[merged.length - 1] === "") {
+    merged.pop();
+  }
+  const seen = new Set(merged);
+  let appendedNonBlank = false;
+  for (const line of DEFAULT_GITIGNORE.split("\n")) {
+    const isBlank = line.length === 0;
+    if (isBlank) {
+      if (merged.length === 0 || merged[merged.length - 1] === "") {
+        continue;
       }
-      ctx.projectConfig.value = projectConfig;
-      return projectConfig;
-    } catch {
-      logger.warn(`\u2728 \u8BBE\u7F6E ${projectConfigFilename} \u914D\u7F6E\u6587\u4EF6\u5931\u8D25!`);
+      merged.push("");
+      continue;
     }
-  } else {
-    logger.info(`\u2728 \u6CA1\u6709\u627E\u5230 ${projectConfigFilename} \u6587\u4EF6! \u6B63\u5728\u4E3A\u4F60\u521B\u5EFA\u4E2D...`);
-    await fs.outputJson(projectConfigPath, {
-      compileType: "miniprogram",
-      libVersion: "trial",
-      packOptions: {
-        ignore: [],
-        include: []
-      },
-      setting: {
-        coverView: true,
-        es6: true,
-        postcss: true,
-        minified: true,
-        enhance: true,
-        showShadowRootInWxmlPanel: true,
-        packNpmRelationList: [
-          {
-            packageJsonPath: "./package.json",
-            miniprogramNpmDistDir: "./dist"
-          }
-        ],
-        babelSetting: {
-          ignore: [],
-          disablePlugins: [],
-          outputPath: ""
-        },
-        packNpmManually: true
-      },
-      condition: {},
-      editorSetting: {
-        tabIndent: "auto",
-        tabSize: 2
-      },
-      appid: "",
-      miniprogramRoot: "dist/",
-      srcMiniprogramRoot: "dist/"
-    }, { spaces: 2 });
-    logger.success(`\u2728 \u521B\u5EFA\u5B8C\u6210! \u522B\u5FD8\u4E86\u5728\u91CC\u9762\u8BBE\u7F6E\u4F60\u7684 \`appid\` `);
+    if (seen.has(line)) {
+      continue;
+    }
+    if (!appendedNonBlank && merged.length > 0 && merged[merged.length - 1] !== "") {
+      merged.push("");
+    }
+    merged.push(line);
+    seen.add(line);
+    appendedNonBlank = true;
+  }
+  return ensureTrailingNewline(trimTrailingBlankLines(merged).join("\n"));
+}
+function normalizeLineEndings(value) {
+  return value.replace(/\r\n/g, "\n");
+}
+function trimTrailingBlankLines(lines) {
+  let end = lines.length;
+  while (end > 0 && lines[end - 1] === "") {
+    end -= 1;
+  }
+  return lines.slice(0, end);
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+
+// src/updateGitignore.ts
+async function updateGitIgnore(options) {
+  const { root, dest, write = true } = options;
+  const gitignorePath = posix.resolve(root, ".gitignore");
+  const outputPath = resolveOutputPath(root, dest, gitignorePath);
+  const existing = await readFileIfExists(outputPath);
+  const merged = mergeGitignore(existing);
+  if (write && merged !== (existing ?? "")) {
+    await writeFile(outputPath, merged);
+    logger2.log(`\u2728 \u66F4\u65B0 ${posix.relative(root, outputPath)} \u6210\u529F!`);
   }
+  return merged;
 }
+
+// src/createProject.ts
+var moduleDir = posix.dirname(fileURLToPath(import.meta.url));
+async function createProject(targetDir = "", templateName = "default" /* default */) {
+  const targetTemplateDir = posix.resolve(moduleDir, "../templates", templateName);
+  if (!await fs2.pathExists(targetTemplateDir)) {
+    logger3.warn(`\u6CA1\u6709\u627E\u5230 ${templateName} \u6A21\u677F!`);
+    return;
+  }
+  await fs2.copy(targetTemplateDir, targetDir);
+  const templatePackagePath = posix.resolve(targetTemplateDir, "package.json");
+  const packageJsonPath = posix.resolve(targetDir, "package.json");
+  await ensureDotGitignore(targetDir);
+  const pkgJson = await fs2.pathExists(templatePackagePath) ? await fs2.readJSON(templatePackagePath) : createEmptyPackageJson();
+  if (!pkgJson.devDependencies) {
+    pkgJson.devDependencies = {};
+  }
+  if (pkgJson.devDependencies["weapp-vite"]) {
+    pkgJson.devDependencies["weapp-vite"] = version;
+  }
+  await upsertTailwindcssVersion(pkgJson);
+  await writeJsonFile(packageJsonPath, pkgJson);
+  await updateGitIgnore({ root: targetDir, write: true });
+  logger3.log("\u2728 \u521B\u5EFA\u6A21\u677F\u6210\u529F!");
+}
+async function upsertTailwindcssVersion(pkgJson) {
+  if (!pkgJson.devDependencies) {
+    return;
+  }
+  const resolved = await latestVersion("weapp-tailwindcss");
+  if (resolved) {
+    pkgJson.devDependencies["weapp-tailwindcss"] = resolved;
+  } else if (!pkgJson.devDependencies["weapp-tailwindcss"]) {
+    pkgJson.devDependencies["weapp-tailwindcss"] = "^4.3.3";
+  }
+}
+function createEmptyPackageJson() {
+  return {
+    name: "weapp-vite-app",
+    homepage: "https://vite.icebreaker.top/",
+    type: "module",
+    scripts: {},
+    devDependencies: {}
+  };
+}
+async function ensureDotGitignore(root) {
+  const gitignorePath = posix.resolve(root, "gitignore");
+  const dotGitignorePath = posix.resolve(root, ".gitignore");
+  if (!await fs2.pathExists(gitignorePath)) {
+    return;
+  }
+  if (await fs2.pathExists(dotGitignorePath)) {
+    await fs2.remove(gitignorePath);
+    return;
+  }
+  await fs2.move(gitignorePath, dotGitignorePath);
+}
+
+// src/packageJson.ts
+import logger4 from "@weapp-core/logger";
+import { defu, get, set } from "@weapp-core/shared";
+var FALLBACK_DEP_VERSIONS = {
+  "miniprogram-api-typings": "^4.1.0",
+  "typescript": "^5.9.2",
+  "weapp-tailwindcss": "^4.3.3"
+};
 async function createOrUpdatePackageJson(options) {
   const { root, dest, command, cb, write, filename } = defu(options, {
     write: true,
@@ -726,110 +877,168 @@ async function createOrUpdatePackageJson(options) {
   });
   const packageJsonFilename = ctx.packageJson.name = filename;
   const packageJsonPath = ctx.packageJson.path = posix.resolve(root, packageJsonFilename);
-  let packageJson;
-  if (await fs.exists(packageJsonPath)) {
-    packageJson = await fs.readJSON(packageJsonPath);
-  } else {
-    packageJson = {
-      name: "weapp-vite-app",
-      homepage: "https://vite.icebreaker.top/",
-      type: "module"
-    };
-  }
+  const outputPath = resolveOutputPath(root, dest, packageJsonPath);
   try {
+    let packageJson = await readJsonIfExists(packageJsonPath);
+    if (!packageJson) {
+      packageJson = createDefaultPackageJson();
+      logger4.info(`\u2728 \u6CA1\u6709\u627E\u5230 ${packageJsonFilename} \u6587\u4EF6\uFF0C\u6B63\u5728\u521B\u5EFA\u9ED8\u8BA4 package.json ...`);
+    }
     set(packageJson, "scripts.dev", `${command} dev`);
     set(packageJson, "scripts.dev:open", `${command} dev -o`);
     set(packageJson, "scripts.build", `${command} build`);
     if (command === "weapp-vite") {
       set(packageJson, "scripts.open", `${command} open`);
       set(packageJson, "scripts.g", `${command} generate`);
-      set(packageJson, "devDependencies.miniprogram-api-typings", await latestVersion("miniprogram-api-typings"));
-      set(packageJson, "devDependencies.weapp-vite", await latestVersion("weapp-vite"));
-      set(packageJson, "devDependencies.typescript", await latestVersion("typescript"));
+      set(packageJson, "devDependencies.weapp-vite", `^${version}`);
+      await Promise.all([
+        upsertDependencyVersion(packageJson, "devDependencies.miniprogram-api-typings", "miniprogram-api-typings", { skipNetwork: !write }),
+        upsertDependencyVersion(packageJson, "devDependencies.typescript", "typescript", { skipNetwork: !write })
+      ]);
     }
     cb?.(
       (...args) => {
         set(packageJson, ...args);
       }
     );
+    ctx.packageJson.value = packageJson;
     if (write) {
-      await fs.outputJSON(dest ?? packageJsonPath, packageJson, {
-        spaces: 2
-      });
-      logger.log(`\u2728 \u8BBE\u7F6E ${packageJsonFilename} \u914D\u7F6E\u6587\u4EF6\u6210\u529F!`);
+      await writeJsonFile(outputPath, packageJson);
+      logger4.log(`\u2728 \u5199\u5165 ${posix.relative(root, outputPath)} \u6210\u529F!`);
     }
-    ctx.packageJson.value = packageJson;
     return packageJson;
-  } catch {
+  } catch (error) {
+    logger4.error(`\u26A0\uFE0F \u8BBE\u7F6E ${packageJsonFilename} \u914D\u7F6E\u6587\u4EF6\u5931\u8D25`, error);
+    throw error;
   }
 }
-async function initViteConfigFile(options) {
-  const { root, write = true } = options;
-  const type = get(ctx.packageJson.value, "type");
-  const targetFilename = ctx.viteConfig.name = type === "module" ? "vite.config.ts" : "vite.config.mts";
-  const viteConfigFilePath = ctx.viteConfig.path = posix.resolve(root, targetFilename);
-  const viteConfigFileCode = ctx.viteConfig.value = getDefaultViteConfig();
-  if (write) {
-    await fs.outputFile(viteConfigFilePath, viteConfigFileCode, "utf8");
-    logger.log(`\u2728 \u8BBE\u7F6E ${targetFilename} \u914D\u7F6E\u6587\u4EF6\u6210\u529F!`);
+async function upsertDependencyVersion(packageJson, keyPath, packageName, options = {}) {
+  const currentValue = get(packageJson, keyPath);
+  const resolved = options.skipNetwork ? null : await latestVersion(packageName);
+  if (resolved) {
+    set(packageJson, keyPath, resolved);
+    return;
   }
-  return viteConfigFileCode;
-}
-async function initTsDtsFile(options) {
-  const { root, write = true } = options;
-  const targetFilename = "vite-env.d.ts";
-  const viteDtsFilePath = posix.resolve(root, targetFilename);
-  const code = getDefaultTsDts();
-  if (write) {
-    await fs.outputFile(viteDtsFilePath, code, "utf8");
-    logger.log(`\u2728 \u8BBE\u7F6E ${targetFilename} \u914D\u7F6E\u6587\u4EF6\u6210\u529F!`);
+  if (currentValue === void 0) {
+    const fallback = FALLBACK_DEP_VERSIONS[packageName] ?? "latest";
+    set(packageJson, keyPath, fallback);
   }
-  return code;
 }
-async function initTsJsonFiles(options) {
-  const { root, write = true } = options;
-  const tsJsonFilename = ctx.tsconfig.name = "tsconfig.json";
-  const tsJsonFilePath = ctx.tsconfig.path = posix.resolve(root, tsJsonFilename);
-  const tsNodeJsonFilename = ctx.tsconfigNode.name = "tsconfig.node.json";
-  const tsNodeJsonFilePath = ctx.tsconfigNode.path = posix.resolve(root, tsNodeJsonFilename);
-  if (write) {
-    const tsJsonValue = getDefaultTsconfigJson();
-    if (write) {
-      await fs.outputJSON(
-        tsJsonFilePath,
-        tsJsonValue,
-        {
-          encoding: "utf8",
-          spaces: 2
-        }
-      );
-      logger.log(`\u2728 \u8BBE\u7F6E ${tsJsonFilename} \u914D\u7F6E\u6587\u4EF6\u6210\u529F!`);
+function createDefaultPackageJson() {
+  return {
+    name: "weapp-vite-app",
+    homepage: "https://vite.icebreaker.top/",
+    type: "module",
+    scripts: {},
+    devDependencies: {}
+  };
+}
+
+// src/projectConfig.ts
+import logger5 from "@weapp-core/logger";
+import { defu as defu2, get as get2, set as set2 } from "@weapp-core/shared";
+async function createOrUpdateProjectConfig(options) {
+  const { root, dest, cb, write, filename } = defu2(
+    options,
+    {
+      write: true,
+      filename: "project.config.json"
     }
-    ctx.tsconfig.value = tsJsonValue;
-    const tsJsonNodeValue = getDefaultTsconfigNodeJson([
-      ctx.viteConfig.name
-    ]);
+  );
+  const projectConfigFilename = ctx.projectConfig.name = filename;
+  const projectConfigPath = ctx.projectConfig.path = posix.resolve(root, projectConfigFilename);
+  const outputPath = resolveOutputPath(root, dest, projectConfigPath);
+  try {
+    let projectConfig = await readJsonIfExists(projectConfigPath);
+    if (projectConfig) {
+      applyProjectConfigDefaults(projectConfig);
+    } else {
+      projectConfig = createDefaultProjectConfig();
+      logger5.info(`\u2728 \u6CA1\u6709\u627E\u5230 ${projectConfigFilename} \u6587\u4EF6\uFF0C\u6B63\u5728\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F\u521B\u5EFA...`);
+    }
+    cb?.(
+      (...args) => {
+        set2(projectConfig, ...args);
+      }
+    );
+    ensurePackNpmRelationList(projectConfig);
+    ctx.projectConfig.value = projectConfig;
     if (write) {
-      await fs.outputJSON(tsNodeJsonFilePath, tsJsonNodeValue, {
-        encoding: "utf8",
-        spaces: 2
-      });
-      logger.log(`\u2728 \u8BBE\u7F6E ${tsNodeJsonFilename} \u914D\u7F6E\u6587\u4EF6\u6210\u529F!`);
+      await writeJsonFile(outputPath, projectConfig);
+      logger5.log(`\u2728 \u5199\u5165 ${posix.relative(root, outputPath)} \u6210\u529F!`);
     }
-    ctx.tsconfigNode.value = tsJsonNodeValue;
+    return projectConfig;
+  } catch (error) {
+    logger5.error(`\u26A0\uFE0F \u8BBE\u7F6E ${projectConfigFilename} \u914D\u7F6E\u6587\u4EF6\u5931\u8D25`, error);
+    throw error;
   }
 }
-async function updateGitIgnore(options) {
-  const { root, write = true } = options;
-  const filepath = posix.resolve(root, ".gitignore");
-  const data = getDefaultGitignore();
-  if (write) {
-    await fs.outputFile(filepath, data, {
-      encoding: "utf8"
-    });
+function applyProjectConfigDefaults(projectConfig) {
+  set2(projectConfig, "miniprogramRoot", "dist/");
+  set2(projectConfig, "srcMiniprogramRoot", "dist/");
+  set2(projectConfig, "setting.packNpmManually", true);
+  const compileType = get2(projectConfig, "compileType");
+  if (compileType === "plugin") {
+    set2(projectConfig, "pluginRoot", "dist-plugin");
+  }
+}
+function ensurePackNpmRelationList(projectConfig) {
+  const relations = get2(projectConfig, "setting.packNpmRelationList");
+  const defaultRelation = {
+    packageJsonPath: "./package.json",
+    miniprogramNpmDistDir: "./dist"
+  };
+  if (Array.isArray(relations)) {
+    const exists = relations.some(
+      (relation) => relation.packageJsonPath === defaultRelation.packageJsonPath && relation.miniprogramNpmDistDir === defaultRelation.miniprogramNpmDistDir
+    );
+    if (!exists) {
+      relations.push(defaultRelation);
+    }
+  } else {
+    set2(projectConfig, "setting.packNpmRelationList", [defaultRelation]);
   }
-  return data;
 }
+function createDefaultProjectConfig() {
+  return {
+    compileType: "miniprogram",
+    libVersion: "trial",
+    packOptions: {
+      ignore: [],
+      include: []
+    },
+    setting: {
+      coverView: true,
+      es6: true,
+      postcss: true,
+      minified: true,
+      enhance: true,
+      showShadowRootInWxmlPanel: true,
+      packNpmRelationList: [
+        {
+          packageJsonPath: "./package.json",
+          miniprogramNpmDistDir: "./dist"
+        }
+      ],
+      babelSetting: {
+        ignore: [],
+        disablePlugins: [],
+        outputPath: ""
+      },
+      packNpmManually: true
+    },
+    condition: {},
+    editorSetting: {
+      tabIndent: "auto",
+      tabSize: 2
+    },
+    appid: "",
+    miniprogramRoot: "dist/",
+    srcMiniprogramRoot: "dist/"
+  };
+}
+
+// src/index.ts
 async function initConfig(options) {
   const { root = process2.cwd(), command } = options;
   await createOrUpdateProjectConfig({ root });
@@ -842,29 +1051,6 @@ async function initConfig(options) {
   }
   return ctx;
 }
-async function createProject(targetDir = "", templateName = "default" /* default */) {
-  const targetTemplateDir = posix.resolve(import.meta.dirname, "../templates", templateName);
-  if (await fs.exists(targetTemplateDir)) {
-    await fs.copy(targetTemplateDir, targetDir);
-    const pkgJsonPath = posix.resolve(targetTemplateDir, "package.json");
-    const pkgJson = await fs.readJson(pkgJsonPath);
-    if (pkgJson.devDependencies) {
-      if (pkgJson.devDependencies["weapp-vite"]) {
-        pkgJson.devDependencies["weapp-vite"] = version;
-      }
-      if (pkgJson.devDependencies["weapp-tailwindcss"]) {
-        pkgJson.devDependencies["weapp-tailwindcss"] = await latestVersion("weapp-tailwindcss");
-      }
-    }
-    await fs.writeJson(posix.resolve(targetDir, "package.json"), pkgJson, { spaces: 2 });
-    if (!await fs.exists(posix.resolve(targetDir, ".gitignore"))) {
-      await updateGitIgnore({ root: targetDir, write: true });
-    }
-    logger.log(`\u2728 \u521B\u5EFA\u6A21\u677F\u6210\u529F!`);
-  } else {
-    logger.warn(`\u6CA1\u6709\u627E\u5230 ${templateName} \u6A21\u677F!`);
-  }
-}
 export {
   TemplateName,
   createOrUpdatePackageJson,
@@ -873,5 +1059,6 @@ export {
   initConfig,
   initTsDtsFile,
   initTsJsonFiles,
-  initViteConfigFile
+  initViteConfigFile,
+  resetContext
 };