sdnext 0.0.26 → 0.0.27

package/dist/utils/createAction.js

@@ -1,15 +1,19 @@
 import { join } from "path";
+import { resolveProjectImportPath } from "./resolveProjectImportPath.js";
 import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
 async function createAction(path) {
     const info = getSharedModuleInfo(path);
     if (!isScriptModule(info.relativePath)) return;
+    const actionPath = join("actions", info.relativePath);
+    const createResponseFnImportPath = await resolveProjectImportPath(actionPath, "server/createResponseFn");
+    const sharedImportPath = await resolveProjectImportPath(actionPath, `shared/${info.importPath}`);
     await writeGeneratedFile({
-        path: join("actions", info.relativePath),
+        path: actionPath,
         content: `"use server"
 
-import { createResponseFn } from "@/server/createResponseFn"
+import { createResponseFn } from "${createResponseFnImportPath}"
 
-import { ${info.name} } from "@/shared/${info.importPath}"
+import { ${info.name} } from "${sharedImportPath}"
 
 export const ${info.name}Action = createResponseFn(${info.name})
 `

package/dist/utils/createRoute.js

@@ -1,5 +1,6 @@
 import { readdir } from "fs/promises";
 import { join } from "path";
+import { resolveProjectImportPath } from "./resolveProjectImportPath.js";
 import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact.js";
 async function createRoute(path) {
     if (path) {
@@ -7,9 +8,10 @@ async function createRoute(path) {
         if (!isScriptModule(info.relativePath)) return;
     }
     const modules = await getSharedModules("shared");
+    const routePath = join("app", "api", "action", "[...action]", "route.ts");
     await writeGeneratedFile({
-        path: join("app", "api", "action", "[...action]", "route.ts"),
-        content: getRouteFileContent(modules)
+        path: routePath,
+        content: await getRouteFileContent(modules, routePath)
     });
 }
 async function getSharedModules(dir) {
@@ -33,12 +35,16 @@ async function getSharedModules(dir) {
     modules.sort((a, b)=>a.importPath.localeCompare(b.importPath));
     return modules;
 }
-function getRouteFileContent(items) {
-    const importLines = items.map((item)=>`import { ${item.name} } from "@/shared/${item.importPath}"`).join("\n");
+async function getRouteFileContent(items, routePath) {
+    const createRouteFnImportPath = await resolveProjectImportPath(routePath, "server/createResponseFn");
+    const importLines = (await Promise.all(items.map(async (item)=>{
+        const importPath = await resolveProjectImportPath(routePath, `shared/${item.importPath}`);
+        return `import { ${item.name} } from "${importPath}"`;
+    }))).join("\n");
     const registerLines = items.map((item)=>`registerRoute(${item.name})`).join("\n");
     return `import { NextRequest, NextResponse } from "next/server"
 
-import { createRouteFn, OriginalResponseFn, RouteBodyType, RouteHandler } from "@/server/createResponseFn"
+import { createRouteFn, OriginalResponseFn, RouteBodyType, RouteHandler } from "${createRouteFnImportPath}"
 ${importLines ? `\n${importLines}\n` : ""}
 const routeMap = new Map<string, RouteHandler>()
 

package/dist/utils/hook.js

@@ -3,6 +3,7 @@ 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 { resolveProjectImportPath } from "./resolveProjectImportPath.js";
 import { isScriptModule, normalizePathSeparator, writeGeneratedFile } from "./sharedArtifact.js";
 import { writeSdNextSetting } from "./writeSdNextSetting.js";
 function getHookTypeFromName(name) {
@@ -20,7 +21,7 @@ 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("createUse") && content.includes("@/presets/")) return "mutation";
+    if (content.includes("createUse") && /from\s+["'][^"']*\/presets\//.test(content)) return "mutation";
     if (content.includes("ClientOptional")) return "get";
     if (content.includes("useQuery")) return "query";
 }
@@ -51,11 +52,15 @@ async function createHook(path, hookMap) {
     const mutationPresetPath = join("presets", dir, mutationPresetName);
     const mutationPresetImportPath = normalizePathSeparator(join(dir, `createUse${upName}`));
     const clientInputType = `${upName}ClientInput`;
+    const actionPath = normalizePathSeparator(join("actions", actionImportPath));
+    const hookActionImportPath = await resolveProjectImportPath(hookPath, actionPath);
+    const hookPresetImportPath = await resolveProjectImportPath(hookPath, normalizePathSeparator(join("presets", mutationPresetImportPath)));
+    const mutationPresetSharedImportPath = await resolveProjectImportPath(mutationPresetPath, normalizePathSeparator(join("shared", actionImportPath)));
     const mutationHook = `import { createRequestFn } from "deepsea-tools"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
-import { createUse${upName} } from "@/presets/${mutationPresetImportPath}"
+import { createUse${upName} } from "${hookPresetImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -65,7 +70,7 @@ export const use${upName} = createUse${upName}(${name}Client)
 
 import { withUseMutationDefaults } from "soda-tanstack-query"
 
-import { ${name} } from "@/shared/${actionImportPath}"
+import { ${name} } from "${mutationPresetSharedImportPath}"
 
 export const createUse${upName} = withUseMutationDefaults<typeof ${name}>(() => {
     const key = useId()
@@ -99,7 +104,7 @@ export const createUse${upName} = withUseMutationDefaults<typeof ${name}>(() =>
     const getHook = `import { createRequestFn, isNonNullable } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -117,7 +122,7 @@ export const use${upName} = createUseQuery({
     const queryHook = `import { createRequestFn } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 

package/dist/utils/resolveProjectImportPath.d.ts

@@ -0,0 +1 @@
+export declare function resolveProjectImportPath(fromPath: string, targetPath: string): Promise<string>;

package/dist/utils/resolveProjectImportPath.js

@@ -0,0 +1,201 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
+import { cwd } from "node:process";
+import { normalizePathSeparator } from "./sharedArtifact.js";
+const resolveProjectImportPath_require = createRequire(import.meta.url);
+const projectRoot = cwd();
+let rootAliasPromise;
+async function resolveProjectImportPath(fromPath, targetPath) {
+    const normalizedTargetPath = normalizePathSeparator(targetPath).replace(/^\.?\//, "");
+    const rootAlias = await getProjectRootAlias();
+    if (rootAlias) return `${rootAlias}/${normalizedTargetPath}`;
+    return getRelativeImportPath(fromPath, normalizedTargetPath);
+}
+function getRelativeImportPath(fromPath, targetPath) {
+    const fromDir = dirname(fromPath);
+    let importPath = normalizePathSeparator(relative(fromDir, targetPath));
+    if (!importPath.startsWith(".")) importPath = `./${importPath}`;
+    return importPath;
+}
+async function getProjectRootAlias() {
+    rootAliasPromise ??= resolveProjectRootAlias();
+    return rootAliasPromise;
+}
+async function resolveProjectRootAlias() {
+    const configPath = await findProjectConfigPath(projectRoot);
+    if (!configPath) return;
+    return readRootAliasFromConfig(configPath, new Set());
+}
+async function findProjectConfigPath(path) {
+    const candidates = [
+        join(path, "tsconfig.json"),
+        join(path, "jsconfig.json")
+    ];
+    for (const candidate of candidates)if (await exists(candidate)) return candidate;
+}
+async function readRootAliasFromConfig(configPath, seen) {
+    const normalizedPath = normalize(configPath);
+    if (seen.has(normalizedPath)) return;
+    seen.add(normalizedPath);
+    const config = await readJsonConfig(configPath);
+    const compilerOptions = toObject(config.compilerOptions);
+    const configDir = dirname(configPath);
+    const baseDir = getBaseDir(configDir, compilerOptions.baseUrl);
+    const paths = toPathMap(compilerOptions.paths);
+    if (paths) {
+        const rootAlias = findRootAlias(paths, baseDir, projectRoot);
+        if (rootAlias) return rootAlias;
+    }
+    const extendsValue = "string" == typeof config.extends ? config.extends : void 0;
+    if (!extendsValue) return;
+    const extendsPath = await resolveExtendsPath(extendsValue, configDir);
+    if (!extendsPath) return;
+    return readRootAliasFromConfig(extendsPath, seen);
+}
+function getBaseDir(configDir, baseUrl) {
+    if ("string" != typeof baseUrl) return configDir;
+    return resolve(configDir, baseUrl);
+}
+function findRootAlias(paths, baseDir, rootDir) {
+    for (const [key, targets] of Object.entries(paths)){
+        const alias = getAliasName(key);
+        if (alias) {
+            for (const target of targets)if (isRootTarget(target, baseDir, rootDir)) return alias;
+        }
+    }
+}
+function getAliasName(pattern) {
+    const wildcard = splitWildcard(pattern);
+    if (!wildcard || wildcard.suffix.length > 0) return;
+    const aliasPrefix = wildcard.prefix.replace(/\/$/, "");
+    if (!aliasPrefix) return;
+    return aliasPrefix;
+}
+function isRootTarget(pattern, baseDir, rootDir) {
+    const wildcard = splitWildcard(pattern);
+    if (!wildcard || wildcard.suffix.length > 0) return false;
+    const targetPath = resolve(baseDir, wildcard.prefix || ".");
+    return normalizeForComparison(targetPath) === normalizeForComparison(rootDir);
+}
+function splitWildcard(value) {
+    const index = value.indexOf("*");
+    if (index < 0) return;
+    if (value.indexOf("*", index + 1) >= 0) return;
+    return {
+        prefix: value.slice(0, index),
+        suffix: value.slice(index + 1)
+    };
+}
+async function resolveExtendsPath(extendsValue, baseDir) {
+    if (isAbsolute(extendsValue) || extendsValue.startsWith(".")) {
+        const relativeCandidates = getRelativeCandidates(resolve(baseDir, extendsValue));
+        for (const candidate of relativeCandidates)if (await exists(candidate)) return candidate;
+        return;
+    }
+    const moduleCandidates = getModuleCandidates(extendsValue);
+    for (const candidate of moduleCandidates)try {
+        return resolveProjectImportPath_require.resolve(candidate, {
+            paths: [
+                baseDir
+            ]
+        });
+    } catch (error) {}
+}
+function getRelativeCandidates(path) {
+    if (path.endsWith(".json")) return [
+        path
+    ];
+    return [
+        path,
+        `${path}.json`
+    ];
+}
+function getModuleCandidates(path) {
+    if (path.endsWith(".json")) return [
+        path
+    ];
+    return [
+        path,
+        `${path}.json`
+    ];
+}
+async function readJsonConfig(path) {
+    const content = await readFile(path, "utf-8");
+    const parsed = JSON.parse(stripTrailingCommas(stripComments(content)));
+    return toObject(parsed);
+}
+function stripComments(content) {
+    const output = [];
+    let inString = false;
+    let escaped = false;
+    for(let index = 0; index < content.length; index++){
+        const char = content[index];
+        const next = content[index + 1];
+        if (inString) {
+            output.push(char);
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if ("\\" === char) {
+                escaped = true;
+                continue;
+            }
+            if ("\"" === char) inString = false;
+            continue;
+        }
+        if ("\"" === char) {
+            inString = true;
+            output.push(char);
+            continue;
+        }
+        if ("/" === char && "/" === next) {
+            while(index < content.length && "\n" !== content[index])index++;
+            output.push("\n");
+            continue;
+        }
+        if ("/" === char && "*" === next) {
+            index += 2;
+            while(index < content.length && !("*" === content[index] && "/" === content[index + 1]))index++;
+            index++;
+            continue;
+        }
+        output.push(char);
+    }
+    return output.join("").replace(/^\uFEFF/, "");
+}
+function stripTrailingCommas(content) {
+    return content.replace(/,\s*([}\]])/g, "$1");
+}
+function toPathMap(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return;
+    const entries = [];
+    for (const [key, item] of Object.entries(value)){
+        if (!Array.isArray(item)) continue;
+        const list = item.filter((target)=>"string" == typeof target);
+        if (0 !== list.length) entries.push([
+            key,
+            list
+        ]);
+    }
+    if (0 === entries.length) return;
+    return Object.fromEntries(entries);
+}
+function toObject(value) {
+    if (value && "object" == typeof value && !Array.isArray(value)) return value;
+    return {};
+}
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+function normalizeForComparison(path) {
+    return normalize(path).replace(/\\/g, "/").replace(/\/$/, "").toLowerCase();
+}
+export { resolveProjectImportPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdnext",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "",
   "type": "module",
   "exports": {

package/src/utils/createAction.ts

@@ -1,5 +1,6 @@
 import { join } from "path"
 
+import { resolveProjectImportPath } from "./resolveProjectImportPath"
 import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact"
 
 export async function createAction(path: string) {
@@ -7,13 +8,17 @@ export async function createAction(path: string) {
 
     if (!isScriptModule(info.relativePath)) return
 
+    const actionPath = join("actions", info.relativePath)
+    const createResponseFnImportPath = await resolveProjectImportPath(actionPath, "server/createResponseFn")
+    const sharedImportPath = await resolveProjectImportPath(actionPath, `shared/${info.importPath}`)
+
     await writeGeneratedFile({
-        path: join("actions", info.relativePath),
+        path: actionPath,
         content: `"use server"
 
-import { createResponseFn } from "@/server/createResponseFn"
+import { createResponseFn } from "${createResponseFnImportPath}"
 
-import { ${info.name} } from "@/shared/${info.importPath}"
+import { ${info.name} } from "${sharedImportPath}"
 
 export const ${info.name}Action = createResponseFn(${info.name})
 `

package/src/utils/createRoute.ts

@@ -1,6 +1,7 @@
 import { readdir } from "fs/promises"
 import { join } from "path"
 
+import { resolveProjectImportPath } from "./resolveProjectImportPath"
 import { getSharedModuleInfo, isScriptModule, writeGeneratedFile } from "./sharedArtifact"
 
 export async function createRoute(path?: string) {
@@ -10,10 +11,11 @@ export async function createRoute(path?: string) {
     }
 
     const modules = await getSharedModules("shared")
+    const routePath = join("app", "api", "action", "[...action]", "route.ts")
 
     await writeGeneratedFile({
-        path: join("app", "api", "action", "[...action]", "route.ts"),
-        content: getRouteFileContent(modules),
+        path: routePath,
+        content: await getRouteFileContent(modules, routePath),
     })
 }
 
@@ -55,13 +57,17 @@ export interface GetRouteFileContentParamsItem {
     name: string
 }
 
-function getRouteFileContent(items: GetRouteFileContentParamsItem[]) {
-    const importLines = items.map(item => `import { ${item.name} } from "@/shared/${item.importPath}"`).join("\n")
+async function getRouteFileContent(items: GetRouteFileContentParamsItem[], routePath: string) {
+    const createRouteFnImportPath = await resolveProjectImportPath(routePath, "server/createResponseFn")
+    const importLines = (await Promise.all(items.map(async (item) => {
+        const importPath = await resolveProjectImportPath(routePath, `shared/${item.importPath}`)
+        return `import { ${item.name} } from "${importPath}"`
+    }))).join("\n")
     const registerLines = items.map(item => `registerRoute(${item.name})`).join("\n")
 
     return `import { NextRequest, NextResponse } from "next/server"
 
-import { createRouteFn, OriginalResponseFn, RouteBodyType, RouteHandler } from "@/server/createResponseFn"
+import { createRouteFn, OriginalResponseFn, RouteBodyType, RouteHandler } from "${createRouteFnImportPath}"
 ${importLines ? `\n${importLines}\n` : ""}
 const routeMap = new Map<string, RouteHandler>()
 

package/src/utils/hook.ts

@@ -6,6 +6,7 @@ import { checkbox, select } from "@inquirer/prompts"
 import { Command } from "commander"
 
 import { readSdNextSetting, SdNextSetting } from "./readSdNextSetting"
+import { resolveProjectImportPath } from "./resolveProjectImportPath"
 import { isScriptModule, normalizePathSeparator, writeGeneratedFile } from "./sharedArtifact"
 import { writeSdNextSetting } from "./writeSdNextSetting"
 
@@ -33,7 +34,7 @@ async function getHookTypeFromContent(path: string, content: string): Promise<Ho
     const type = setting.hook?.[path]
     if (type !== undefined && type !== "skip") return type
     if (content.includes("useMutation")) return "mutation"
-    if (content.includes("createUse") && content.includes("@/presets/")) return "mutation"
+    if (content.includes("createUse") && /from\s+["'][^"']*\/presets\//.test(content)) return "mutation"
     if (content.includes("ClientOptional")) return "get"
     if (content.includes("useQuery")) return "query"
     return undefined
@@ -81,12 +82,16 @@ export async function createHook(path: string, hookMap: Record<string, HookData>
     const mutationPresetPath = join("presets", dir, mutationPresetName)
     const mutationPresetImportPath = normalizePathSeparator(join(dir, `createUse${upName}`))
     const clientInputType = `${upName}ClientInput`
+    const actionPath = normalizePathSeparator(join("actions", actionImportPath))
+    const hookActionImportPath = await resolveProjectImportPath(hookPath, actionPath)
+    const hookPresetImportPath = await resolveProjectImportPath(hookPath, normalizePathSeparator(join("presets", mutationPresetImportPath)))
+    const mutationPresetSharedImportPath = await resolveProjectImportPath(mutationPresetPath, normalizePathSeparator(join("shared", actionImportPath)))
 
     const mutationHook = `import { createRequestFn } from "deepsea-tools"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
-import { createUse${upName} } from "@/presets/${mutationPresetImportPath}"
+import { createUse${upName} } from "${hookPresetImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -97,7 +102,7 @@ export const use${upName} = createUse${upName}(${name}Client)
 
 import { withUseMutationDefaults } from "soda-tanstack-query"
 
-import { ${name} } from "@/shared/${actionImportPath}"
+import { ${name} } from "${mutationPresetSharedImportPath}"
 
 export const createUse${upName} = withUseMutationDefaults<typeof ${name}>(() => {
     const key = useId()
@@ -132,7 +137,7 @@ export const createUse${upName} = withUseMutationDefaults<typeof ${name}>(() =>
     const getHook = `import { createRequestFn, isNonNullable } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 
@@ -151,7 +156,7 @@ export const use${upName} = createUseQuery({
     const queryHook = `import { createRequestFn } from "deepsea-tools"
 import { createUseQuery } from "soda-tanstack-query"
 
-import { ${name}Action } from "@/actions/${actionImportPath}"
+import { ${name}Action } from "${hookActionImportPath}"
 
 export const ${name}Client = createRequestFn(${name}Action)
 

package/src/utils/resolveProjectImportPath.ts

@@ -0,0 +1,256 @@
+import { constants } from "node:fs"
+import { access, readFile } from "node:fs/promises"
+import { createRequire } from "node:module"
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path"
+import { cwd } from "node:process"
+
+import { normalizePathSeparator } from "./sharedArtifact"
+
+const require = createRequire(import.meta.url)
+
+const projectRoot = cwd()
+
+let rootAliasPromise: Promise<string | undefined> | undefined
+
+export async function resolveProjectImportPath(fromPath: string, targetPath: string) {
+    const normalizedTargetPath = normalizePathSeparator(targetPath).replace(/^\.?\//, "")
+    const rootAlias = await getProjectRootAlias()
+
+    if (rootAlias) return `${rootAlias}/${normalizedTargetPath}`
+
+    return getRelativeImportPath(fromPath, normalizedTargetPath)
+}
+
+function getRelativeImportPath(fromPath: string, targetPath: string) {
+    const fromDir = dirname(fromPath)
+    let importPath = normalizePathSeparator(relative(fromDir, targetPath))
+
+    if (!importPath.startsWith(".")) importPath = `./${importPath}`
+
+    return importPath
+}
+
+async function getProjectRootAlias() {
+    rootAliasPromise ??= resolveProjectRootAlias()
+    return rootAliasPromise
+}
+
+async function resolveProjectRootAlias() {
+    const configPath = await findProjectConfigPath(projectRoot)
+    if (!configPath) return undefined
+
+    return readRootAliasFromConfig(configPath, new Set())
+}
+
+async function findProjectConfigPath(path: string) {
+    const candidates = [join(path, "tsconfig.json"), join(path, "jsconfig.json")]
+
+    for (const candidate of candidates) {
+        if (await exists(candidate)) return candidate
+    }
+
+    return undefined
+}
+
+async function readRootAliasFromConfig(configPath: string, seen: Set<string>): Promise<string | undefined> {
+    const normalizedPath = normalize(configPath)
+    if (seen.has(normalizedPath)) return undefined
+    seen.add(normalizedPath)
+
+    const config = await readJsonConfig(configPath)
+    const compilerOptions = toObject(config.compilerOptions)
+    const configDir = dirname(configPath)
+    const baseDir = getBaseDir(configDir, compilerOptions.baseUrl)
+    const paths = toPathMap(compilerOptions.paths)
+
+    if (paths) {
+        const rootAlias = findRootAlias(paths, baseDir, projectRoot)
+        if (rootAlias) return rootAlias
+    }
+
+    const extendsValue = typeof config.extends === "string" ? config.extends : undefined
+    if (!extendsValue) return undefined
+
+    const extendsPath = await resolveExtendsPath(extendsValue, configDir)
+    if (!extendsPath) return undefined
+
+    return readRootAliasFromConfig(extendsPath, seen)
+}
+
+function getBaseDir(configDir: string, baseUrl: unknown) {
+    if (typeof baseUrl !== "string") return configDir
+    return resolve(configDir, baseUrl)
+}
+
+function findRootAlias(paths: Record<string, string[]>, baseDir: string, rootDir: string) {
+    for (const [key, targets] of Object.entries(paths)) {
+        const alias = getAliasName(key)
+        if (!alias) continue
+
+        for (const target of targets) {
+            if (!isRootTarget(target, baseDir, rootDir)) continue
+            return alias
+        }
+    }
+
+    return undefined
+}
+
+function getAliasName(pattern: string) {
+    const wildcard = splitWildcard(pattern)
+    if (!wildcard || wildcard.suffix.length > 0) return undefined
+
+    const aliasPrefix = wildcard.prefix.replace(/\/$/, "")
+    if (!aliasPrefix) return undefined
+
+    return aliasPrefix
+}
+
+function isRootTarget(pattern: string, baseDir: string, rootDir: string) {
+    const wildcard = splitWildcard(pattern)
+    if (!wildcard || wildcard.suffix.length > 0) return false
+
+    const targetPath = resolve(baseDir, wildcard.prefix || ".")
+
+    return normalizeForComparison(targetPath) === normalizeForComparison(rootDir)
+}
+
+function splitWildcard(value: string) {
+    const index = value.indexOf("*")
+    if (index < 0) return undefined
+    if (value.indexOf("*", index + 1) >= 0) return undefined
+
+    return {
+        prefix: value.slice(0, index),
+        suffix: value.slice(index + 1),
+    }
+}
+
+async function resolveExtendsPath(extendsValue: string, baseDir: string) {
+    if (isAbsolute(extendsValue) || extendsValue.startsWith(".")) {
+        const relativeCandidates = getRelativeCandidates(resolve(baseDir, extendsValue))
+        for (const candidate of relativeCandidates) {
+            if (await exists(candidate)) return candidate
+        }
+
+        return undefined
+    }
+
+    const moduleCandidates = getModuleCandidates(extendsValue)
+
+    for (const candidate of moduleCandidates) {
+        try {
+            return require.resolve(candidate, { paths: [baseDir] })
+        } catch (error) {}
+    }
+
+    return undefined
+}
+
+function getRelativeCandidates(path: string) {
+    if (path.endsWith(".json")) return [path]
+    return [path, `${path}.json`]
+}
+
+function getModuleCandidates(path: string) {
+    if (path.endsWith(".json")) return [path]
+    return [path, `${path}.json`]
+}
+
+async function readJsonConfig(path: string): Promise<JsonObject> {
+    const content = await readFile(path, "utf-8")
+    const parsed = JSON.parse(stripTrailingCommas(stripComments(content)))
+    return toObject(parsed)
+}
+
+function stripComments(content: string) {
+    const output: string[] = []
+    let inString = false
+    let escaped = false
+
+    for (let index = 0; index < content.length; index++) {
+        const char = content[index]
+        const next = content[index + 1]
+
+        if (inString) {
+            output.push(char)
+            if (escaped) {
+                escaped = false
+                continue
+            }
+
+            if (char === "\\") {
+                escaped = true
+                continue
+            }
+
+            if (char === "\"") inString = false
+
+            continue
+        }
+
+        if (char === "\"") {
+            inString = true
+            output.push(char)
+            continue
+        }
+
+        if (char === "/" && next === "/") {
+            while (index < content.length && content[index] !== "\n") index++
+            output.push("\n")
+            continue
+        }
+
+        if (char === "/" && next === "*") {
+            index += 2
+            while (index < content.length && !(content[index] === "*" && content[index + 1] === "/")) index++
+            index++
+            continue
+        }
+
+        output.push(char)
+    }
+
+    return output.join("").replace(/^\uFEFF/, "")
+}
+
+function stripTrailingCommas(content: string) {
+    return content.replace(/,\s*([}\]])/g, "$1")
+}
+
+function toPathMap(value: unknown): Record<string, string[]> | undefined {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return undefined
+
+    const entries: [string, string[]][] = []
+
+    for (const [key, item] of Object.entries(value)) {
+        if (!Array.isArray(item)) continue
+        const list = item.filter((target): target is string => typeof target === "string")
+        if (list.length === 0) continue
+        entries.push([key, list])
+    }
+
+    if (entries.length === 0) return undefined
+
+    return Object.fromEntries(entries)
+}
+
+function toObject(value: unknown): JsonObject {
+    if (value && typeof value === "object" && !Array.isArray(value)) return value as JsonObject
+    return {}
+}
+
+async function exists(path: string) {
+    try {
+        await access(path, constants.F_OK)
+        return true
+    } catch (error) {
+        return false
+    }
+}
+
+function normalizeForComparison(path: string) {
+    return normalize(path).replace(/\\/g, "/").replace(/\/$/, "").toLowerCase()
+}
+
+type JsonObject = Record<string, unknown>