made-refine 0.1.11 → 0.1.13

package/dist/cli.cjs

@@ -8435,32 +8435,185 @@ function installPackage(cwd) {
     console.log(import_picocolors.default.dim(`    ${cmd}`));
   }
 }
-async function setupNextJs(cwd) {
-  console.log(import_picocolors.default.bold("\nConfiguring for Next.js...\n"));
-  const babelrcPath = import_path2.default.join(cwd, ".babelrc");
-  if (import_fs2.default.existsSync(babelrcPath)) {
-    const content2 = import_fs2.default.readFileSync(babelrcPath, "utf-8");
-    if (content2.includes("made-refine")) {
-      console.log(import_picocolors.default.dim("  .babelrc \u2014 already configured"));
-    } else {
-      console.log(import_picocolors.default.yellow('  .babelrc already exists \u2014 please add "made-refine/babel" plugin manually'));
+var BABEL_JSON_CONFIG_FILES = [".babelrc", ".babelrc.json", "babel.config.json"];
+var BABEL_JS_CONFIG_FILES = [
+  ".babelrc.js",
+  ".babelrc.cjs",
+  ".babelrc.mjs",
+  "babel.config.js",
+  "babel.config.cjs",
+  "babel.config.mjs"
+];
+function findBabelConfigFile(cwd) {
+  for (const file of BABEL_JSON_CONFIG_FILES) {
+    const absolutePath = import_path2.default.join(cwd, file);
+    if (import_fs2.default.existsSync(absolutePath)) {
+      return {
+        absolutePath,
+        relativePath: file,
+        kind: "json"
+      };
     }
-  } else {
-    const babelrc = JSON.stringify(
-      {
-        presets: ["next/babel"],
-        env: {
-          development: {
-            plugins: ["made-refine/babel"]
-          }
-        }
-      },
-      null,
-      2
+  }
+  for (const file of BABEL_JS_CONFIG_FILES) {
+    const absolutePath = import_path2.default.join(cwd, file);
+    if (import_fs2.default.existsSync(absolutePath)) {
+      return {
+        absolutePath,
+        relativePath: file,
+        kind: "js"
+      };
+    }
+  }
+  const packageJsonPath = import_path2.default.join(cwd, "package.json");
+  if (import_fs2.default.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(import_fs2.default.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.babel !== void 0) {
+        return {
+          absolutePath: packageJsonPath,
+          relativePath: "package.json#babel",
+          kind: "package-json"
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function isMadeRefinePlugin(plugin) {
+  if (typeof plugin === "string") {
+    return plugin === "made-refine/babel";
+  }
+  if (Array.isArray(plugin) && typeof plugin[0] === "string") {
+    return plugin[0] === "made-refine/babel";
+  }
+  return false;
+}
+function hasMadeRefinePlugin(plugins) {
+  if (!Array.isArray(plugins)) return false;
+  return plugins.some((plugin) => isMadeRefinePlugin(plugin));
+}
+function ensureMadeRefineInDevelopmentEnv(config) {
+  if (hasMadeRefinePlugin(config.plugins)) {
+    return "already-configured";
+  }
+  const existingEnv = config.env;
+  if (existingEnv !== void 0 && (typeof existingEnv !== "object" || existingEnv === null || Array.isArray(existingEnv))) {
+    return "unsupported-shape";
+  }
+  if (!config.env) {
+    config.env = {};
+  }
+  const env = config.env;
+  const existingDevelopment = env.development;
+  if (existingDevelopment !== void 0 && (typeof existingDevelopment !== "object" || existingDevelopment === null || Array.isArray(existingDevelopment))) {
+    return "unsupported-shape";
+  }
+  if (!env.development) {
+    env.development = {};
+  }
+  const development = env.development;
+  if (hasMadeRefinePlugin(development.plugins)) {
+    return "already-configured";
+  }
+  if (development.plugins === void 0) {
+    development.plugins = ["made-refine/babel"];
+    return "updated";
+  }
+  if (!Array.isArray(development.plugins)) {
+    return "unsupported-shape";
+  }
+  development.plugins = [...development.plugins, "made-refine/babel"];
+  return "updated";
+}
+function printManualNextBabelInstructions() {
+  console.log(
+    import_picocolors.default.dim(
+      "    env: { development: { plugins: ['made-refine/babel'] } }\n    (or add 'made-refine/babel' in your existing Babel plugin list)"
+    )
+  );
+}
+function configureNextBabel(cwd) {
+  const configFile = findBabelConfigFile(cwd);
+  if (!configFile) {
+    console.log(
+      import_picocolors.default.yellow("  \u26A0 No existing Babel config found \u2014 skipping Babel config to preserve SWC/Turbopack defaults.")
     );
-    console.log(import_picocolors.default.green(`  \u2713 Created .babelrc`));
-    import_fs2.default.writeFileSync(babelrcPath, babelrc + "\n", "utf-8");
+    console.log(import_picocolors.default.dim("    Source detection will use React fiber fallback (less precise than Babel attributes)."));
+    return;
+  }
+  if (configFile.kind === "js") {
+    console.log(import_picocolors.default.yellow(`  \u26A0 Found ${configFile.relativePath} (JS Babel config) \u2014 verify/add plugin manually:`));
+    printManualNextBabelInstructions();
+    return;
+  }
+  if (configFile.kind === "package-json") {
+    let packageJson;
+    try {
+      packageJson = JSON.parse(import_fs2.default.readFileSync(configFile.absolutePath, "utf-8"));
+    } catch {
+      console.log(import_picocolors.default.yellow("  \u26A0 Could not parse package.json \u2014 add plugin manually:"));
+      printManualNextBabelInstructions();
+      return;
+    }
+    if (typeof packageJson !== "object" || packageJson === null || Array.isArray(packageJson)) {
+      console.log(import_picocolors.default.yellow("  \u26A0 package.json has unsupported shape \u2014 add plugin manually:"));
+      printManualNextBabelInstructions();
+      return;
+    }
+    const pkg = packageJson;
+    if (typeof pkg.babel !== "object" || pkg.babel === null || Array.isArray(pkg.babel)) {
+      console.log(import_picocolors.default.yellow("  \u26A0 package.json#babel has unsupported shape \u2014 add plugin manually:"));
+      printManualNextBabelInstructions();
+      return;
+    }
+    const result2 = ensureMadeRefineInDevelopmentEnv(pkg.babel);
+    if (result2 === "already-configured") {
+      console.log(import_picocolors.default.dim("  package.json#babel \u2014 already configured"));
+      return;
+    }
+    if (result2 === "unsupported-shape") {
+      console.log(import_picocolors.default.yellow("  \u26A0 package.json#babel has unsupported shape \u2014 add plugin manually:"));
+      printManualNextBabelInstructions();
+      return;
+    }
+    import_fs2.default.writeFileSync(configFile.absolutePath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+    console.log(import_picocolors.default.green('  \u2713 Updated package.json#babel (added "made-refine/babel" in development env)'));
+    return;
+  }
+  const content = import_fs2.default.readFileSync(configFile.absolutePath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    console.log(import_picocolors.default.yellow(`  \u26A0 Could not parse ${configFile.relativePath} as JSON \u2014 add plugin manually:`));
+    printManualNextBabelInstructions();
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    console.log(import_picocolors.default.yellow(`  \u26A0 ${configFile.relativePath} has unsupported shape \u2014 add plugin manually:`));
+    printManualNextBabelInstructions();
+    return;
   }
+  const result = ensureMadeRefineInDevelopmentEnv(parsed);
+  if (result === "already-configured") {
+    console.log(import_picocolors.default.dim(`  ${configFile.relativePath} \u2014 already configured`));
+    return;
+  }
+  if (result === "unsupported-shape") {
+    console.log(import_picocolors.default.yellow(`  \u26A0 ${configFile.relativePath} has unsupported shape \u2014 add plugin manually:`));
+    printManualNextBabelInstructions();
+    return;
+  }
+  import_fs2.default.writeFileSync(configFile.absolutePath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+  console.log(import_picocolors.default.green(`  \u2713 Updated ${configFile.relativePath} (added "made-refine/babel" in development env)`));
+}
+async function setupNextJs(cwd) {
+  console.log(import_picocolors.default.bold("\nConfiguring for Next.js...\n"));
+  configureNextBabel(cwd);
   const preloadSrc = import_path2.default.join(cwd, "node_modules/made-refine/dist/preload/preload.js");
   const publicDir = import_path2.default.join(cwd, "public");
   const preloadDest = import_path2.default.join(publicDir, "made-refine-preload.js");

package/dist/index.js

@@ -1397,6 +1397,253 @@ function getFiberForElement(element) {
   if (!fiberKey) return null;
   return element[fiberKey] || null;
 }
+var STACK_SOURCE_FILE_EXTENSION_REGEX = /\.(jsx|tsx|ts|js)$/;
+var STACK_BUNDLED_FILE_PATTERN_REGEX = /(\.min|bundle|chunk|vendor|vendors|runtime|polyfill|polyfills)\.(js|mjs|cjs)$|(chunk|bundle|vendor|vendors|runtime|polyfill|polyfills|framework|app|main|index)[-_.][A-Za-z0-9_-]{4,}\.(js|mjs|cjs)$|[\da-f]{8,}\.(js|mjs|cjs)$|[-_.][\da-f]{20,}\.(js|mjs|cjs)$|\/dist\/|\/build\/|\/.next\/|\/out\/|\/node_modules\/|\.webpack\.|\.vite\.|\.turbopack\./i;
+var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code\])?$/;
+var SERVER_FRAME_MARKER = "(at Server)";
+var STACK_INTERNAL_SCHEME_PREFIXES = [
+  "rsc://",
+  "about://React/",
+  "React/Server/",
+  "file:///",
+  "webpack://",
+  "webpack-internal://",
+  "node:",
+  "turbopack://",
+  "/app-pages-browser/"
+];
+function formatOwnerDebugStack(stack) {
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  const filtered = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed === "Error: react-stack-top-frame") continue;
+    if (trimmed.includes("react_stack_bottom_frame") || trimmed.includes("react-stack-bottom-frame")) {
+      continue;
+    }
+    filtered.push(line);
+  }
+  if (filtered.length > 0 && filtered[0].includes("fakeJSXCallSite")) {
+    filtered.shift();
+  }
+  return filtered.join("\n");
+}
+function extractStackLocation(urlLike) {
+  if (!urlLike.includes(":")) return [urlLike, void 0, void 0];
+  const isWrappedLocation = urlLike.startsWith("(") && /:\d+\)$/.test(urlLike);
+  const sanitizedResult = isWrappedLocation ? urlLike.slice(1, -1) : urlLike;
+  const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(sanitizedResult);
+  if (!parts) return [sanitizedResult, void 0, void 0];
+  return [
+    parts[1],
+    parts[2] !== void 0 ? Number(parts[2]) : void 0,
+    parts[3] !== void 0 ? Number(parts[3]) : void 0
+  ];
+}
+function parseV8StackLine(line) {
+  let currentLine = line;
+  if (currentLine.includes("(eval ")) {
+    currentLine = currentLine.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = currentLine.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const locationMatch = sanitizedLine.match(/ (\(.+\)$)/);
+  if (locationMatch) {
+    sanitizedLine = sanitizedLine.replace(locationMatch[0], "");
+  }
+  const [fileName, lineNumber, columnNumber] = extractStackLocation(
+    locationMatch ? locationMatch[1] : sanitizedLine
+  );
+  const functionName = locationMatch && sanitizedLine ? sanitizedLine : void 0;
+  if (fileName === "eval" || fileName === "<anonymous>") {
+    return {
+      functionName
+    };
+  }
+  return {
+    functionName,
+    fileName,
+    lineNumber,
+    columnNumber,
+    source: currentLine,
+    isServer: currentLine.includes(SERVER_FRAME_MARKER) || fileName.startsWith("rsc://")
+  };
+}
+function parseFFOrSafariStackLine(line) {
+  let currentLine = line;
+  if (currentLine.includes(" > eval")) {
+    currentLine = currentLine.replace(
+      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
+      ":$1"
+    );
+  }
+  const trimmed = currentLine.trim();
+  if (!trimmed || SAFARI_NATIVE_CODE_REGEXP.test(trimmed)) {
+    return null;
+  }
+  if (!trimmed.includes("@") && !trimmed.includes(":")) {
+    return {
+      functionName: trimmed,
+      source: currentLine,
+      isServer: trimmed.includes(SERVER_FRAME_MARKER)
+    };
+  }
+  const atIndex = trimmed.lastIndexOf("@");
+  if (atIndex === -1) {
+    return null;
+  }
+  const maybeFunctionName = trimmed.slice(0, atIndex);
+  const location = trimmed.slice(atIndex + 1);
+  const [fileName, lineNumber, columnNumber] = extractStackLocation(location);
+  return {
+    functionName: maybeFunctionName || void 0,
+    fileName,
+    lineNumber,
+    columnNumber,
+    source: currentLine,
+    isServer: currentLine.includes(SERVER_FRAME_MARKER) || fileName.startsWith("rsc://")
+  };
+}
+function parseInStackLine(line) {
+  const functionName = line.replace(/^\s*in\s+/, "").replace(/\s*\(at .*\)$/, "").trim();
+  if (!functionName) return null;
+  return {
+    functionName,
+    source: line,
+    isServer: line.includes(SERVER_FRAME_MARKER)
+  };
+}
+function parseDebugStack(stack) {
+  const frames = [];
+  for (const rawLine of stack.split("\n")) {
+    if (FIREFOX_SAFARI_STACK_REGEXP.test(rawLine)) {
+      const parsed = parseFFOrSafariStackLine(rawLine);
+      if (parsed) frames.push(parsed);
+      continue;
+    }
+    if (/^\s*at\s+/.test(rawLine)) {
+      const parsed = parseV8StackLine(rawLine);
+      if (parsed) frames.push(parsed);
+      continue;
+    }
+    if (/^\s*in\s+/.test(rawLine)) {
+      const parsed = parseInStackLine(rawLine);
+      if (parsed) frames.push(parsed);
+    }
+  }
+  return frames;
+}
+function normalizeStackFileName(fileName) {
+  if (!fileName) return "";
+  let normalized = fileName;
+  const isHttpUrl = normalized.startsWith("http://") || normalized.startsWith("https://");
+  if (isHttpUrl) {
+    try {
+      normalized = new URL(normalized).pathname;
+    } catch {
+    }
+  }
+  let didStripPrefix = true;
+  while (didStripPrefix) {
+    didStripPrefix = false;
+    for (const prefix of STACK_INTERNAL_SCHEME_PREFIXES) {
+      if (normalized.startsWith(prefix)) {
+        normalized = normalized.slice(prefix.length);
+        if (prefix === "file:///") {
+          normalized = `/${normalized.replace(/^\/+/, "")}`;
+        }
+        didStripPrefix = true;
+        break;
+      }
+    }
+  }
+  normalized = normalized.replace(/^\/\(app-pages-browser\)\//, "/").replace(/^\/\.\//, "/").replace(/^\.\//, "");
+  const queryIndex = normalized.indexOf("?");
+  if (queryIndex !== -1) {
+    normalized = normalized.slice(0, queryIndex);
+  }
+  return normalized;
+}
+function isSourceStackFile(fileName) {
+  const normalizedFileName = normalizeStackFileName(fileName);
+  if (!normalizedFileName) return false;
+  if (!STACK_SOURCE_FILE_EXTENSION_REGEX.test(normalizedFileName)) return false;
+  return !STACK_BUNDLED_FILE_PATTERN_REGEX.test(normalizedFileName);
+}
+function buildFunctionNameToRscFramesMap(fiber) {
+  const functionNameToRscFrames = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  let current = fiber;
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const rawStack = current?._debugStack?.stack;
+    const stack = typeof rawStack === "string" ? formatOwnerDebugStack(rawStack) : "";
+    if (stack) {
+      const frames = parseDebugStack(stack);
+      for (const frame of frames) {
+        if (!frame.functionName || !frame.fileName) continue;
+        if (!frame.fileName.startsWith("rsc://")) continue;
+        const normalized = normalizeStackFileName(frame.fileName);
+        if (!normalized) continue;
+        const existing = functionNameToRscFrames.get(frame.functionName) ?? [];
+        const duplicate = existing.some(
+          (candidate) => candidate.fileName === normalized && candidate.lineNumber === frame.lineNumber && candidate.columnNumber === frame.columnNumber
+        );
+        if (!duplicate) {
+          existing.push({
+            fileName: normalized,
+            lineNumber: frame.lineNumber,
+            columnNumber: frame.columnNumber
+          });
+          functionNameToRscFrames.set(frame.functionName, existing);
+        }
+      }
+    }
+    current = current._debugOwner ?? current.return ?? null;
+  }
+  return functionNameToRscFrames;
+}
+function enrichServerFrame(frame, functionNameToRscFrames, functionNameToUsageIndex) {
+  if (!frame.functionName) return frame;
+  const available = functionNameToRscFrames.get(frame.functionName);
+  if (!available) return frame;
+  const usageIndex = functionNameToUsageIndex.get(frame.functionName) ?? 0;
+  const resolved = available[usageIndex % available.length];
+  functionNameToUsageIndex.set(frame.functionName, usageIndex + 1);
+  return {
+    ...frame,
+    fileName: resolved.fileName,
+    lineNumber: resolved.lineNumber,
+    columnNumber: resolved.columnNumber
+  };
+}
+function getSourceFromDebugStack(fiber) {
+  const rawStack = fiber?._debugStack?.stack;
+  if (typeof rawStack !== "string" || rawStack.length === 0) {
+    return null;
+  }
+  const formattedStack = formatOwnerDebugStack(rawStack);
+  if (!formattedStack) return null;
+  const stackFrames = parseDebugStack(formattedStack);
+  const functionNameToRscFrames = buildFunctionNameToRscFramesMap(fiber);
+  const functionNameToUsageIndex = /* @__PURE__ */ new Map();
+  for (const frame of stackFrames) {
+    const maybeEnriched = frame.isServer ? enrichServerFrame(frame, functionNameToRscFrames, functionNameToUsageIndex) : frame;
+    if (!maybeEnriched.fileName) continue;
+    const normalizedFileName = normalizeStackFileName(maybeEnriched.fileName);
+    if (!normalizedFileName) continue;
+    if (isSourceStackFile(normalizedFileName)) {
+      return {
+        fileName: normalizedFileName,
+        lineNumber: maybeEnriched.lineNumber,
+        columnNumber: maybeEnriched.columnNumber
+      };
+    }
+  }
+  return null;
+}
 function getSourceFromFiber(fiber) {
   const debugSource = fiber?._debugSource;
   if (debugSource?.fileName) return debugSource;
@@ -1409,6 +1656,8 @@ function getSourceFromFiber(fiber) {
   if (pending?.fileName) return pending;
   const memo = fiber?.memoizedProps?.__source;
   if (memo?.fileName) return memo;
+  const fromDebugStack = getSourceFromDebugStack(fiber);
+  if (fromDebugStack?.fileName) return fromDebugStack;
   return null;
 }
 function buildFrame(fiber) {
@@ -1624,7 +1873,7 @@ function buildTargetHtml(element) {
   return `<${tagName}${attrString}></${tagName}>`;
 }
 function formatSourcePath(file) {
-  const normalized = file.replace(/\\/g, "/").replace(/^webpack:\/\/\//, "").replace(/^webpack:\/\//, "").replace(/^file:\/\//, "").replace(/^_N_E\//, "").replace(/^\.\/+/, "");
+  const normalized = file.replace(/\\/g, "/").replace(/^webpack:\/\/\//, "").replace(/^webpack:\/\//, "").replace(/^webpack-internal:\/\//, "").replace(/^rsc:\/\/React\/Server\//, "").replace(/^about:\/\/React\//, "").replace(/^file:\/\//, "").replace(/^\/\(app-pages-browser\)\//, "/").replace(/^\/app-pages-browser\//, "/").replace(/^_N_E\//, "").replace(/^\.\/+/, "");
   const packagesIndex = normalized.indexOf("/packages/");
   if (packagesIndex !== -1) {
     return `/[project]${normalized.slice(packagesIndex)}`;
@@ -1769,8 +2018,10 @@ function getElementLocator(element) {
   const elementInfo = getElementInfo(element);
   let domSource = parseDomSource(element);
   if (!domSource) {
-    const fiber = getFiberForElement(element);
-    if (fiber) {
+    const seenFibers = /* @__PURE__ */ new Set();
+    let fiber = getFiberForElement(element);
+    while (fiber && !seenFibers.has(fiber)) {
+      seenFibers.add(fiber);
       const fiberSource = getSourceFromFiber(fiber);
       if (fiberSource?.fileName) {
         domSource = {
@@ -1778,7 +2029,9 @@ function getElementLocator(element) {
           line: fiberSource.lineNumber,
           column: fiberSource.columnNumber
         };
+        break;
       }
+      fiber = fiber._debugOwner ?? fiber.return ?? null;
     }
   }
   return {