@rn-perf-kit/react 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +20 -4
- package/src/PerfTrace.tsx +37 -0
- package/src/fiber-hook.ts +118 -0
- package/src/index.ts +4 -0
- package/src/useDiscardedRenderTracker.ts +38 -0
- package/src/usePerfScreen.ts +34 -0
- package/tsconfig.json +8 -0
- package/README.md +0 -3
package/package.json
CHANGED
|
@@ -1,6 +1,22 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@rn-perf-kit/react",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.1.0",
|
|
4
|
+
"description": "React fiber hook adapter, PerfTrace component, render/commit tracker",
|
|
5
|
+
"main": "./src/index.ts",
|
|
6
|
+
"types": "./src/index.ts",
|
|
7
|
+
"scripts": {
|
|
8
|
+
"typecheck": "tsc --noEmit",
|
|
9
|
+
"lint": "eslint src/"
|
|
10
|
+
},
|
|
11
|
+
"peerDependencies": {
|
|
12
|
+
"react": ">=18.0.0",
|
|
13
|
+
"react-native": ">=0.73.0"
|
|
14
|
+
},
|
|
15
|
+
"devDependencies": {
|
|
16
|
+
"typescript": "^5.3.0",
|
|
17
|
+
"@types/react": "^18.0.0"
|
|
18
|
+
},
|
|
19
|
+
"dependencies": {
|
|
20
|
+
"@rn-perf-kit/core": "^0.1.0"
|
|
21
|
+
}
|
|
22
|
+
}
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* PerfTrace — wraps React Profiler for Level 1 render measurement.
|
|
3
|
+
*/
|
|
4
|
+
import React, { type ReactNode, Profiler, type ProfilerOnRenderCallback } from 'react';
|
|
5
|
+
import { timeline } from '@rn-perf-kit/core';
|
|
6
|
+
|
|
7
|
+
interface PerfTraceProps {
|
|
8
|
+
id: string;
|
|
9
|
+
children: ReactNode;
|
|
10
|
+
disabled?: boolean;
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
const onRenderCallback: ProfilerOnRenderCallback = (
|
|
14
|
+
_id,
|
|
15
|
+
phase,
|
|
16
|
+
actualDuration,
|
|
17
|
+
_baseDuration,
|
|
18
|
+
_startTime,
|
|
19
|
+
commitTime
|
|
20
|
+
) => {
|
|
21
|
+
timeline.add({
|
|
22
|
+
type: 'commit',
|
|
23
|
+
t: commitTime,
|
|
24
|
+
dur: actualDuration,
|
|
25
|
+
phase: phase === 'mount' ? 'mount' : phase === 'nested-update' ? 'nested-update' : 'update',
|
|
26
|
+
fibers: [],
|
|
27
|
+
});
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
export function PerfTrace({ id, children, disabled = false }: PerfTraceProps): React.JSX.Element {
|
|
31
|
+
if (disabled) return <>{children}</>;
|
|
32
|
+
return (
|
|
33
|
+
<Profiler id={id} onRender={onRenderCallback}>
|
|
34
|
+
{children}
|
|
35
|
+
</Profiler>
|
|
36
|
+
);
|
|
37
|
+
}
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Versioned fiber hook adapter.
|
|
3
|
+
* Installs __REACT_DEVTOOLS_GLOBAL_HOOK__ before React initializes.
|
|
4
|
+
* Compatible with: React 18.x (New Architecture)
|
|
5
|
+
*
|
|
6
|
+
* IMPORTANT: Fiber internals are private. All access is isolated here.
|
|
7
|
+
* Version this file per React version.
|
|
8
|
+
*/
|
|
9
|
+
|
|
10
|
+
import { timeline } from '@rn-perf-kit/core';
|
|
11
|
+
import type { RenderedFiber, RenderCause } from '@rn-perf-kit/core';
|
|
12
|
+
|
|
13
|
+
// React internal flags (ReactFiberFlags.js) — may change between versions
|
|
14
|
+
const PerformedWork = 0b000000000000000000000000001;
|
|
15
|
+
|
|
16
|
+
interface Fiber {
|
|
17
|
+
tag: number;
|
|
18
|
+
type: unknown;
|
|
19
|
+
key: string | null;
|
|
20
|
+
memoizedProps: Record<string, unknown> | null;
|
|
21
|
+
memoizedState: unknown;
|
|
22
|
+
pendingProps: Record<string, unknown> | null;
|
|
23
|
+
flags: number;
|
|
24
|
+
alternate: Fiber | null;
|
|
25
|
+
dependencies: { firstContext: unknown } | null;
|
|
26
|
+
child: Fiber | null;
|
|
27
|
+
sibling: Fiber | null;
|
|
28
|
+
actualDuration?: number;
|
|
29
|
+
selfBaseDuration?: number;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
type FiberRoot = { current: Fiber };
|
|
33
|
+
|
|
34
|
+
let enabled = false;
|
|
35
|
+
let deepMode = false;
|
|
36
|
+
|
|
37
|
+
export function installFiberHook(): void {
|
|
38
|
+
if (typeof global === 'undefined') return;
|
|
39
|
+
if ((global as any).__REACT_DEVTOOLS_GLOBAL_HOOK__) return;
|
|
40
|
+
|
|
41
|
+
(global as any).__REACT_DEVTOOLS_GLOBAL_HOOK__ = {
|
|
42
|
+
isDisabled: false,
|
|
43
|
+
supportsFiber: true,
|
|
44
|
+
renderers: new Map(),
|
|
45
|
+
inject(_renderer: unknown) { return 1; },
|
|
46
|
+
onCommitFiberRoot(_rendererID: number, root: FiberRoot, _priority: unknown) {
|
|
47
|
+
if (!enabled) return;
|
|
48
|
+
try { processCommit(root); } catch (_e) {}
|
|
49
|
+
},
|
|
50
|
+
onCommitFiberUnmount(_rendererID: number, _fiber: Fiber) {},
|
|
51
|
+
onPostCommitFiberRoot(_rendererID: number, _root: FiberRoot) {},
|
|
52
|
+
};
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
export function setFiberHookEnabled(value: boolean, deep = false): void {
|
|
56
|
+
enabled = value;
|
|
57
|
+
deepMode = deep;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function processCommit(root: FiberRoot): void {
|
|
61
|
+
const t = timeline.now();
|
|
62
|
+
const fibers: RenderedFiber[] = [];
|
|
63
|
+
if (deepMode) walkFibers(root.current, fibers);
|
|
64
|
+
timeline.add({ type: 'commit', t, dur: 0, fibers, phase: 'update' });
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
function walkFibers(fiber: Fiber | null, out: RenderedFiber[]): void {
|
|
68
|
+
if (!fiber) return;
|
|
69
|
+
if (fiber.flags & PerformedWork) {
|
|
70
|
+
const name = getFiberName(fiber);
|
|
71
|
+
const cause = classifyRenderCause(fiber);
|
|
72
|
+
out.push({ name, cause, actualDuration: fiber.actualDuration ?? 0, wasted: isWasted(cause) });
|
|
73
|
+
}
|
|
74
|
+
walkFibers(fiber.child, out);
|
|
75
|
+
walkFibers(fiber.sibling, out);
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
function getFiberName(fiber: Fiber): string {
|
|
79
|
+
if (typeof fiber.type === 'string') return fiber.type;
|
|
80
|
+
if (typeof fiber.type === 'function') {
|
|
81
|
+
return (fiber.type as Function).displayName ?? (fiber.type as Function).name ?? 'Anonymous';
|
|
82
|
+
}
|
|
83
|
+
return 'Unknown';
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
function classifyRenderCause(fiber: Fiber): RenderCause {
|
|
87
|
+
const alt = fiber.alternate;
|
|
88
|
+
if (!alt) return 'prop-change';
|
|
89
|
+
if (fiber.memoizedState !== alt.memoizedState) return 'state-change';
|
|
90
|
+
if (fiber.dependencies?.firstContext) return 'context-change';
|
|
91
|
+
const prev = alt.memoizedProps;
|
|
92
|
+
const next = fiber.memoizedProps ?? fiber.pendingProps;
|
|
93
|
+
if (!shallowEqual(prev, next)) {
|
|
94
|
+
if (deepEqual(prev, next)) return 'unstable-reference';
|
|
95
|
+
return 'prop-change';
|
|
96
|
+
}
|
|
97
|
+
return 'parent-rerender';
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
function isWasted(cause: RenderCause): boolean {
|
|
101
|
+
return cause === 'parent-rerender' || cause === 'unstable-reference';
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
function shallowEqual(
|
|
105
|
+
a: Record<string, unknown> | null,
|
|
106
|
+
b: Record<string, unknown> | null
|
|
107
|
+
): boolean {
|
|
108
|
+
if (a === b) return true;
|
|
109
|
+
if (!a || !b) return false;
|
|
110
|
+
const ka = Object.keys(a);
|
|
111
|
+
const kb = Object.keys(b);
|
|
112
|
+
if (ka.length !== kb.length) return false;
|
|
113
|
+
return ka.every((k) => a[k] === b[k]);
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
function deepEqual(a: unknown, b: unknown): boolean {
|
|
117
|
+
try { return JSON.stringify(a) === JSON.stringify(b); } catch { return false; }
|
|
118
|
+
}
|
package/src/index.ts
ADDED
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Discarded render tracker for concurrent React.
|
|
3
|
+
*/
|
|
4
|
+
import { useLayoutEffect } from 'react';
|
|
5
|
+
import { timeline } from '@rn-perf-kit/core';
|
|
6
|
+
|
|
7
|
+
const pending = new Map<number, { name: string; t: number; count: number }>();
|
|
8
|
+
let tokenCounter = 0;
|
|
9
|
+
let sweepTimer: ReturnType<typeof setInterval> | null = null;
|
|
10
|
+
const STALE_MS = 100;
|
|
11
|
+
|
|
12
|
+
function nextToken(): number { return ++tokenCounter; }
|
|
13
|
+
|
|
14
|
+
function startSweep(): void {
|
|
15
|
+
if (sweepTimer !== null) return;
|
|
16
|
+
sweepTimer = setInterval(() => {
|
|
17
|
+
const now = timeline.now();
|
|
18
|
+
pending.forEach((entry, token) => {
|
|
19
|
+
if (now - entry.t > STALE_MS) {
|
|
20
|
+
timeline.add({ type: 'render-discarded', t: entry.t, component: entry.name, renderCount: entry.count });
|
|
21
|
+
pending.delete(token);
|
|
22
|
+
}
|
|
23
|
+
});
|
|
24
|
+
}, 200);
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
export function stopDiscardedRenderSweep(): void {
|
|
28
|
+
if (sweepTimer !== null) { clearInterval(sweepTimer); sweepTimer = null; }
|
|
29
|
+
pending.clear();
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
export function useDiscardedRenderTracker(componentName: string): void {
|
|
33
|
+
const token = nextToken();
|
|
34
|
+
const existing = pending.get(token);
|
|
35
|
+
pending.set(token, { name: componentName, t: timeline.now(), count: existing ? existing.count + 1 : 1 });
|
|
36
|
+
startSweep();
|
|
37
|
+
useLayoutEffect(() => { pending.delete(token); });
|
|
38
|
+
}
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Hook to track screen-level performance for a named screen.
|
|
3
|
+
*/
|
|
4
|
+
import { useCallback, useEffect, useRef } from 'react';
|
|
5
|
+
import { timeline } from '@rn-perf-kit/core';
|
|
6
|
+
|
|
7
|
+
export interface PerfScreenHandle {
|
|
8
|
+
markReady: () => void;
|
|
9
|
+
}
|
|
10
|
+
|
|
11
|
+
export function usePerfScreen(screenName: string): PerfScreenHandle {
|
|
12
|
+
const mountedAt = useRef(timeline.now());
|
|
13
|
+
const markedReady = useRef(false);
|
|
14
|
+
|
|
15
|
+
useEffect(() => {
|
|
16
|
+
mountedAt.current = timeline.now();
|
|
17
|
+
markedReady.current = false;
|
|
18
|
+
timeline.mark(`screen:mount:${screenName}`);
|
|
19
|
+
return () => { timeline.mark(`screen:unmount:${screenName}`); };
|
|
20
|
+
}, [screenName]);
|
|
21
|
+
|
|
22
|
+
const markReady = useCallback(() => {
|
|
23
|
+
if (markedReady.current) return;
|
|
24
|
+
markedReady.current = true;
|
|
25
|
+
const readyAt = timeline.now();
|
|
26
|
+
timeline.mark(`screen:ready:${screenName}`, {
|
|
27
|
+
mountedAt: mountedAt.current,
|
|
28
|
+
readyAt,
|
|
29
|
+
ttfr: readyAt - mountedAt.current,
|
|
30
|
+
});
|
|
31
|
+
}, [screenName]);
|
|
32
|
+
|
|
33
|
+
return { markReady };
|
|
34
|
+
}
|
package/tsconfig.json
ADDED
package/README.md
DELETED