sdnext 0.0.23 → 0.0.25

package/README.md

@@ -1,3 +1,113 @@
 # sdnext
 
-to do.
+`sdnext` 是一个面向 `Next.js` 项目的轻量生成工具，用来基于 `shared/**` 自动生成 `actions/**`、`app/api/actions/**/route.ts`，以及基于 `actions/**` 生成 `hooks/**`。
+
+## 约定
+
+### shared -> action
+
+`shared/addUser.ts`
+
+```ts
+export async function addUser() {}
+```
+
+会生成：
+
+`actions/addUser.ts`
+
+```ts
+"use server"
+
+import { createResponseFn } from "@/server/createResponseFn"
+
+import { addUser } from "@/shared/addUser"
+
+export const addUserAction = createResponseFn(addUser)
+```
+
+### shared -> route
+
+如果源函数显式声明了 `route` 元数据：
+
+```ts
+export async function addUser() {}
+
+addUser.route = true
+```
+
+或：
+
+```ts
+export async function addUser() {}
+
+addUser.route = {}
+```
+
+会额外生成：
+
+`app/api/actions/add-user/route.ts`
+
+```ts
+import { createRoute } from "@/server/createResponseFn"
+
+import { addUser } from "@/shared/addUser"
+
+export const { POST } = createRoute(addUser)
+```
+
+默认情况下，`fn.route` 视为 `false`，不会生成 route。
+
+### actions -> hook
+
+执行 `sdnext hook` 后，会根据 `actions/**` 生成 `hooks/**`。
+
+命名规则：
+
+- `getUser` 默认识别为 `get`
+- `queryUser` 默认识别为 `query`
+- 其他函数默认识别为 `mutation`
+
+## 命令
+
+### build
+
+```bash
+sdnext build next build
+```
+
+执行顺序：
+
+1. 同步生成 `actions/**`
+2. 根据 `fn.route` 同步生成 `app/api/actions/**`
+3. 再执行后续命令
+
+### dev
+
+```bash
+sdnext dev next dev
+```
+
+行为与 `build` 类似，但会额外监听 `shared/**` 的新增、修改、删除，并实时同步生成物。
+
+### hook
+
+```bash
+sdnext hook
+```
+
+扫描 `actions/**` 并交互式生成或覆盖 `hooks/**`。
+
+## 路径映射
+
+- `shared/addUser.ts` -> `actions/addUser.ts`
+- `shared/addUser.ts` -> `app/api/actions/add-user/route.ts`
+- `shared/admin/addUser.ts` -> `actions/admin/addUser.ts`
+- `shared/admin/addUser.ts` -> `app/api/actions/admin/add-user/route.ts`
+
+## 说明
+
+- 只处理 `.ts`、`.tsx`、`.js`、`.jsx`
+- 生成文件会做幂等比较，内容未变化时不会重复写入
+- 删除 `shared` 文件或移除 `fn.route` 后，对应生成物会自动清理
+- `sdnext build` 和 `sdnext dev` 会自动把 `actions/**` 与 `app/api/actions/**` 写入 `.vscode/settings.json` 的 `files.exclude`

package/dist/index.js

@@ -1,15 +1,146 @@
 #!/usr/bin/env node
-import { readFileSync } from "fs";
-import { join } from "path";
-import { Command } from "commander";
-import { build } from "./utils/build.js";
-import { dev } from "./utils/dev.js";
-import { hook } from "./utils/hook.js";
-const program = new Command();
-const path = "win32" === process.platform ? import.meta.resolve("../").replace(/^file:\/\/\//, "") : import.meta.resolve("../").replace(/^file:\/\//, "");
-const packgeJson = JSON.parse(readFileSync(join(path, "package.json"), "utf-8"));
-program.name("soda next").version(packgeJson.version);
-program.command("build").allowUnknownOption(true).allowExcessArguments(true).action(build);
-program.command("dev").allowUnknownOption(true).allowExcessArguments(true).action(dev);
-program.command("hook").action(hook);
-program.parse();
+import * as __WEBPACK_EXTERNAL_MODULE__utils_build_js_f9ba07bf__ from "./utils/build.js";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_dev_js_df994271__ from "./utils/dev.js";
+import * as __WEBPACK_EXTERNAL_MODULE__utils_hook_js_8cbfab27__ from "./utils/hook.js";
+import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
+import * as __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__ from "fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
+var __webpack_modules__ = {
+    "./src/index.ts": function(module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.a(module, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
+            try {
+                __webpack_require__.r(__webpack_exports__);
+                var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("fs/promises");
+                var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("path");
+                var url__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("url");
+                var commander__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("commander");
+                var _utils_build__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./utils/build");
+                var _utils_dev__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./utils/dev");
+                var _utils_hook__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./utils/hook");
+                const program = new commander__WEBPACK_IMPORTED_MODULE_3__.Command();
+                const path = (0, url__WEBPACK_IMPORTED_MODULE_2__.fileURLToPath)(new URL("../", import.meta.url));
+                const packageJson = JSON.parse(await (0, fs_promises__WEBPACK_IMPORTED_MODULE_0__.readFile)((0, path__WEBPACK_IMPORTED_MODULE_1__.join)(path, "package.json"), "utf-8"));
+                program.name("soda next").version(packageJson.version);
+                program.command("build").allowUnknownOption(true).allowExcessArguments(true).action(_utils_build__WEBPACK_IMPORTED_MODULE_4__.build);
+                program.command("dev").allowUnknownOption(true).allowExcessArguments(true).action(_utils_dev__WEBPACK_IMPORTED_MODULE_5__.dev);
+                program.command("hook").action(_utils_hook__WEBPACK_IMPORTED_MODULE_6__.hook);
+                program.parse();
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        }, 1);
+    },
+    "./utils/build": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_build_js_f9ba07bf__;
+    },
+    "./utils/dev": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_dev_js_df994271__;
+    },
+    "./utils/hook": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__utils_hook_js_8cbfab27__;
+    },
+    commander: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_commander__;
+    },
+    "fs/promises": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__;
+    },
+    path: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_path__;
+    },
+    url: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_url__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    var webpackQueues = "function" == typeof Symbol ? Symbol("webpack queues") : "__webpack_queues__";
+    var webpackExports = "function" == typeof Symbol ? Symbol("webpack exports") : "__webpack_exports__";
+    var webpackError = "function" == typeof Symbol ? Symbol("webpack error") : "__webpack_error__";
+    var resolveQueue = (queue)=>{
+        if (queue && queue.d < 1) {
+            queue.d = 1;
+            queue.forEach((fn)=>fn.r--);
+            queue.forEach((fn)=>fn.r-- ? fn.r++ : fn());
+        }
+    };
+    var wrapDeps = (deps)=>deps.map((dep)=>{
+            if (null !== dep && "object" == typeof dep) {
+                if (dep[webpackQueues]) return dep;
+                if (dep.then) {
+                    var queue = [];
+                    queue.d = 0;
+                    dep.then((r)=>{
+                        obj[webpackExports] = r;
+                        resolveQueue(queue);
+                    }, (e)=>{
+                        obj[webpackError] = e;
+                        resolveQueue(queue);
+                    });
+                    var obj = {};
+                    obj[webpackQueues] = (fn)=>fn(queue);
+                    return obj;
+                }
+            }
+            var ret = {};
+            ret[webpackQueues] = function() {};
+            ret[webpackExports] = dep;
+            return ret;
+        });
+    __webpack_require__.a = (module, body, hasAwait)=>{
+        var queue;
+        hasAwait && ((queue = []).d = -1);
+        var depQueues = new Set();
+        var exports = module.exports;
+        var currentDeps;
+        var outerResolve;
+        var reject;
+        var promise = new Promise((resolve, rej)=>{
+            reject = rej;
+            outerResolve = resolve;
+        });
+        promise[webpackExports] = exports;
+        promise[webpackQueues] = (fn)=>{
+            queue && fn(queue), depQueues.forEach(fn), promise["catch"](function() {});
+        };
+        module.exports = promise;
+        body((deps)=>{
+            currentDeps = wrapDeps(deps);
+            var fn;
+            var getResult = ()=>currentDeps.map((d)=>{
+                    if (d[webpackError]) throw d[webpackError];
+                    return d[webpackExports];
+                });
+            var promise = new Promise((resolve)=>{
+                fn = ()=>resolve(getResult);
+                fn.r = 0;
+                var fnQueue = (q)=>q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
+                currentDeps.map((dep)=>dep[webpackQueues](fnQueue));
+            });
+            return fn.r ? promise : getResult();
+        }, (err)=>(err ? reject(promise[webpackError] = err) : outerResolve(exports), resolveQueue(queue)));
+        queue && queue.d < 0 && (queue.d = 0);
+    };
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+__webpack_require__("./src/index.ts");

package/dist/utils/build.js

@@ -1,24 +1,23 @@
-import { spawn } from "child_process";
 import { readdir, stat } from "fs/promises";
 import { join } from "path";
-import { createAction } from "./createAction.js";
-import { excludeActions } from "./excludeActions.js";
+import { excludeGeneratedFiles } from "./excludeGeneratedFiles.js";
+import { runCommand } from "./runCommand.js";
+import { syncSharedArtifacts } from "./syncSharedArtifacts.js";
 async function buildFolder(dir) {
     const content = await readdir(dir);
     for (const item of content){
         const path = join(dir, item);
         const stats = await stat(path);
         if (stats.isDirectory()) await buildFolder(path);
-        else await createAction(path);
+        else await syncSharedArtifacts(path);
     }
 }
 async function build(options, { args }) {
-    await excludeActions();
+    await excludeGeneratedFiles();
     await buildFolder("shared");
     if (0 === args.length) return;
-    spawn(args.join(" "), {
-        stdio: "inherit",
-        shell: true
+    process.exitCode = await runCommand({
+        args
     });
 }
 export { build, buildFolder };

package/dist/utils/createAction.js

@@ -1,25 +1,18 @@
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { join, parse, relative } from "path";
+import { join } from "path";
+import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
 async function createAction(path) {
-    path = relative("shared", path).replace(/\\/g, "/");
-    const { dir, name, ext } = parse(path);
-    if (".ts" !== ext && ".tsx" !== ext && ".js" !== ext && ".jsx" !== ext) return;
-    const content = `"use server"
+    const info = getSharedModuleInfo(path);
+    if (!isScriptModule(info.relativePath)) return;
+    await writeGeneratedFile({
+        path: join("actions", info.relativePath),
+        content: `"use server"
 
 import { createResponseFn } from "@/server/createResponseFn"
 
-import { ${name} } from "@/shared/${join(dir, name)}"
+import { ${info.name} } from "@/shared/${info.importPath}"
 
-export const ${name}Action = createResponseFn(${name})
-`;
-    const actionPath = join("actions", path);
-    try {
-        const current = await readFile(actionPath, "utf-8");
-        if (current === content) return;
-    } catch (error) {}
-    await mkdir(join("actions", dir), {
-        recursive: true
+export const ${info.name}Action = createResponseFn(${info.name})
+`
     });
-    await writeFile(actionPath, content);
 }
 export { createAction };

package/dist/utils/createRoute.d.ts

@@ -0,0 +1,5 @@
+export declare function createRoute(path: string): Promise<void>;
+export interface IsRouteEnabledParams {
+    content: string;
+    name: string;
+}

package/dist/utils/createRoute.js

@@ -0,0 +1,31 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { getSharedModuleInfo, isScriptModule, removeGeneratedFile, toKebabCase, writeGeneratedFile } from "./sharedArtifact.js";
+async function createRoute(path) {
+    const info = getSharedModuleInfo(path);
+    if (!isScriptModule(info.relativePath)) return;
+    const routeDirPath = join("app", "api", "actions", info.dir, toKebabCase(info.name));
+    const routePath = join(routeDirPath, "route.ts");
+    const content = await readFile(join("shared", info.relativePath), "utf-8");
+    if (!isRouteEnabled({
+        content,
+        name: info.name
+    })) return void await removeGeneratedFile({
+        path: routeDirPath,
+        stopPath: join("app", "api", "actions")
+    });
+    await writeGeneratedFile({
+        path: routePath,
+        content: `import { createRoute } from "@/server/createResponseFn"
+
+import { ${info.name} } from "@/shared/${info.importPath}"
+
+export const { POST } = createRoute(${info.name})
+`
+    });
+}
+function isRouteEnabled({ content, name }) {
+    const routeRegExp = new RegExp(`\\b${name}\\.route\\s*=\\s*(true\\b|\\{)`);
+    return routeRegExp.test(content);
+}
+export { createRoute };

package/dist/utils/dev.js

@@ -1,19 +1,34 @@
 import { spawn } from "child_process";
+import { fileURLToPath } from "url";
 import { buildFolder } from "./build.js";
-import { excludeActions } from "./excludeActions.js";
+import { excludeGeneratedFiles } from "./excludeGeneratedFiles.js";
+import { spawnCommand } from "./runCommand.js";
 async function dev(options, { args }) {
-    await excludeActions();
+    await excludeGeneratedFiles();
     await buildFolder("shared");
     if (0 === args.length) return;
-    const watchPath = import.meta.resolve("./watch.js").replace("win32" === process.platform ? /^file:\/\/\// : /^file:\/\//, "");
+    const watchPath = fileURLToPath(new URL("./watch.js", import.meta.url));
     const child = spawn(process.execPath, [
         watchPath
-    ]);
-    const child2 = spawn(args.join(" "), {
-        stdio: "inherit",
-        shell: true
+    ], {
+        stdio: "inherit"
+    });
+    const child2 = spawnCommand({
+        args
+    });
+    process.exitCode = await new Promise((resolve, reject)=>{
+        let settled = false;
+        function onClose(code) {
+            if (settled) return;
+            settled = true;
+            child.kill();
+            child2.kill();
+            resolve(code);
+        }
+        child.once("error", reject);
+        child2.once("error", reject);
+        child.once("close", (code, signal)=>onClose("number" == typeof code ? code : signal ? 1 : 0));
+        child2.once("close", (code, signal)=>onClose("number" == typeof code ? code : signal ? 1 : 0));
     });
-    child.on("close", ()=>child2.kill());
-    child2.on("close", ()=>child.kill());
 }
 export { dev };

package/dist/utils/excludeGeneratedFiles.d.ts

@@ -0,0 +1 @@
+export declare function excludeGeneratedFiles(): Promise<import("./writeVsCodeSetting").VsCodeSetting>;

package/dist/utils/{excludeActions.js → excludeGeneratedFiles.js}

@@ -1,9 +1,10 @@
 import { writeVsCodeSetting } from "./writeVsCodeSetting.js";
-function excludeActions() {
+function excludeGeneratedFiles() {
     return writeVsCodeSetting({
         "files.exclude": {
-            "actions/**": true
+            "actions/**": true,
+            "app/api/actions/**": true
         }
     });
 }
-export { excludeActions };
+export { excludeGeneratedFiles };

package/dist/utils/hook.d.ts

@@ -3,9 +3,13 @@ export type HookType = "get" | "query" | "mutation";
 export type OperationType = HookType | "skip";
 export type HookContentMap = Record<HookType, string>;
 export interface HookData extends HookContentMap {
+    hookPath: string;
     overwrite: boolean;
     type: HookType;
 }
 export declare function createHook(path: string, hookMap: Record<string, HookData>): Promise<void>;
-export declare function createActionFromFolder(): Promise<Record<string, HookData>>;
+export declare function createHookFromFolder(): Promise<Record<string, HookData>>;
 export declare function hook(options: Record<string, string>, { args }: Command): Promise<void>;
+export interface NodeError {
+    code?: string;
+}

package/dist/utils/hook.js

@@ -1,8 +1,9 @@
-import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import { readFile, readdir, stat } from "fs/promises";
 import { join, parse, relative } from "path";
 import { cwd } from "process";
 import { checkbox as prompts_checkbox, select as prompts_select } from "@inquirer/prompts";
 import { readSdNextSetting } from "./readSdNextSetting.js";
+import { isScriptModule, normalizePathSeparator, writeGeneratedFile } from "./sharedArtifact.js";
 import { writeSdNextSetting } from "./writeSdNextSetting.js";
 function getHookTypeFromName(name) {
     if (/^get[^a-z]/.test(name)) return "get";
@@ -19,29 +20,32 @@ async function getHookTypeFromContent(path, content) {
     const type = setting.hook?.[path];
     if (void 0 !== type && "skip" !== type) return type;
     if (content.includes("useMutation")) return "mutation";
-    if (content.includes("IdOrParams")) return "get";
+    if (content.includes("ClientOptional")) return "get";
     if (content.includes("useQuery")) return "query";
 }
 async function createHook(path, hookMap) {
     path = relative("actions", path).replace(/\\/g, "/");
-    const { dir, name, ext, base } = parse(path);
-    if (".ts" !== ext && ".tsx" !== ext && ".js" !== ext && ".jsx" !== ext) return;
-    const serverContent = await readFile(join("shared", path), "utf-8");
-    const match = serverContent.match(new RegExp(`export async function ${name}\\(.+?: (.+?)Params\\)`, "s"));
-    const hasSchema = !!match;
+    const { dir, name, base } = parse(path);
+    if (!isScriptModule(path)) return;
     const upName = name.replace(/^./, (char)=>char.toUpperCase());
     const key = name.replace(/[A-Z]/g, (char)=>`-${char.toLowerCase()}`);
+    const actionImportPath = normalizePathSeparator(join(dir, name));
+    const hookName = base.replace(/^./, (char)=>`use${char.toUpperCase()}`);
+    const hookPath = join("hooks", dir, hookName);
+    const clientInputType = `${upName}ClientInput`;
     const mutationHook = `import { useId } from "react"
 
 import { useMutation, UseMutationOptions } from "@tanstack/react-query"
 import { createRequestFn } from "deepsea-tools"
 
-import { ${name}Action } from "@/actions/${join(dir, name)}"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
+export type ${clientInputType} = Parameters<typeof ${name}Client> extends [] ? void : Parameters<typeof ${name}Client>[0]
+
 export interface Use${upName}Params<TOnMutateResult = unknown> extends Omit<
-    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, Parameters<typeof ${name}Client>[0], TOnMutateResult>,
+    UseMutationOptions<Awaited<ReturnType<typeof ${name}Client>>, Error, ${clientInputType}, TOnMutateResult>,
     "mutationFn"
 > {}
 
@@ -87,11 +91,13 @@ export function use${upName}<TOnMutateResult = unknown>({ onMutate, onSuccess, o
     const getHook = `import { createRequestFn, isNonNullable } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${join(dir, name)}"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
-export function ${name}ClientOptional(id?: ${hasSchema ? `${match[1].replace(/Schema$/, "Params").replace(/^./, (char)=>char.toUpperCase())} | ` : ""}undefined | null) {
+export type ${clientInputType} = Parameters<typeof ${name}Client> extends [] ? undefined : Parameters<typeof ${name}Client>[0]
+
+export function ${name}ClientOptional(id?: ${clientInputType} | null) {
     return isNonNullable(id) ? ${name}Client(id) : null
 }
 
@@ -103,7 +109,7 @@ export const use${upName} = createUseQuery({
     const queryHook = `import { createRequestFn } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${join(dir, name)}"
+import { ${name}Action } from "@/actions/${actionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -117,8 +123,6 @@ export const use${upName} = createUseQuery({
         query: queryHook,
         mutation: mutationHook
     };
-    const hookName = base.replace(/^./, (char)=>`use${char.toUpperCase()}`);
-    const hookPath = join("hooks", dir, hookName);
     let hookType = getHookTypeFromName(name);
     let overwrite = true;
     try {
@@ -131,35 +135,41 @@ export const use${upName} = createUseQuery({
         overwrite = true;
     }
     hookMap[path] = {
+        hookPath,
         overwrite,
         type: hookType,
         ...map
     };
 }
-async function createActionFromFolder() {
+async function createHookFromFolder() {
     const map = {};
-    async function _createActionFromFolder(dir) {
+    async function _createHookFromFolder(dir) {
         const content = await readdir(dir);
         for (const item of content){
             const path = join(dir, item);
             const stats = await stat(path);
-            if (stats.isDirectory()) await _createActionFromFolder(path);
+            if (stats.isDirectory()) await _createHookFromFolder(path);
             if (stats.isFile()) await createHook(path, map);
         }
     }
-    await _createActionFromFolder("actions");
+    try {
+        await _createHookFromFolder("actions");
+    } catch (error) {
+        if (isNodeError(error) && "ENOENT" === error.code) return map;
+        throw error;
+    }
     return map;
 }
 async function hook(options, { args }) {
-    const map = await createActionFromFolder();
+    const map = await createHookFromFolder();
     const entires = Object.entries(map);
     if (0 === entires.length) return void console.log("All hooks are the latest.");
     const newEntires = entires.filter(([path, { overwrite }])=>overwrite);
     const oldEntires = entires.filter(([path, { overwrite }])=>!overwrite);
     const root = cwd();
     const setting = await getSetting();
-    for await (const [path, { overwrite, type, ...map }] of newEntires){
-        const resolved = join(root, "hooks", path);
+    for (const [path, { hookPath, overwrite, type, ...map }] of newEntires){
+        const resolved = join(root, hookPath);
         const answer = await prompts_select({
             message: path,
             choices: [
@@ -172,25 +182,22 @@ async function hook(options, { args }) {
         });
         setting.hook ??= {};
         setting.hook[resolved] = answer;
-        if ("skip" === answer) continue;
-        const { dir, base } = parse(path);
-        await mkdir(join("hooks", dir), {
-            recursive: true
+        if ("skip" !== answer) await writeGeneratedFile({
+            path: hookPath,
+            content: map[answer]
         });
-        await writeFile(join("hooks", dir, base.replace(/^./, (char)=>`use${char.toUpperCase()}`)), map[answer]);
     }
     await writeSdNextSetting(setting);
     const overwrites = await prompts_checkbox({
         message: "Please check the hooks you want to overwrite",
         choices: oldEntires.map(([key])=>key)
     });
-    for (const [path, { overwrite, type, ...map }] of oldEntires){
-        if (!overwrites.includes(path)) continue;
-        const { dir, base } = parse(path);
-        await mkdir(join("hooks", dir), {
-            recursive: true
-        });
-        await writeFile(join("hooks", dir, base.replace(/^./, (char)=>`use${char.toUpperCase()}`)), map[type]);
-    }
+    for (const [path, { hookPath, overwrite, type, ...map }] of oldEntires)if (overwrites.includes(path)) await writeGeneratedFile({
+        path: hookPath,
+        content: map[type]
+    });
+}
+function isNodeError(error) {
+    return "object" == typeof error && null !== error;
 }
-export { createActionFromFolder, createHook, hook };
+export { createHook, createHookFromFolder, hook };

package/dist/utils/readSdNextSetting.d.ts

@@ -3,3 +3,6 @@ export interface SdNextSetting {
     hook?: Record<string, OperationType>;
 }
 export declare function readSdNextSetting(): Promise<SdNextSetting>;
+export interface NodeError {
+    code?: string;
+}

package/dist/utils/readSdNextSetting.js

@@ -1,14 +1,19 @@
-import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 async function readSdNextSetting() {
     const userDir = homedir();
     const settingPath = join(userDir, ".sdnext.json");
-    if (existsSync(settingPath)) {
+    try {
         const setting = JSON.parse(await readFile(settingPath, "utf-8"));
         return setting;
+    } catch (error) {
+        if (isNodeError(error) && "ENOENT" === error.code) return {};
+        console.warn(`Failed to read ${settingPath}, fallback to default setting.`);
+        return {};
     }
-    return {};
+}
+function isNodeError(error) {
+    return "object" == typeof error && null !== error;
 }
 export { readSdNextSetting };