@flotrace/runtime-core 2.2.4 → 2.3.1

package/dist/chunk-5LSFLPGP.mjs

@@ -0,0 +1,276 @@
+// src/jsxRuntimeUtils.ts
+var FLOTRACE_SOURCE = /* @__PURE__ */ Symbol.for("flotrace.source");
+var JSX_RUNTIME_ACTIVE_KEY = /* @__PURE__ */ Symbol.for("flotrace.jsx-runtime-active");
+function normalizeJsxSourcePath(fileName) {
+  let p = fileName;
+  if (p.startsWith("file://")) p = p.slice("file://".length);
+  if (p.startsWith("webpack-internal:///./")) p = p.slice("webpack-internal:///./".length);
+  if (p.startsWith("[project]/")) p = p.slice("[project]/".length);
+  if (p.startsWith("./")) p = p.slice(2);
+  if (/^\/[a-zA-Z]:[\\/]/.test(p)) p = p.slice(1);
+  if (/^[a-zA-Z]:[\\/]/.test(p)) p = p[0].toLowerCase() + p.slice(1);
+  return p;
+}
+function normalizeStackFramePath(rawPath) {
+  let p = rawPath;
+  const queryIdx = p.indexOf("?");
+  if (queryIdx !== -1) p = p.slice(0, queryIdx);
+  const httpMatch = p.match(/^https?:\/\/[^/]+(\/.+)$/);
+  if (httpMatch) {
+    p = httpMatch[1];
+    if (p.startsWith("/")) p = p.slice(1);
+  }
+  return normalizeJsxSourcePath(p);
+}
+function isJsBundlePath(rawPath) {
+  if (/\bindex\.bundle\b/.test(rawPath)) return true;
+  if (/\.bundle(\?|$|\.js(\?|$))/.test(rawPath)) return true;
+  if (/\?platform=(ios|android|web|native)\b/.test(rawPath)) return true;
+  return false;
+}
+function parseFirstNonReactFrame(stack) {
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const parened = line.match(/\(([^)]+):(\d+):(\d+)\)/);
+    const hermes = line.match(/@([^\s]+):(\d+):(\d+)$/);
+    const match = parened ?? hermes;
+    if (!match) continue;
+    const path = match[1];
+    if (path.includes("react-dom")) continue;
+    if (path.includes("react-native/Libraries")) continue;
+    if (path.includes("/react/cjs/")) continue;
+    if (path.includes("/scheduler/")) continue;
+    if (isJsBundlePath(path)) continue;
+    return {
+      fileName: normalizeStackFramePath(path),
+      lineNumber: Number(match[2]),
+      columnNumber: Number(match[3])
+    };
+  }
+  return null;
+}
+function computeCallSiteId(source) {
+  const normPath = normalizeJsxSourcePath(source.fileName);
+  const key = `${normPath}:${source.lineNumber}:${source.columnNumber}`;
+  let hash = 2166136261;
+  for (let i = 0; i < key.length; i++) {
+    hash ^= key.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+var FLOTRACE_SRC_ATTR = "data-flotrace-src";
+function parseDataFlotraceSrc(value) {
+  let obj;
+  try {
+    obj = JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+  if (!obj || typeof obj !== "object") return void 0;
+  const o = obj;
+  if (typeof o.f !== "string" || typeof o.l !== "number" || typeof o.c !== "number") {
+    return void 0;
+  }
+  const fileName = o.f;
+  const lineNumber = o.l;
+  const columnNumber = o.c;
+  return {
+    fileName,
+    lineNumber,
+    columnNumber,
+    callSiteId: computeCallSiteId({ fileName, lineNumber, columnNumber })
+  };
+}
+function readJsxSourceFromFiber(fiber) {
+  const props = fiber.memoizedProps;
+  if (props) {
+    const symRaw = props[FLOTRACE_SOURCE];
+    if (symRaw && typeof symRaw === "object") {
+      const obj = symRaw;
+      if (typeof obj.fileName === "string" && typeof obj.lineNumber === "number" && typeof obj.columnNumber === "number" && typeof obj.callSiteId === "string") {
+        return symRaw;
+      }
+    }
+    const strRaw = props[FLOTRACE_SRC_ATTR];
+    if (typeof strRaw === "string") {
+      const parsed = parseDataFlotraceSrc(strRaw);
+      if (parsed) return parsed;
+    }
+  }
+  const type = fiber.type;
+  if (type !== null && (typeof type === "function" || typeof type === "object")) {
+    const typeAttr = type[FLOTRACE_SRC_ATTR];
+    if (typeof typeAttr === "string") {
+      const parsed = parseDataFlotraceSrc(typeAttr);
+      if (parsed) return parsed;
+    }
+  }
+  return void 0;
+}
+function isUserComponent(fiber) {
+  const jsxSrc = readJsxSourceFromFiber({
+    memoizedProps: fiber.memoizedProps ?? null,
+    type: fiber.type
+  });
+  if (jsxSrc && !jsxSrc.fileName.includes("node_modules")) return true;
+  const debugSourcePath = fiber._debugSource?.fileName;
+  if (typeof debugSourcePath === "string" && !debugSourcePath.includes("node_modules")) {
+    return true;
+  }
+  const stack = fiber._debugStack?.stack;
+  if (typeof stack === "string") {
+    const frame = parseFirstNonReactFrame(stack);
+    if (frame && !frame.fileName.includes("node_modules")) return true;
+  }
+  return false;
+}
+var callSiteRenders = /* @__PURE__ */ new Map();
+var RING_BUFFER_MAX = 60;
+function recordCallSiteRender(callSiteId, now = performance.now()) {
+  const arr = callSiteRenders.get(callSiteId);
+  if (arr === void 0) {
+    callSiteRenders.set(callSiteId, [now]);
+    return;
+  }
+  arr.push(now);
+  if (arr.length > RING_BUFFER_MAX) arr.shift();
+}
+function getCallSiteRenders(callSiteId) {
+  return callSiteRenders.get(callSiteId) ?? [];
+}
+function getCallSiteRenderRate(callSiteId, windowMs = 5e3, now = performance.now()) {
+  const arr = callSiteRenders.get(callSiteId);
+  if (!arr || arr.length === 0) return 0;
+  const cutoff = now - windowMs;
+  let count = 0;
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] >= cutoff) count++;
+    else break;
+  }
+  return count / windowMs * 1e3;
+}
+function clearCallSiteRenders() {
+  callSiteRenders.clear();
+}
+function computeCallSiteMetricsPayload(windowMs = 5e3, now = performance.now()) {
+  let out = null;
+  const cutoff = now - windowMs;
+  for (const [callSiteId, arr] of callSiteRenders) {
+    if (arr.length === 0) continue;
+    let count = 0;
+    for (let i = arr.length - 1; i >= 0; i--) {
+      if (arr[i] >= cutoff) count++;
+      else break;
+    }
+    if (count > 0) {
+      (out ?? (out = {}))[callSiteId] = count / windowMs * 1e3;
+    }
+  }
+  return out;
+}
+var duplicateKeyEmitter = null;
+function setDuplicateKeyEmitter(emitter) {
+  duplicateKeyEmitter = emitter;
+}
+var currentKeyBatch = /* @__PURE__ */ new Map();
+var keyBatchFlushScheduled = false;
+function recordJsxKey(source, key) {
+  const keyType = typeof key;
+  if (keyType !== "string" && keyType !== "number" && keyType !== "boolean") return;
+  const keyStr = String(key);
+  const batchKey = `${source.callSiteId}|${keyStr}`;
+  const entry = currentKeyBatch.get(batchKey);
+  if (entry !== void 0) {
+    entry.count++;
+  } else {
+    currentKeyBatch.set(batchKey, { count: 1, source });
+  }
+  if (!keyBatchFlushScheduled) {
+    keyBatchFlushScheduled = true;
+    queueMicrotask(flushDuplicateKeys);
+  }
+}
+function flushDuplicateKeys() {
+  keyBatchFlushScheduled = false;
+  const emitter = duplicateKeyEmitter;
+  if (emitter === null) {
+    currentKeyBatch.clear();
+    return;
+  }
+  for (const [batchKey, { count, source }] of currentKeyBatch) {
+    if (count < 2) continue;
+    const sep = batchKey.indexOf("|");
+    const duplicateKey = batchKey.slice(sep + 1);
+    emitter({
+      callSiteId: source.callSiteId,
+      fileName: source.fileName,
+      lineNumber: source.lineNumber,
+      columnNumber: source.columnNumber,
+      duplicateKey,
+      occurrences: count
+    });
+  }
+  currentKeyBatch.clear();
+}
+function markJsxRuntimeActive() {
+  globalThis[JSX_RUNTIME_ACTIVE_KEY] = true;
+}
+function isJsxRuntimeActive() {
+  return globalThis[JSX_RUNTIME_ACTIVE_KEY] === true;
+}
+var KNOWN_REACT_PROPS = /* @__PURE__ */ new Set(["key", "ref", "children", "className"]);
+var REACT_ELEMENT_TYPEOF_LEGACY = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_ELEMENT_TYPEOF_R19 = /* @__PURE__ */ Symbol.for("react.transitional.element");
+function isReactElement(v) {
+  const typeOf = v.$$typeof;
+  return typeOf === REACT_ELEMENT_TYPEOF_LEGACY || typeOf === REACT_ELEMENT_TYPEOF_R19;
+}
+function detectInlineLiterals(props) {
+  let out;
+  for (const k in props) {
+    if (KNOWN_REACT_PROPS.has(k)) continue;
+    const v = props[k];
+    if (typeof v === "function") {
+      if (!v.name) {
+        (out ?? (out = {}))[k] = "fn";
+      }
+    } else if (Array.isArray(v)) {
+      if (v.length > 0) {
+        (out ?? (out = {}))[k] = "arr";
+      }
+    } else if (v !== null && typeof v === "object" && // Skip elements processed by our own runtime (marker present).
+    !(FLOTRACE_SOURCE in v) && // Skip React elements processed by ANY runtime — `$$typeof` is set on
+    // every element regardless of which jsx-runtime created it, so this
+    // catches mixed-runtime codebases. Without this guard, an inline
+    // `<Outer child={<Inner/>} />` would false-positive on `child` when
+    // Inner went through a different jsxImportSource.
+    !isReactElement(v)) {
+      const proto = Object.getPrototypeOf(v);
+      if (proto === Object.prototype || proto === null) {
+        (out ?? (out = {}))[k] = "obj";
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  FLOTRACE_SOURCE,
+  JSX_RUNTIME_ACTIVE_KEY,
+  normalizeJsxSourcePath,
+  parseFirstNonReactFrame,
+  computeCallSiteId,
+  readJsxSourceFromFiber,
+  isUserComponent,
+  recordCallSiteRender,
+  getCallSiteRenders,
+  getCallSiteRenderRate,
+  clearCallSiteRenders,
+  computeCallSiteMetricsPayload,
+  setDuplicateKeyEmitter,
+  recordJsxKey,
+  markJsxRuntimeActive,
+  isJsxRuntimeActive,
+  detectInlineLiterals
+};