react-perf-recorder 0.1.0

package/dist/browser/chunk-7DJUCCWG.js

@@ -0,0 +1,447 @@
+// src/core/stack.ts
+var V8_FRAME = /^\s*at (?:(?:async )?(.+?) \()?(.+?):(\d+):(\d+)\)?\s*$/;
+var GECKO_FRAME = /^\s*(.*?)@(.+?):(\d+):(\d+)\s*$/;
+var servedPath = (url) => url.replace(/^[a-z]+:\/\/[^/]+/, "").split(/[?#]/)[0].replace(/^\//, "");
+function parseStack(stack) {
+  const frames = [];
+  for (const line of stack.split("\n")) {
+    const m = V8_FRAME.exec(line) ?? GECKO_FRAME.exec(line);
+    if (!m) continue;
+    frames.push({ fn: (m[1] ?? "").replace(/^Object\./, "").replace(/ \[as .+\]$/, ""), url: m[2], line: Number(m[3]), column: Number(m[4]) });
+  }
+  return frames;
+}
+var OWN = (() => {
+  const url = (parseStack(new Error().stack ?? "")[0]?.url ?? "").split(/[?#]/)[0];
+  const at = Math.max(url.lastIndexOf("/dist/"), url.lastIndexOf("/src/"));
+  return at >= 0 ? [`${url.slice(0, at)}/dist/`, `${url.slice(0, at)}/src/`] : [];
+})();
+var packageOf = (path) => {
+  const parts = path.split("/").filter(Boolean);
+  return parts[0]?.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? "";
+};
+function libraryOf(url) {
+  const path = url.split(/[?#]/)[0];
+  if (OWN.some((prefix) => path.startsWith(prefix))) return "react-perf-recorder";
+  const deps = /\/deps\/([^/]+)\.js$/.exec(path);
+  if (deps && (url.includes("?v=") || path.includes("/.vite"))) return deps[1].startsWith("chunk-") ? "" : packageOf(deps[1].replace(/_/g, "/"));
+  const at = path.lastIndexOf("/node_modules/");
+  if (at >= 0) return packageOf(path.slice(at + "/node_modules/".length));
+  return null;
+}
+
+// src/core/react-compat.ts
+var BOTTOM_FRAME = /react_stack_bottom_frame/;
+var ownerStackSites = /* @__PURE__ */ new WeakMap();
+var sawSite = false;
+var sawFiberWithoutSite = false;
+function siteOf(f) {
+  const legacy = f._debugSource;
+  if (legacy?.fileName) {
+    sawSite = true;
+    return { url: legacy.fileName, line: legacy.lineNumber, column: legacy.columnNumber ?? 0, exact: true };
+  }
+  const stack = f._debugStack;
+  if (stack instanceof Error) {
+    const site = ownerStackSite(stack);
+    if (site) sawSite = true;
+    else sawFiberWithoutSite = true;
+    return site;
+  }
+  sawFiberWithoutSite = true;
+  return null;
+}
+function ownerStackSite(error) {
+  const known2 = ownerStackSites.get(error);
+  if (known2 !== void 0) return known2;
+  const holder = Error;
+  const previous = holder.prepareStackTrace;
+  let text = "";
+  try {
+    holder.prepareStackTrace = void 0;
+    text = error.stack ?? "";
+  } catch {
+    text = "";
+  } finally {
+    holder.prepareStackTrace = previous;
+  }
+  const frames = parseStack(text);
+  const frame = frames[1];
+  const site = frame && !BOTTOM_FRAME.test(frame.fn) ? { url: frame.url, line: frame.line, column: frame.column, exact: false } : null;
+  ownerStackSites.set(error, site);
+  return site;
+}
+function sourcesUnavailable() {
+  return sawFiberWithoutSite && !sawSite;
+}
+var ContextProviderTag = 10;
+var ContextConsumerTag = 9;
+var isProviderTag = (tag) => tag === ContextProviderTag;
+var isConsumerTag = (tag) => tag === ContextConsumerTag;
+function contextOf(f) {
+  const type = f.type;
+  return type?._context ?? type ?? null;
+}
+var HOOKS_WITHOUT_CELLS = /* @__PURE__ */ new Set(["useContext", "useDebugValue", "use", "useMemoCache", "useHostTransitionStatus", "useFormStatus"]);
+var HOOK_CELLS = {
+  useSyncExternalStore: 2,
+  useTransition: 2,
+  useActionState: 3,
+  useFormState: 3
+};
+var hookCells = (type) => HOOKS_WITHOUT_CELLS.has(type) ? 0 : HOOK_CELLS[type] ?? 1;
+var LANES_18 = [
+  [1, "Sync"],
+  [2, "InputContinuousHydration"],
+  [4, "InputContinuous"],
+  [8, "DefaultHydration"],
+  [16, "Default"],
+  [32, "TransitionHydration"],
+  [4194240, "Transition"],
+  [31 << 22, "Retry"],
+  [1 << 27, "SelectiveHydration"],
+  [1 << 28, "IdleHydration"],
+  [1 << 29, "Idle"],
+  [1 << 30, "Offscreen"]
+];
+var LANES_19 = [
+  [1, "SyncHydration"],
+  [2, "Sync"],
+  [4, "InputContinuousHydration"],
+  [8, "InputContinuous"],
+  [16, "DefaultHydration"],
+  [32, "Default"],
+  [64, "TransitionHydration"],
+  [261888, "Transition"],
+  [3932160, "TransitionDeferred"],
+  [62914560, "Retry"],
+  [1 << 26, "SelectiveHydration"],
+  [1 << 27, "IdleHydration"],
+  [1 << 28, "Idle"],
+  [1 << 29, "Offscreen"],
+  [1 << 30, "Deferred"]
+];
+function laneLabel(lanes) {
+  if (!lanes) return void 0;
+  const lowest = lanes & -lanes;
+  for (const [mask, label] of majorVersion() >= 19 ? LANES_19 : LANES_18) if (lowest & mask) return label;
+  return `lane:${lowest}`;
+}
+var captured = /* @__PURE__ */ new Set();
+function captureRenderers() {
+  const target = globalThis;
+  let hook = target.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (!hook) {
+    const renderers = /* @__PURE__ */ new Map();
+    const noop = () => {
+    };
+    hook = {
+      renderers,
+      supportsFiber: true,
+      isDisabled: false,
+      inject(renderer2) {
+        const id = renderers.size + 1;
+        renderers.set(id, renderer2);
+        return id;
+      },
+      onCommitFiberRoot: noop,
+      onCommitFiberUnmount: noop,
+      onPostCommitFiberRoot: noop,
+      onScheduleFiberRoot: noop,
+      checkDCE: noop,
+      on: noop,
+      off: noop,
+      emit: noop,
+      sub: () => noop
+    };
+    target.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+  }
+  for (const renderer2 of hook.renderers?.values() ?? []) captured.add(renderer2);
+  const original = hook.inject;
+  if (typeof original === "function" && !original.rprCaptured) {
+    const inject = function(renderer2) {
+      captured.add(renderer2);
+      return original.call(this, renderer2);
+    };
+    inject.rprCaptured = true;
+    hook.inject = inject;
+  }
+}
+function knownRenderers() {
+  const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  return [...captured, ...hook?.renderers?.values() ?? []];
+}
+function reactVersion() {
+  return knownRenderers().find((r) => r.version)?.version ?? null;
+}
+function renderer() {
+  return knownRenderers().find((r) => r.currentDispatcherRef) ?? null;
+}
+function majorVersion() {
+  return Number.parseInt(reactVersion() ?? "", 10) || 0;
+}
+
+// src/core/sites.ts
+var positionKey = (p) => `${p.url}:${p.line}:${p.column}`;
+var known = /* @__PURE__ */ new Map();
+var asked = /* @__PURE__ */ new Set();
+var queue = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+var mapper = null;
+var inFlight = null;
+var scheduled = null;
+function setSiteMapper(fn) {
+  mapper = fn;
+}
+function onSitesMapped(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function mappedSite(position) {
+  const key = positionKey(position);
+  const site = known.get(key);
+  if (site) return site;
+  if (site === "" || !mapper) return void 0;
+  if (!asked.has(key)) {
+    asked.add(key);
+    queue.set(key, position);
+    schedule();
+  }
+  return void 0;
+}
+function schedule() {
+  if (scheduled || inFlight) return;
+  scheduled = setTimeout(() => {
+    scheduled = null;
+    void flush();
+  }, 0);
+}
+function flush() {
+  if (!mapper || !queue.size) return Promise.resolve();
+  const positions = [...queue.values()];
+  queue.clear();
+  const request = mapper(positions).then((sites) => {
+    for (const [key, site] of Object.entries(sites)) known.set(key, site);
+    for (const position of positions) if (!known.has(positionKey(position))) known.set(positionKey(position), "");
+    if (Object.keys(sites).length) for (const listener of listeners) listener();
+  }).catch(() => {
+    for (const position of positions) asked.delete(positionKey(position));
+  }).finally(() => {
+    inFlight = null;
+    if (queue.size) schedule();
+  });
+  inFlight = request;
+  return request;
+}
+
+// src/core/fiber.ts
+var Tag = {
+  FunctionComponent: 0,
+  ClassComponent: 1,
+  IndeterminateComponent: 2,
+  HostRoot: 3,
+  HostPortal: 4,
+  HostComponent: 5,
+  HostText: 6,
+  ForwardRef: 11,
+  MemoComponent: 14,
+  SimpleMemoComponent: 15,
+  HostHoistable: 26,
+  HostSingleton: 27
+};
+var ProfileMode = 2;
+var isHost = (f) => f.tag === Tag.HostComponent || f.tag === Tag.HostHoistable || f.tag === Tag.HostSingleton;
+var isComposite = (f) => typeof f.type === "function" || Boolean(f.type?.render || f.type?.type);
+var mountedInPlace = (f) => f.alternate === null && isComposite(f) && f.return !== null && f.return.alternate !== null && f.return.tag !== Tag.HostRoot;
+var hasHooks = (f) => f.tag === Tag.FunctionComponent || f.tag === Tag.ForwardRef || f.tag === Tag.SimpleMemoComponent || f.tag === Tag.IndeterminateComponent;
+var hasProfileTimings = (f) => (f.mode & ProfileMode) !== 0 && typeof f.actualDuration === "number";
+function nameOf(f) {
+  if (isProviderTag(f.tag)) return `Provider(${contextOf(f)?.displayName || "context"})`;
+  if (isConsumerTag(f.tag)) return `Consumer(${contextOf(f)?.displayName || "context"})`;
+  const t = f.type;
+  if (t == null || typeof t === "string") return null;
+  if (typeof t === "function") return t.displayName || f.elementType?.displayName || t.name || "Anonymous";
+  if (typeof t === "object") {
+    if (t.displayName) return t.displayName;
+    if (t.render) return t.render.displayName || t.render.name || "ForwardRef";
+    if (t.type) return t.type.displayName || t.type.name || "Memo";
+  }
+  return null;
+}
+var isProvider = (name) => name.startsWith("Provider(");
+function wrapsProvider(f) {
+  const child = currentOf(f).child;
+  return Boolean(child && !child.sibling && isProvider(nameOf(child) ?? ""));
+}
+var libraryByType = /* @__PURE__ */ new WeakMap();
+function isLibraryFiber(f) {
+  const type = typeof f.type === "function" || f.type && typeof f.type === "object" ? f.type : null;
+  const known2 = type ? libraryByType.get(type) : void 0;
+  if (known2 !== void 0) return known2;
+  const library = definedInPackage(f);
+  if (type) libraryByType.set(type, library);
+  return library;
+}
+function definedInPackage(f) {
+  const site = siteOf(f.child ?? f);
+  return !site || libraryOf(site.url) !== null;
+}
+function sourceOf(f, root = "") {
+  const site = siteOf(f);
+  if (!site) return "";
+  const file = relativeFile(site.url, root);
+  if (site.exact) return `${file}:${site.line}`;
+  return mappedSite(site) || file;
+}
+function generatedSourceOf(f) {
+  const site = siteOf(f);
+  return site && !site.exact ? { url: site.url, line: site.line, column: site.column } : void 0;
+}
+function siteKeyOf(f, root = "") {
+  const site = siteOf(f);
+  return site ? `${relativeFile(site.url, root)}:${site.line}:${site.column}` : "";
+}
+function relativeFile(fileName, root = "") {
+  const file = fileName.replace(/^[a-z]+:\/\/[^/]+/, "").replace(/[?#].*$/, "");
+  if (root && file.startsWith(root)) return file.slice(root.length).replace(/^\/+/, "");
+  const i = file.lastIndexOf("/src/");
+  return i >= 0 ? file.slice(i + 1) : file.replace(/^\/+/, "").split("/").slice(-3).join("/");
+}
+var fiberKey = null;
+function fiberFromNode(node) {
+  for (let el = node; el; el = el.parentNode) {
+    if (!fiberKey) fiberKey = Object.keys(el).find((k) => k.startsWith("__reactFiber$")) ?? null;
+    const fiber = fiberKey ? el[fiberKey] : void 0;
+    if (fiber) return fiber;
+  }
+  return null;
+}
+function eachFiber(visit) {
+  for (const root of findRoots()) {
+    const stack = [root.current];
+    while (stack.length) {
+      const f = stack.pop();
+      if (visit(f) === false) return;
+      if (f.sibling) stack.push(f.sibling);
+      if (f.child) stack.push(f.child);
+    }
+  }
+}
+function hostRootOf(f) {
+  let node = f;
+  while (node?.return) node = node.return;
+  return node?.tag === Tag.HostRoot ? node.stateNode : null;
+}
+var created = /* @__PURE__ */ new Set();
+function registerRoot(root) {
+  created.add(new WeakRef(root));
+}
+function findRoots(doc = document) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const ref of created) {
+    const root = ref.deref();
+    if (!root) created.delete(ref);
+    else if (root.containerInfo?.isConnected && root.current) roots.add(root);
+  }
+  const candidates = [doc.getElementById("root"), ...Array.from(doc.body?.children ?? [])];
+  for (const el of Array.from(doc.body?.children ?? [])) candidates.push(...Array.from(el.children));
+  for (const el of candidates) {
+    if (!el) continue;
+    const key = Object.keys(el).find((k) => k.startsWith("__reactContainer$"));
+    const container = key ? el[key] : void 0;
+    if (container?.stateNode) roots.add(container.stateNode);
+  }
+  return [...roots];
+}
+function nearestHosts(f, limit = 500) {
+  const out = [];
+  const stack = f.child ? [f.child] : [];
+  if (isHost(f)) return [f.stateNode];
+  while (stack.length && out.length < limit) {
+    const node = stack.pop();
+    if (node.sibling) stack.push(node.sibling);
+    if (isHost(node)) {
+      out.push(node.stateNode);
+    } else if (node.tag === Tag.HostText) {
+      const parent = node.stateNode.parentElement;
+      if (parent && !out.includes(parent)) out.push(parent);
+    } else if (node.child) {
+      stack.push(node.child);
+    }
+  }
+  return out;
+}
+function compositeChain(f) {
+  const chain = [];
+  for (let node = f; node; node = node.return) if (isComposite(node)) chain.push(node);
+  return chain.reverse();
+}
+function currentOf(f) {
+  let top = f;
+  while (top.return) top = top.return;
+  if (top.tag !== Tag.HostRoot || top.stateNode?.current === top) return f;
+  return f.alternate ?? f;
+}
+function compositeChildren(f, skip, limit = 100) {
+  const out = [];
+  const stack = [];
+  const first = currentOf(f).child;
+  if (first) stack.push(first);
+  while (stack.length && out.length < limit) {
+    const node = stack.pop();
+    if (node.sibling) stack.push(node.sibling);
+    if (isComposite(node) && !skip(node)) out.push(node);
+    else if (node.child) stack.push(node.child);
+  }
+  return out;
+}
+
+// src/core/roots-notify.ts
+var listeners2 = /* @__PURE__ */ new Set();
+function noteRoot(root) {
+  if (root?._internalRoot) registerRoot(root._internalRoot);
+  listeners2.forEach((listener) => listener());
+}
+function onRootCreated(listener) {
+  listeners2.add(listener);
+  return () => listeners2.delete(listener);
+}
+
+export {
+  servedPath,
+  parseStack,
+  libraryOf,
+  sourcesUnavailable,
+  isProviderTag,
+  isConsumerTag,
+  hookCells,
+  laneLabel,
+  captureRenderers,
+  reactVersion,
+  renderer,
+  setSiteMapper,
+  onSitesMapped,
+  Tag,
+  isHost,
+  isComposite,
+  mountedInPlace,
+  hasHooks,
+  hasProfileTimings,
+  nameOf,
+  isProvider,
+  wrapsProvider,
+  isLibraryFiber,
+  sourceOf,
+  generatedSourceOf,
+  siteKeyOf,
+  fiberFromNode,
+  eachFiber,
+  hostRootOf,
+  findRoots,
+  nearestHosts,
+  compositeChain,
+  currentOf,
+  compositeChildren,
+  noteRoot,
+  onRootCreated
+};

package/dist/browser/chunk-NTY2W4HE.js

@@ -0,0 +1,182 @@
+import {
+  libraryOf,
+  parseStack,
+  servedPath
+} from "./chunk-7DJUCCWG.js";
+
+// src/runtime/memo.ts
+var MAX_DISTINCT = 64;
+function createdAt(rec) {
+  const frame = parseStack(rec.created?.stack ?? "").slice(1).find((f) => libraryOf(f.url) === null);
+  if (!frame) return { name: rec.kind, file: "" };
+  const file = servedPath(frame.url).replace(/^src\//, "");
+  const fn = /^[A-Za-z_$][\w$]*$/.test(frame.fn) ? frame.fn : "";
+  return { name: `${rec.kind} in ${fn ? `${fn} \xB7 ` : ""}${file.split("/").pop()}`, file };
+}
+function createMemoInstrumentation() {
+  const state = { on: false, depth: 0 };
+  const byFn = /* @__PURE__ */ new WeakMap();
+  const live = /* @__PURE__ */ new Set();
+  const objectIds = /* @__PURE__ */ new WeakMap();
+  let nextId = 1;
+  const keyOf = (value) => {
+    if (value === null || typeof value !== "object" && typeof value !== "function") {
+      const text = String(value);
+      return typeof value === "bigint" ? `${text}n` : text.slice(0, 40);
+    }
+    let id = objectIds.get(value);
+    if (!id) objectIds.set(value, id = nextId++);
+    return `#${id}`;
+  };
+  const argsKey = (args) => {
+    let key = "";
+    for (let i = 1; i < args.length; i++) key += `${i > 1 ? "|" : ""}${keyOf(args[i])}`;
+    return key;
+  };
+  const instrument = (factory, kind, fnArg) => function(...args) {
+    let index = typeof fnArg === "number" ? fnArg : -1;
+    if (fnArg === "lastFunction") {
+      for (let i = args.length - 1; i >= 0 && index < 0; i--) if (typeof args[i] === "function") index = i;
+    }
+    const fn = args[index];
+    if (typeof fn !== "function") return factory.apply(this, args);
+    const options = args[index + 1];
+    const size = options && typeof options === "object" && typeof options.size === "number" ? options.size : 1;
+    const rec = {
+      name: "",
+      file: "",
+      kind,
+      size,
+      calls: 0,
+      recomputes: 0,
+      nestedCalls: 0,
+      recomputesOnArgSwitch: 0,
+      distinct: /* @__PURE__ */ new Set(),
+      lastKey: null,
+      evictions: 0,
+      storedAt: /* @__PURE__ */ new Map(),
+      created: new Error()
+    };
+    const inner = function(...innerArgs) {
+      if (state.on) rec.recomputes++;
+      return fn.apply(this, innerArgs);
+    };
+    const wrappedArgs = args.slice();
+    wrappedArgs[index] = inner;
+    const memo = factory.apply(this, wrappedArgs);
+    if (typeof memo !== "function") return memo;
+    const outer = function(...callArgs) {
+      if (!state.on) return memo.apply(this, callArgs);
+      rec.calls++;
+      const nested = state.depth > 0;
+      if (nested) rec.nestedCalls++;
+      const before = rec.recomputes;
+      state.depth++;
+      try {
+        return memo.apply(this, callArgs);
+      } finally {
+        state.depth--;
+        if (!nested) {
+          const key = argsKey(callArgs);
+          if (rec.recomputes > before) {
+            if (rec.lastKey !== null && key !== rec.lastKey) rec.recomputesOnArgSwitch++;
+            const stored = rec.storedAt.get(key);
+            if (stored !== void 0 && before - stored >= rec.size) rec.evictions++;
+            if (rec.storedAt.size < MAX_DISTINCT || rec.storedAt.has(key)) rec.storedAt.set(key, rec.recomputes);
+          }
+          rec.lastKey = key;
+          if (rec.distinct.size < MAX_DISTINCT) rec.distinct.add(key);
+        }
+      }
+    };
+    Object.assign(outer, memo);
+    byFn.set(outer, rec);
+    live.add(new WeakRef(outer));
+    return outer;
+  };
+  const records = () => {
+    const out = [];
+    for (const ref of live) {
+      const fn = ref.deref();
+      if (!fn) live.delete(ref);
+      else out.push(byFn.get(fn));
+    }
+    return out;
+  };
+  return {
+    instrument,
+    get recording() {
+      return state.on;
+    },
+    get used() {
+      return records().length > 0;
+    },
+    name(fn, name, file) {
+      const rec = typeof fn === "function" ? byFn.get(fn) : void 0;
+      if (rec) Object.assign(rec, { name, file });
+    },
+    label(fn) {
+      return byFn.get(fn)?.name || null;
+    },
+    start() {
+      for (const rec of records())
+        Object.assign(rec, {
+          calls: 0,
+          recomputes: 0,
+          nestedCalls: 0,
+          recomputesOnArgSwitch: 0,
+          distinct: /* @__PURE__ */ new Set(),
+          lastKey: null,
+          evictions: 0,
+          storedAt: /* @__PURE__ */ new Map()
+        });
+      state.on = true;
+      state.depth = 0;
+    },
+    stop() {
+      state.on = false;
+      const merged = /* @__PURE__ */ new Map();
+      for (const rec of records()) {
+        if (!rec.calls) continue;
+        const { name, file } = rec.name ? rec : createdAt(rec);
+        const key = `${name}|${file}`;
+        const stat = merged.get(key) ?? {
+          name,
+          file,
+          kind: rec.kind,
+          size: rec.size,
+          calls: 0,
+          recomputes: 0,
+          hitRate: 0,
+          nestedCalls: 0,
+          recomputesOnArgSwitch: 0,
+          distinctArgs: 0,
+          evictions: 0,
+          evicting: false
+        };
+        stat.calls += rec.calls;
+        stat.recomputes += rec.recomputes;
+        stat.nestedCalls += rec.nestedCalls;
+        stat.recomputesOnArgSwitch += rec.recomputesOnArgSwitch;
+        stat.evictions += rec.evictions;
+        stat.distinctArgs = Math.max(stat.distinctArgs, rec.distinct.size);
+        merged.set(key, stat);
+      }
+      return [...merged.values()].map((stat) => ({
+        ...stat,
+        hitRate: stat.calls ? +(1 - stat.recomputes / stat.calls).toFixed(3) : 0,
+        // More argument sets than slots, recomputing as they alternate; or answers pushed out while still in use,
+        // which a ring with room for every argument set does too.
+        evicting: stat.recomputes >= 10 && (stat.recomputesOnArgSwitch / stat.recomputes >= 0.5 && stat.distinctArgs > stat.size || stat.evictions / stat.recomputes >= 0.25)
+      })).sort((a, b) => b.recomputes - a.recomputes);
+    }
+  };
+}
+
+// src/runtime/index.ts
+var definePlugin = (factory) => factory;
+
+export {
+  createMemoInstrumentation,
+  definePlugin
+};