pruny 1.43.9 → 1.44.0

package/dist/index.js

@@ -12564,7 +12564,7 @@ var source_default = chalk;
 // src/index.ts
 var import_prompts = __toESM(require_prompts3(), 1);
 import { rmSync, existsSync as existsSync11, readdirSync, lstatSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname6, join as join11, relative as relative5, resolve as resolve4 } from "node:path";
+import { dirname as dirname7, join as join11, relative as relative5, resolve as resolve5 } from "node:path";
 
 // src/scanner.ts
 var import_fast_glob10 = __toESM(require_out4(), 1);
@@ -15886,16 +15886,16 @@ async function scanUnusedServices(config) {
 
 // src/scanners/broken-links.ts
 var import_fast_glob9 = __toESM(require_out4(), 1);
-import { readFileSync as readFileSync9, existsSync as existsSync7 } from "node:fs";
-import { join as join7 } from "node:path";
+import { readFileSync as readFileSync9, existsSync as existsSync7, statSync as statSync2 } from "node:fs";
+import { dirname as dirname5, join as join7, resolve as resolve3 } from "node:path";
 var LINK_PATTERNS = [
-  /<Link\s+[^>]*href\s*=\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
-  /router\.(push|replace)\s*\(\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
-  /(?:redirect|permanentRedirect)\s*\(\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
-  /href\s*:\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
-  /<a\s+[^>]*href\s*=\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
-  /revalidatePath\s*\(\s*['"`](\/[^'"`\s{}$]+)['"`]/g,
-  /pathname\s*===?\s*['"`](\/[^'"`\s{}$]+)['"`]/g
+  /<Link\s+[^>]*href\s*=\s*(?:\{\s*)?['"`](\/[^'"`\s]+)['"`](?:\s*\})?/g,
+  /router\.(push|replace)\s*\(\s*['"`](\/[^'"`\s]+)['"`]/g,
+  /(?:redirect|permanentRedirect)\s*\(\s*['"`](\/[^'"`\s]+)['"`]/g,
+  /href\s*:\s*['"`](\/[^'"`\s]+)['"`]/g,
+  /<a\s+[^>]*href\s*=\s*(?:\{\s*)?['"`](\/[^'"`\s]+)['"`](?:\s*\})?/g,
+  /revalidatePath\s*\(\s*['"`](\/[^'"`\s]+)['"`]/g,
+  /pathname\s*===?\s*['"`](\/[^'"`\s]+)['"`]/g
 ];
 function extractPath(match2) {
   if (match2[2] && match2[2].startsWith("/"))
@@ -15904,6 +15904,11 @@ function extractPath(match2) {
     return match2[1];
   return null;
 }
+function normalizePath(raw) {
+  let out = raw.replace(/\$\{[^}]*\}/g, "[id]");
+  out = out.replace(/[{}]/g, "");
+  return out;
+}
 function shouldSkipPath(path2) {
   if (/^https?:\/\//.test(path2))
     return true;
@@ -15939,15 +15944,15 @@ function filePathToRoute(filePath) {
   });
   return "/" + segments.join("/");
 }
-function matchesRoute(refPath, routes, routeSegments) {
+function matchesRoute(refPath, routes, routes_) {
   const cleaned = cleanPath(refPath);
   if (routes.has(cleaned))
     return true;
   const refSegments = cleaned.split("/").filter(Boolean);
-  for (const routeSeg of routeSegments) {
-    if (matchSegments(refSegments, routeSeg))
+  for (const route of routes_) {
+    if (matchSegments(refSegments, route.segments, route.params))
       return true;
-    if (matchesDynamicSuffix(refSegments, routeSeg))
+    if (matchesDynamicSuffix(refSegments, route.segments))
       return true;
   }
   return false;
@@ -15965,14 +15970,29 @@ function matchesDynamicSuffix(refSegments, routeSegments) {
     return false;
   return matchSegments(refSegments, tail);
 }
-function matchSegments(refSegments, routeSegments) {
+function matchSegments(refSegments, routeSegments, params) {
   let ri = 0;
   let si = 0;
   while (ri < refSegments.length && si < routeSegments.length) {
     const routeSeg = routeSegments[si];
     if (/^\[\[?\.\.\./.test(routeSeg))
       return true;
-    if (/^\[.+\]$/.test(routeSeg)) {
+    const dynMatch = /^\[(.+)\]$/.exec(routeSeg);
+    if (dynMatch) {
+      const paramName = dynMatch[1];
+      if (params && params[paramName]) {
+        const ref = refSegments[ri];
+        const allowed = params[paramName];
+        let ok = false;
+        for (const v of allowed) {
+          if (v.toLowerCase() === ref.toLowerCase()) {
+            ok = true;
+            break;
+          }
+        }
+        if (!ok)
+          return false;
+      }
       ri++;
       si++;
       continue;
@@ -15997,7 +16017,7 @@ function isGitignoredPublicFile(appDir, linkPath) {
       continue;
     try {
       const patterns = readFileSync9(gitignorePath, "utf-8").split(`
-`).map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+`).map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("!"));
       for (const pattern of patterns) {
         if (minimatch(publicRelPath, pattern, { dot: true }) || minimatch(linkPath.slice(1), pattern, { dot: true }) || minimatch(`**/public${linkPath}`, pattern, { dot: true })) {
           return true;
@@ -16025,12 +16045,21 @@ async function scanBrokenLinks(config) {
   const knownRoutes = new Set;
   const routeSegmentsList = [];
   knownRoutes.add("/");
+  const aliasMap = parseTsConfigPaths(appDir);
   for (const file of pageFiles) {
     const route = filePathToRoute(file);
     knownRoutes.add(route);
     const segments = route.split("/").filter(Boolean);
     if (segments.some((s) => s.startsWith("["))) {
-      routeSegmentsList.push(segments);
+      const absFile = join7(appDir, file);
+      const params = resolveStaticParams(absFile, appDir, aliasMap);
+      routeSegmentsList.push({ segments, params: params ?? undefined });
+      if (process.env.DEBUG_PRUNY) {
+        if (params) {
+          const summary = Object.entries(params).map(([k, v]) => `${k}=${v.size}`).join(", ");
+          console.log(`[DEBUG] Static params for ${route}: ${summary}`);
+        }
+      }
     }
   }
   if (process.env.DEBUG_PRUNY) {
@@ -16073,9 +16102,10 @@ async function scanBrokenLinks(config) {
         pattern.lastIndex = 0;
         let match2;
         while ((match2 = pattern.exec(content)) !== null) {
-          const rawPath = extractPath(match2);
-          if (!rawPath)
+          const extracted = extractPath(match2);
+          if (!extracted)
             continue;
+          const rawPath = normalizePath(extracted);
           if (shouldSkipPath(rawPath))
             continue;
           const cleaned = cleanPath(rawPath);
@@ -16123,6 +16153,632 @@ async function scanBrokenLinks(config) {
     links
   };
 }
+var TS_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var JSON_EXT = ".json";
+function resolveStaticParams(routeFile, appDir, aliasMap) {
+  let content;
+  try {
+    content = readFileSync9(routeFile, "utf-8");
+  } catch {
+    return null;
+  }
+  const body = extractFunctionBody(content, "generateStaticParams");
+  if (!body)
+    return null;
+  const returnExpr = extractReturnExpression(body);
+  if (!returnExpr)
+    return null;
+  return resolveParamsExpression(returnExpr, content, routeFile, appDir, aliasMap, new Set, 0);
+}
+function extractFunctionBody(source, name) {
+  const fnRe = new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${name}\\s*\\([^)]*\\)\\s*\\{`, "g");
+  let m = fnRe.exec(source);
+  if (m) {
+    return readBalanced(source, m.index + m[0].length - 1);
+  }
+  const arrowRe = new RegExp(`(?:export\\s+)?const\\s+${name}\\s*=\\s*(?:async\\s*)?\\([^)]*\\)\\s*=>\\s*\\{`, "g");
+  m = arrowRe.exec(source);
+  if (m) {
+    return readBalanced(source, m.index + m[0].length - 1);
+  }
+  return null;
+}
+function readBalanced(source, start) {
+  if (source[start] !== "{")
+    return null;
+  let depth = 0;
+  let i = start;
+  let inString = null;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (;i < source.length; i++) {
+    const c = source[i];
+    const next = source[i + 1];
+    if (inLineComment) {
+      if (c === `
+`)
+        inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (c === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === inString)
+        inString = null;
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      continue;
+    }
+    if (c === "{")
+      depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0)
+        return source.slice(start + 1, i);
+    }
+  }
+  return null;
+}
+function extractReturnExpression(body) {
+  const re = /\breturn\s+([\s\S]+?)(?:;|$)/g;
+  let last = null;
+  let m;
+  while ((m = re.exec(body)) !== null)
+    last = m;
+  if (!last)
+    return null;
+  return last[1].trim();
+}
+function resolveParamsExpression(expr, fileContent, filePath, appDir, aliasMap, visited, depth) {
+  if (depth > 4)
+    return null;
+  expr = expr.trim();
+  if (expr.startsWith("[")) {
+    const arrText = sliceTopLevelArray(expr);
+    if (arrText) {
+      const tail = expr.slice(arrText.length).trim();
+      if (!tail) {
+        const arr = parseObjectArray(arrText);
+        if (arr)
+          return mergeParams(arr);
+      }
+      if (tail.startsWith(".map")) {
+        const stringArr = parseStringArray(arrText);
+        if (stringArr) {
+          const paramName = inferParamFromMap(expr) ?? "slug";
+          return { [paramName]: new Set(stringArr) };
+        }
+        const objArr = parseObjectArray(arrText);
+        if (objArr) {
+          const projection = extractMapProjection(expr);
+          if (!projection)
+            return null;
+          const out = {};
+          for (const [param, source] of Object.entries(projection)) {
+            const parts = source.split(".");
+            parts.shift();
+            const values = [];
+            for (const obj of objArr) {
+              let v = obj;
+              for (const p of parts) {
+                if (v && typeof v === "object" && p in v) {
+                  v = v[p];
+                } else {
+                  v = undefined;
+                  break;
+                }
+              }
+              if (typeof v === "string")
+                values.push(v);
+            }
+            if (values.length > 0)
+              out[param] = new Set(values);
+          }
+          return Object.keys(out).length > 0 ? out : null;
+        }
+      }
+    }
+  }
+  const objKeysM = /^Object\.(keys|entries)\s*\(\s*([A-Za-z_$][\w$]*)\s*\)/.exec(expr);
+  if (objKeysM) {
+    const ident = objKeysM[2];
+    const keys = resolveIdentifierKeys(ident, fileContent, filePath, appDir, aliasMap, visited, depth);
+    if (!keys)
+      return null;
+    const paramName = inferParamFromMap(expr) ?? guessFirstParamName(expr) ?? "slug";
+    return { [paramName]: new Set(keys) };
+  }
+  const identMapM = /^([A-Za-z_$][\w$]*)\s*\.\s*map\s*\(/.exec(expr);
+  if (identMapM) {
+    const ident = identMapM[1];
+    const resolved = resolveIdentifierAsArray(ident, fileContent, filePath, appDir, aliasMap, visited, depth);
+    if (!resolved)
+      return null;
+    if (resolved.kind === "strings") {
+      const paramName = inferParamFromMap(expr) ?? "slug";
+      return { [paramName]: new Set(resolved.values) };
+    }
+    if (resolved.kind === "objects") {
+      const projection = extractMapProjection(expr);
+      if (!projection)
+        return null;
+      const out = {};
+      for (const [param, source] of Object.entries(projection)) {
+        const values = [];
+        for (const obj of resolved.values) {
+          const parts = source.split(".");
+          parts.shift();
+          let v = obj;
+          for (const p of parts) {
+            if (v && typeof v === "object" && p in v) {
+              v = v[p];
+            } else {
+              v = undefined;
+              break;
+            }
+          }
+          if (typeof v === "string")
+            values.push(v);
+        }
+        if (values.length > 0)
+          out[param] = new Set(values);
+      }
+      return Object.keys(out).length > 0 ? out : null;
+    }
+    if (resolved.kind === "objectKeys") {
+      const paramName = inferParamFromMap(expr) ?? "slug";
+      return { [paramName]: new Set(resolved.values) };
+    }
+  }
+  return null;
+}
+function extractMapProjection(expr) {
+  const bodyMatch = /\.map\s*\(\s*(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*=>\s*\(?\s*\{([^}]+)\}/.exec(expr);
+  if (!bodyMatch)
+    return null;
+  const iter = (bodyMatch[1] ?? bodyMatch[2] ?? "").trim().split(",")[0].trim() || "item";
+  const objBody = bodyMatch[3];
+  const out = {};
+  const propRe = /([A-Za-z_$][\w$]*)\s*(?::\s*([A-Za-z_$][\w$.]*))?/g;
+  let m;
+  while ((m = propRe.exec(objBody)) !== null) {
+    const key = m[1];
+    const value = m[2] ?? key;
+    out[key] = value.startsWith(iter + ".") || value === iter ? value : `${iter}.${value}`;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function inferParamFromMap(expr) {
+  const m = /=>\s*\(?\s*\{\s*([A-Za-z_$][\w$]*)\s*[:}]/.exec(expr);
+  return m ? m[1] : null;
+}
+function guessFirstParamName(expr) {
+  const m = /\{\s*([A-Za-z_$][\w$]*)\s*\}/.exec(expr);
+  return m ? m[1] : null;
+}
+function mergeParams(items) {
+  const out = {};
+  for (const item of items) {
+    for (const [k, v] of Object.entries(item)) {
+      if (typeof v !== "string")
+        continue;
+      if (!out[k])
+        out[k] = new Set;
+      out[k].add(v);
+    }
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function parseObjectArray(expr) {
+  const arrText = sliceTopLevelArray(expr);
+  if (!arrText)
+    return null;
+  const inner = arrText.slice(1, -1).trim();
+  if (!inner)
+    return [];
+  const items = [];
+  let depth = 0;
+  let buf = "";
+  const chunks = [];
+  let inString = null;
+  for (let i = 0;i < inner.length; i++) {
+    const c = inner[i];
+    if (inString) {
+      if (c === "\\") {
+        buf += c + inner[++i];
+        continue;
+      }
+      if (c === inString)
+        inString = null;
+      buf += c;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      buf += c;
+      continue;
+    }
+    if (c === "{" || c === "[" || c === "(")
+      depth++;
+    else if (c === "}" || c === "]" || c === ")")
+      depth--;
+    if (c === "," && depth === 0) {
+      chunks.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += c;
+  }
+  if (buf.trim())
+    chunks.push(buf);
+  for (const chunk of chunks) {
+    const obj = parseSimpleObject(chunk.trim());
+    if (!obj)
+      return null;
+    items.push(obj);
+  }
+  return items;
+}
+function parseStringArray(arrText) {
+  if (!arrText.startsWith("[") || !arrText.endsWith("]"))
+    return null;
+  const inner = arrText.slice(1, -1).trim();
+  if (!inner)
+    return [];
+  if (/[{[]/.test(inner))
+    return null;
+  const out = [];
+  const re = /["'`]([^"'`]*)["'`]/g;
+  let m;
+  let count = 0;
+  while ((m = re.exec(inner)) !== null) {
+    out.push(m[1]);
+    count++;
+  }
+  const chunks = inner.split(",").filter((s) => s.trim()).length;
+  if (count !== chunks)
+    return null;
+  return out;
+}
+function sliceTopLevelArray(expr) {
+  if (expr[0] !== "[")
+    return null;
+  let depth = 0;
+  let inString = null;
+  for (let i = 0;i < expr.length; i++) {
+    const c = expr[i];
+    if (inString) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === inString)
+        inString = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      continue;
+    }
+    if (c === "[")
+      depth++;
+    else if (c === "]") {
+      depth--;
+      if (depth === 0)
+        return expr.slice(0, i + 1);
+    }
+  }
+  return null;
+}
+function parseSimpleObject(text) {
+  if (!text.startsWith("{") || !text.endsWith("}"))
+    return null;
+  const body = text.slice(1, -1);
+  const out = {};
+  const re = /([A-Za-z_$][\w$]*)\s*:\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`)/g;
+  let m;
+  let count = 0;
+  while ((m = re.exec(body)) !== null) {
+    out[m[1]] = m[2] ?? m[3] ?? m[4] ?? "";
+    count++;
+  }
+  return count > 0 ? out : null;
+}
+function resolveIdentifierKeys(ident, fileContent, filePath, appDir, aliasMap, visited, depth) {
+  const r = resolveIdentifier(ident, fileContent, filePath, appDir, aliasMap, visited, depth);
+  if (!r)
+    return null;
+  if (r.kind === "objectKeys")
+    return r.values;
+  if (r.kind === "objects") {
+    return null;
+  }
+  if (r.kind === "strings")
+    return r.values;
+  return null;
+}
+function resolveIdentifierAsArray(ident, fileContent, filePath, appDir, aliasMap, visited, depth) {
+  return resolveIdentifier(ident, fileContent, filePath, appDir, aliasMap, visited, depth);
+}
+function resolveIdentifier(ident, fileContent, filePath, appDir, aliasMap, visited, depth) {
+  if (depth > 5)
+    return null;
+  const visitKey = `${filePath}::${ident}`;
+  if (visited.has(visitKey))
+    return null;
+  visited.add(visitKey);
+  const localValue = findLocalConst(ident, fileContent);
+  if (localValue) {
+    const parsed = parseLiteralValue(localValue);
+    if (parsed)
+      return parsed;
+  }
+  const importInfo = findImport(ident, fileContent);
+  if (!importInfo)
+    return null;
+  const resolvedPath = resolveModulePath(importInfo.path, filePath, appDir, aliasMap);
+  if (!resolvedPath)
+    return null;
+  if (resolvedPath.endsWith(JSON_EXT)) {
+    try {
+      const data = JSON.parse(readFileSync9(resolvedPath, "utf-8"));
+      return literalToResolution(data);
+    } catch {
+      return null;
+    }
+  }
+  let nextContent;
+  try {
+    nextContent = readFileSync9(resolvedPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const nextIdent = importInfo.kind === "default" ? findDefaultExportIdentifier(nextContent) ?? ident : importInfo.imported;
+  return resolveIdentifier(nextIdent, nextContent, resolvedPath, appDir, aliasMap, visited, depth + 1);
+}
+function findImport(ident, source) {
+  const defRe = new RegExp(`import\\s+${ident}\\s+from\\s+['"]([^'"]+)['"]`, "g");
+  let m;
+  if ((m = defRe.exec(source)) !== null) {
+    return { kind: "default", imported: ident, path: m[1] };
+  }
+  const namedRe = /import\s*\{\s*([^}]+)\s*\}\s*from\s*['"]([^'"]+)['"]/g;
+  while ((m = namedRe.exec(source)) !== null) {
+    const specifiers = m[1].split(",").map((s) => s.trim());
+    for (const spec of specifiers) {
+      const aliasMatch = /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/.exec(spec);
+      if (aliasMatch) {
+        if (aliasMatch[2] === ident) {
+          return { kind: "named", imported: aliasMatch[1], path: m[2] };
+        }
+      } else if (spec === ident) {
+        return { kind: "named", imported: ident, path: m[2] };
+      }
+    }
+  }
+  return null;
+}
+function resolveModulePath(spec, fromFile, appDir, aliasMap) {
+  let candidates = [];
+  if (spec.startsWith(".")) {
+    candidates.push(resolve3(dirname5(fromFile), spec));
+  } else if (aliasMap.size > 0) {
+    for (const [prefix, targets] of aliasMap.entries()) {
+      if (spec === prefix.replace(/\/$/, "") || spec.startsWith(prefix)) {
+        const sub = spec.slice(prefix.length);
+        for (const t of targets) {
+          candidates.push(sub ? join7(t, sub) : t);
+        }
+      }
+    }
+  } else {
+    candidates.push(join7(appDir, spec));
+  }
+  for (const cand of candidates) {
+    if (existsSync7(cand)) {
+      try {
+        if (statSync2(cand).isFile())
+          return cand;
+      } catch {}
+    }
+    for (const ext2 of [...TS_EXTS, JSON_EXT]) {
+      if (existsSync7(cand + ext2))
+        return cand + ext2;
+    }
+    for (const ext2 of TS_EXTS) {
+      const idx = join7(cand, "index" + ext2);
+      if (existsSync7(idx))
+        return idx;
+    }
+  }
+  return null;
+}
+function findLocalConst(ident, source) {
+  const re = new RegExp(`(?:export\\s+)?const\\s+${ident}\\s*(?::[^=]+)?=\\s*`, "g");
+  const m = re.exec(source);
+  if (!m)
+    return null;
+  const start = m.index + m[0].length;
+  return readExpression(source, start);
+}
+function readExpression(source, start) {
+  let depth = 0;
+  let inString = null;
+  let i = start;
+  for (;i < source.length; i++) {
+    const c = source[i];
+    if (inString) {
+      if (c === "\\") {
+        i++;
+        continue;
+      }
+      if (c === inString)
+        inString = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      continue;
+    }
+    if (c === "{" || c === "[" || c === "(")
+      depth++;
+    else if (c === "}" || c === "]" || c === ")")
+      depth--;
+    if (depth === 0 && (c === ";" || c === `
+`))
+      break;
+  }
+  return source.slice(start, i).trim().replace(/[;]+$/, "").trim();
+}
+function findDefaultExportIdentifier(source) {
+  const m = /export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/.exec(source);
+  return m ? m[1] : null;
+}
+function parseLiteralValue(expr) {
+  expr = expr.trim();
+  if (expr.startsWith("{")) {
+    const keys = extractTopLevelKeys(expr);
+    if (keys.length > 0)
+      return { kind: "objectKeys", values: keys };
+    return null;
+  }
+  if (expr.startsWith("[")) {
+    const arrText = sliceTopLevelArray(expr);
+    if (!arrText)
+      return null;
+    const stringRe = /["'`]([^"'`]*)["'`]/g;
+    const inner = arrText.slice(1, -1);
+    if (/^\s*\{/.test(inner)) {
+      const objs = parseObjectArray(arrText);
+      if (objs)
+        return { kind: "objects", values: objs };
+      return null;
+    }
+    const values = [];
+    let m;
+    while ((m = stringRe.exec(inner)) !== null)
+      values.push(m[1]);
+    if (values.length > 0)
+      return { kind: "strings", values };
+  }
+  return null;
+}
+function extractTopLevelKeys(expr) {
+  const inner = expr.slice(1, expr.length - 1);
+  const keys = [];
+  let depth = 0;
+  let i = 0;
+  let inString = null;
+  let atKeyPos = true;
+  while (i < inner.length) {
+    const c = inner[i];
+    if (inString) {
+      if (c === "\\") {
+        i += 2;
+        continue;
+      }
+      if (c === inString)
+        inString = null;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      if (atKeyPos && depth === 0) {
+        const quote = c;
+        const end = inner.indexOf(quote, i + 1);
+        if (end === -1)
+          break;
+        keys.push(inner.slice(i + 1, end));
+        i = end + 1;
+        while (i < inner.length && /\s/.test(inner[i]))
+          i++;
+        if (inner[i] === ":") {
+          i++;
+          atKeyPos = false;
+        }
+        continue;
+      }
+      inString = c;
+      i++;
+      continue;
+    }
+    if (c === "{" || c === "[" || c === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === "}" || c === "]" || c === ")") {
+      depth--;
+      i++;
+      continue;
+    }
+    if (depth === 0 && c === ",") {
+      atKeyPos = true;
+      i++;
+      continue;
+    }
+    if (depth === 0 && c === ":") {
+      atKeyPos = false;
+      i++;
+      continue;
+    }
+    if (atKeyPos && depth === 0 && /[A-Za-z_$]/.test(c)) {
+      let j = i;
+      while (j < inner.length && /[\w$]/.test(inner[j]))
+        j++;
+      const key = inner.slice(i, j);
+      let k = j;
+      while (k < inner.length && /\s/.test(inner[k]))
+        k++;
+      if (inner[k] === ":") {
+        keys.push(key);
+        i = k + 1;
+        atKeyPos = false;
+        continue;
+      }
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return keys;
+}
+function literalToResolution(data) {
+  if (Array.isArray(data)) {
+    if (data.every((v) => typeof v === "string")) {
+      return { kind: "strings", values: data };
+    }
+    if (data.every((v) => v && typeof v === "object")) {
+      return { kind: "objects", values: data };
+    }
+    return null;
+  }
+  if (data && typeof data === "object") {
+    return { kind: "objectKeys", values: Object.keys(data) };
+  }
+  return null;
+}
 
 // src/scanner.ts
 function extractRoutePath(filePath) {
@@ -16628,7 +17284,7 @@ async function scan(config) {
 // src/config.ts
 var import_fast_glob11 = __toESM(require_out4(), 1);
 import { existsSync as existsSync9, readFileSync as readFileSync11 } from "node:fs";
-import { join as join9, resolve as resolve3, relative as relative4, dirname as dirname5 } from "node:path";
+import { join as join9, resolve as resolve4, relative as relative4, dirname as dirname6 } from "node:path";
 var DEFAULT_CONFIG = {
   dir: "./",
   ignore: {
@@ -16666,7 +17322,7 @@ function loadConfig(options) {
     absolute: true
   });
   if (options.config && existsSync9(options.config)) {
-    const absConfig = resolve3(cwd, options.config);
+    const absConfig = resolve4(cwd, options.config);
     if (!configFiles.includes(absConfig)) {
       configFiles.push(absConfig);
     }
@@ -16689,7 +17345,7 @@ function loadConfig(options) {
     try {
       const content = readFileSync11(configPath, "utf-8");
       const config = JSON.parse(content);
-      const configDir = dirname5(configPath);
+      const configDir = dirname6(configPath);
       const relDir = relative4(cwd, configDir);
       const prefixPattern = (p) => {
         if (p.startsWith("**/") || p.startsWith("/") || !relDir)
@@ -16804,7 +17460,7 @@ program2.action(async (options) => {
     let isMonorepo = existsSync11(appsDir) && lstatSync(appsDir).isDirectory();
     if (!isMonorepo) {
       let current = absoluteDir;
-      while (current !== dirname6(current)) {
+      while (current !== dirname7(current)) {
         const potentialApps = join11(current, "apps");
         if (existsSync11(potentialApps) && lstatSync(potentialApps).isDirectory()) {
           monorepoRoot = current;
@@ -16812,7 +17468,7 @@ program2.action(async (options) => {
           isMonorepo = true;
           break;
         }
-        current = dirname6(current);
+        current = dirname7(current);
       }
     }
     if (isMonorepo && monorepoRoot !== absoluteDir) {
@@ -16913,6 +17569,10 @@ program2.action(async (options) => {
         if (options.json) {
           console.log(JSON.stringify(result, null, 2));
         } else if (options.fix) {
+          if (isScanAll && !hasUnusedItems(result)) {
+            console.log(source_default.green(`   ✅ Nothing to fix in ${appLabel}`));
+            continue;
+          }
           const fixResult = await handleFixes(result, currentConfig, options, isMonorepo);
           if (fixResult === "back") {
             requestedBack = true;
@@ -17155,7 +17815,7 @@ Analyzing cascading impact...`));
       const routeFiles = new Set;
       const rootDir = config.appSpecificScan ? config.appSpecificScan.rootDir : config.dir;
       for (const r of [...unusedRoutes, ...partiallyRoutes]) {
-        routeFiles.add(resolve4(rootDir, r.filePath));
+        routeFiles.add(resolve5(rootDir, r.filePath));
       }
       const title = `Unused API Routes (${totalRoutesIssues} items in ${routeFiles.size} files)`;
       choices.push({ title, value: "routes" });
@@ -17452,7 +18112,7 @@ Analyzing cascading impact...`));
           const fullPath = resolveFilePath(filePath, config);
           const route = fileRoutes[0];
           if (route.type === "nextjs" && (filePath.includes("app/api") || filePath.includes("pages/api"))) {
-            filesToUnlink.add(dirname6(fullPath));
+            filesToUnlink.add(dirname7(fullPath));
           } else if (route.type === "nestjs" && (result.unusedFiles?.files.some((f) => f.path === filePath) || filePath.includes("api/"))) {
             filesToUnlink.add(fullPath);
           } else {
@@ -17506,7 +18166,7 @@ Analyzing cascading impact...`));
         }
         const actuallyFixed = new Set;
         for (const [absPath, removals] of removalsByFile) {
-          if (actuallyDeleted.has(absPath) || actuallyDeleted.has(dirname6(absPath)))
+          if (actuallyDeleted.has(absPath) || actuallyDeleted.has(dirname7(absPath)))
             continue;
           if (!existsSync11(absPath))
             continue;
@@ -17521,7 +18181,7 @@ Analyzing cascading impact...`));
         }
         result.routes = result.routes.filter((r) => {
           const fullPath = resolveFilePath(r.filePath, config);
-          if (actuallyDeleted.has(fullPath) || actuallyDeleted.has(dirname6(fullPath)))
+          if (actuallyDeleted.has(fullPath) || actuallyDeleted.has(dirname7(fullPath)))
             return false;
           if (actuallyFixed.has(fullPath)) {
             r.unusedMethods = [];
@@ -17993,11 +18653,11 @@ function printTable(summary) {
 }
 function findGitRoot(startDir) {
   let currentDir = startDir;
-  while (currentDir !== dirname6(currentDir)) {
+  while (currentDir !== dirname7(currentDir)) {
     if (existsSync11(join11(currentDir, ".git"))) {
       return true;
     }
-    currentDir = dirname6(currentDir);
+    currentDir = dirname7(currentDir);
   }
   return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pruny",
-  "version": "1.43.9",
+  "version": "1.44.0",
   "description": "Find and remove unused Next.js API routes & Nest.js Controllers",
   "type": "module",
   "files": [
@@ -34,7 +34,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/webnaresh/pruny"
+    "url": "https://github.com/Navibyte-Innovations-Pvt-Ltd/pruny"
   },
   "dependencies": {
     "chalk": "^5.3.0",