react-perf-recorder 0.1.0

package/dist/browser/plugins/react-query.js

@@ -0,0 +1,74 @@
+import {
+  definePlugin
+} from "../chunk-NTY2W4HE.js";
+import "../chunk-7DJUCCWG.js";
+
+// src/plugins/react-query/runtime.ts
+var ACTIONS = /* @__PURE__ */ new Set(["fetch", "success", "error", "invalidate"]);
+var SEARCH_EVERY_MS = 1e3;
+var runtime_default = definePlugin(() => {
+  let unsubscribe = null;
+  let found = false;
+  let searchedAt = -Infinity;
+  const counts = /* @__PURE__ */ new Map();
+  const kinds = /* @__PURE__ */ new WeakMap();
+  function search(session) {
+    searchedAt = session.now();
+    const [provider] = session.findFibers((f) => typeof f.memoizedProps?.client?.getQueryCache === "function", 1);
+    if (!provider) return;
+    found = true;
+    const cache = provider.memoizedProps.client.getQueryCache();
+    unsubscribe = cache.subscribe((event) => {
+      const action = event.action?.type;
+      const updated = event.type === "updated";
+      if (!(event.type === "added" || event.type === "removed" || updated && action && ACTIONS.has(action))) return;
+      const key = JSON.stringify(event.query.queryKey).slice(0, 70);
+      const kind = updated ? action : event.type;
+      counts.set(`${kind} ${key}`, (counts.get(`${kind} ${key}`) ?? 0) + 1);
+      if (!updated) {
+        session.emitCause({ type: `${kind} ${key}` });
+        return;
+      }
+      const cause = session.emitCause({ type: `${kind} ${key}`, waitForTimer: true, merge: key });
+      if (!cause) return;
+      const seen = kinds.get(cause);
+      if (seen) {
+        if (!seen.includes(kind)) seen.push(kind);
+        cause.type = `${seen.join(" \u2192 ")} ${key}`;
+      } else kinds.set(cause, [kind]);
+    });
+  }
+  return {
+    name: "react-query",
+    packages: ["@tanstack/react-query", "@tanstack/query-core"],
+    start(session) {
+      counts.clear();
+      found = false;
+      search(session);
+    },
+    commit(session) {
+      if (!found && session.now() - searchedAt >= SEARCH_EVERY_MS) search(session);
+    },
+    stop(session) {
+      if (!found) search(session);
+      unsubscribe?.();
+      unsubscribe = null;
+      const list = [...counts].sort((a, b) => b[1] - a[1]);
+      const byKind = /* @__PURE__ */ new Map();
+      for (const [type, n] of list) {
+        const kind = type.split(" ")[0];
+        byKind.set(kind, (byKind.get(kind) ?? 0) + n);
+      }
+      return {
+        version: 1,
+        active: found,
+        highlights: list.length ? list.slice(0, 3).map(([type, n]) => `${n}\xD7 ${type}`) : ["no query events during the recording"],
+        metrics: Object.fromEntries([...byKind].map(([kind, n]) => [`events.${kind}`, { value: n, kind: "count" }])),
+        data: { clientFound: found, events: list.slice(0, 50) }
+      };
+    }
+  };
+});
+export {
+  runtime_default as default
+};

package/dist/browser/plugins/zustand.d.ts

@@ -0,0 +1,11 @@
+import { a as RuntimePluginFactory } from '../index-BlkKhwHe.js';
+
+/** `create(fn)` and the curried `create<T>()(fn)` of zustand, `createStore` of zustand/vanilla. */
+declare function wrapCreate<F extends (...args: any[]) => any>(factory: F): F;
+declare function wrapUseShallow<F extends (...args: any[]) => any>(useShallow: F): F;
+declare function nameStore(store: unknown, name: string): void;
+declare const _default: RuntimePluginFactory<{
+    devtools?: boolean;
+} | null>;
+
+export { _default as default, nameStore, wrapCreate, wrapUseShallow };

package/dist/browser/plugins/zustand.js

@@ -0,0 +1,171 @@
+import {
+  definePlugin
+} from "../chunk-NTY2W4HE.js";
+import "../chunk-7DJUCCWG.js";
+
+// src/plugins/zustand/devtools-shim.ts
+var KEY = "__REDUX_DEVTOOLS_EXTENSION__";
+function installDevtoolsShim(onSend) {
+  const target = window;
+  const existing = Object.getOwnPropertyDescriptor(target, KEY);
+  if (existing?.get && existing.get.rpr) return;
+  let real = target[KEY] ?? void 0;
+  const shim = Object.assign((...args) => real ? real(...args) : (next) => next, {
+    connect(options) {
+      const connection = real?.connect?.(options);
+      return {
+        init: (...args) => connection?.init?.(...args),
+        subscribe: (listener) => connection?.subscribe?.(listener) ?? (() => {
+        }),
+        unsubscribe: () => connection?.unsubscribe?.(),
+        error: (message) => connection?.error?.(message),
+        send(action, state) {
+          try {
+            onSend(action, state);
+          } catch {
+          }
+          return connection?.send?.(action, state);
+        }
+      };
+    }
+  });
+  const get = Object.assign(() => shim, { rpr: true });
+  Object.defineProperty(target, KEY, {
+    configurable: true,
+    enumerable: false,
+    get,
+    set(value) {
+      if (value !== shim) real = value;
+    }
+  });
+}
+
+// src/plugins/zustand/runtime.ts
+var stores = /* @__PURE__ */ new Set();
+var apiByGetState = /* @__PURE__ */ new WeakMap();
+var names = /* @__PURE__ */ new WeakMap();
+var shallowInner = /* @__PURE__ */ new WeakMap();
+var eventByState = /* @__PURE__ */ new WeakMap();
+var anonymous = 0;
+var follow = null;
+var apiOf = (value) => {
+  const candidate = value;
+  return candidate && typeof candidate.getState === "function" && typeof candidate.subscribe === "function" ? candidate : null;
+};
+function register(result) {
+  const api = apiOf(result);
+  if (api && !apiByGetState.has(api.getState)) {
+    apiByGetState.set(api.getState, api);
+    stores.add(new WeakRef(api));
+    follow?.(api);
+  }
+  return result;
+}
+function wrapCreate(factory) {
+  if (typeof factory !== "function") return factory;
+  return function(...args) {
+    if (args[0] === void 0) {
+      const curried = factory.apply(this, args);
+      return (...inner) => register(curried(...inner));
+    }
+    return register(factory.apply(this, args));
+  };
+}
+function wrapUseShallow(useShallow) {
+  if (typeof useShallow !== "function") return useShallow;
+  return ((selector) => {
+    const fn = useShallow(selector);
+    shallowInner.set(fn, selector);
+    return fn;
+  });
+}
+function nameStore(store, name) {
+  const api = apiOf(store);
+  if (api) names.set(api, name);
+}
+var storeName = (api) => {
+  let name = names.get(api);
+  if (!name) names.set(api, name = `store${++anonymous}`);
+  return name;
+};
+var MAX_KEYS = 40;
+function changedKeys(prev, next) {
+  if (!prev || !next || typeof prev !== "object" || typeof next !== "object") return [{ key: "(state)", prev, next }];
+  const a = prev;
+  const b = next;
+  const out = [];
+  for (const key of Object.keys(b)) if (a[key] !== b[key] && out.length < MAX_KEYS) out.push({ key, prev: a[key], next: b[key] });
+  return out;
+}
+var runtime_default = definePlugin((options) => {
+  const unsubscribes = [];
+  const counts = /* @__PURE__ */ new Map();
+  let ctx = null;
+  let actions = 0;
+  return {
+    name: "zustand",
+    setup(context) {
+      ctx = context;
+      if (options?.devtools === false) return;
+      installDevtoolsShim((action, state) => {
+        if (!ctx?.recording || !state || typeof state !== "object") return;
+        const event = eventByState.get(state);
+        const type = typeof action === "string" ? action : action?.type;
+        if (event && type && type !== "anonymous") {
+          event.type = type;
+          actions++;
+        }
+      });
+    },
+    describe(fn, kind, next) {
+      if (kind === "selector") {
+        const inner = shallowInner.get(fn);
+        return inner ? `useShallow(${next(inner)})` : null;
+      }
+      const api = apiByGetState.get(fn);
+      return api ? storeName(api) : null;
+    },
+    start(session) {
+      counts.clear();
+      actions = 0;
+      follow = (api) => {
+        unsubscribes.push(
+          api.subscribe((state, prev) => {
+            const name = storeName(api);
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+            const event = session.emitCause({ type: `${name}.setState`, changes: changedKeys(prev, state), data: { store: name }, aim: true });
+            if (event && state && typeof state === "object") eventByState.set(state, event);
+          })
+        );
+      };
+      for (const ref of stores) {
+        const api = ref.deref();
+        if (api) follow(api);
+        else stores.delete(ref);
+      }
+    },
+    stop() {
+      follow = null;
+      unsubscribes.splice(0).forEach((unsubscribe) => unsubscribe());
+      const list = [...counts].sort((a, b) => b[1] - a[1]);
+      let active = false;
+      for (const ref of stores) if (ref.deref()) active = true;
+      return {
+        version: 1,
+        active,
+        highlights: list.length ? list.slice(0, 3).map(([name, n]) => `${name}: ${n} updates`) : ["no store updates during the recording"],
+        metrics: {
+          "actions.named": { value: actions, kind: "count" },
+          ...Object.fromEntries(list.map(([name, n]) => [`${name}.updates`, { value: n, kind: "count" }]))
+        },
+        data: { stores: list.map(([name, updates]) => ({ name, updates })) }
+      };
+    }
+  };
+});
+export {
+  runtime_default as default,
+  nameStore,
+  wrapCreate,
+  wrapUseShallow
+};

package/dist/browser/runtime.d.ts

@@ -0,0 +1 @@
+export { C as CauseInput, e as Conditions, D as DescribeKind, F as Fiber, J as JsonValue, M as MemoInstrumentation, i as MemoStat, b as PluginContext, J as PluginOptions, d as PluginSection, c as Primitive, R as RuntimePlugin, a as RuntimePluginFactory, S as SessionContext, j as createMemoInstrumentation, k as definePlugin, n as noteRoot } from './index-BlkKhwHe.js';

package/dist/browser/runtime.js

@@ -0,0 +1,12 @@
+import {
+  createMemoInstrumentation,
+  definePlugin
+} from "./chunk-NTY2W4HE.js";
+import {
+  noteRoot
+} from "./chunk-7DJUCCWG.js";
+export {
+  createMemoInstrumentation,
+  definePlugin,
+  noteRoot
+};