13,684 matches across 25 files for func main
snippet_mode: auto · sorted by relevance
30 ElementTypeClass,
31 ElementTypeContext,
32▶ ElementTypeFunction,
33 ElementTypeForwardRef,
34 ElementTypeHostComponent,
· · ·
177 Plugins,
178} from 'react-devtools-shared/src/frontend/types';
179▶import type {ReactFunctionLocation} from 'shared/ReactTypes';
180import type {
181 FiberInstance,
· · ·
194import {formatOwnerStack} from '../shared/DevToolsOwnerStack';
195
196▶function createFiberInstance(fiber: Fiber): FiberInstance {
197 return {
198 kind: FIBER_INSTANCE,
· · ·
211
212// This is used to represent a filtered Fiber but still lets us find its host instance.
213▶function createFilteredFiberInstance(fiber: Fiber): FilteredFiberInstance {
214 return {
215 kind: FILTERED_FIBER_INSTANCE,
· · ·
227}
228
229▶function createVirtualInstance(
230 debugEntry: ReactComponentInfo,
231): VirtualInstance {
+ 351 more matches in this file
19import type {ActivityState} from './ReactFiberActivityComponent';
20import type {SuspenseState} from './ReactFiberSuspenseComponent';
21▶import type {FunctionComponentUpdateQueue} from './ReactFiberHooks';
22import type {Transition} from 'react/src/ReactStartTransition';
23import type {
· · ·
148 SuspenseListComponent,
149 OffscreenComponent,
150▶ FunctionComponent,
151 ForwardRef,
152 MemoComponent,
· · ·
232 SelectiveHydrationException,
233 beginWork,
234▶ replayFunctionComponent,
235} from './ReactFiberBeginWork';
236import {completeWork} from './ReactFiberCompleteWork';
· · ·
416import {claimQueuedTransitionTypes} from './ReactFiberTransitionTypes';
417
418▶const PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
419
420type ExecutionContext = number;
· · ·
456
457// When this is true, the work-in-progress fiber just suspended (or errored) and
458▶// we've yet to unwind the stack. In some cases, we may yield to the main thread
459// after this happens. If the fiber is pinged before we resume, we can retry
460// immediately instead of unwinding the stack.
+ 200 more matches in this file
80
81import {
82▶ clientRenderBoundary as clientRenderFunction,
83 completeBoundary as completeBoundaryFunction,
84 completeBoundaryUpgradeToViewTransitions as upgradeToViewTransitionsInstruction,
· · ·
83▶ completeBoundary as completeBoundaryFunction,
84 completeBoundaryUpgradeToViewTransitions as upgradeToViewTransitionsInstruction,
85 completeBoundaryWithStyles as styleInsertionFunction,
· · ·
85▶ completeBoundaryWithStyles as styleInsertionFunction,
86 completeSegment as completeSegmentFunction,
87 formReplaying as formReplayingRuntime,
· · ·
86▶ completeSegment as completeSegmentFunction,
87 formReplaying as formReplayingRuntime,
88 markShellTime,
· · ·
127export type InstructionState = number;
128const NothingSent /* */ = 0b000000000;
129▶const SentCompleteSegmentFunction /* */ = 0b000000001;
130const SentCompleteBoundaryFunction /* */ = 0b000000010;
131const SentClientRenderFunction /* */ = 0b000000100;
+ 264 more matches in this file
55} from './ReactFiberDevToolsHook';
56import {
57▶ FunctionComponent,
58 ClassComponent,
59 HostRoot,
· · ·
75 LazyComponent,
76 IncompleteClassComponent,
77▶ IncompleteFunctionComponent,
78 ScopeComponent,
79 OffscreenComponent,
· · ·
110import {
111 disableLegacyContext,
112▶ disableLegacyContextForFunctionComponents,
113 enableProfilerCommitHooks,
114 enableProfilerTimer,
· · ·
262 createFiberFromOffscreen,
263 createWorkInProgress,
264▶ isSimpleFunctionComponent,
265 isFunctionClassComponent,
266} from './ReactFiber';
· · ·
265▶ isFunctionClassComponent,
266} from './ReactFiber';
267import {
+ 149 more matches in this file
182import {
183 disableLegacyContext,
184▶ disableLegacyContextForFunctionComponents,
185 enableScopeAPI,
186 enableAsyncIterableChildren,
· · ·
450};
451
452▶function createPreamble(): Preamble {
453 return {
454 content: createPreambleState(),
· · ·
467// as little as 80%. We can receive half of that each 500ms - at best. In practice,
468// a little bandwidth is lost to processing and contention - e.g. CSS and images that
469▶// are downloaded along with the main content. So we estimate about half of that to be
470// the lower end throughput. In other words, we expect that you can at least show
471// about 12.5kb of content per 500ms. Not counting starting latency for the first
· · ·
474const DEFAULT_PROGRESSIVE_CHUNK_SIZE = 12800;
475
476▶function getBlockingRenderMaxSize(request: Request): number {
477 // We want to make sure that we can block the reveal of a well designed complete
478 // shell but if you have constructed a too large shell (e.g. by not adding any
· · ·
509}
510
511▶function isEligibleForOutlining(
512 request: Request,
513 boundary: SuspenseBoundary,
+ 189 more matches in this file
304export * from 'react-reconciler/src/ReactFiberConfigWithNoPersistence';
305
306▶function getOwnerDocumentFromRootContainer(
307 rootContainerElement: Element | Document | DocumentFragment,
308): Document {
· · ·
312}
313
314▶export function getRootHostContext(
315 rootContainerInstance: Container,
316): HostContext {
· · ·
367}
368
369▶function getOwnHostContext(namespaceURI: string): HostContextNamespace {
370 switch (namespaceURI) {
371 case SVG_NAMESPACE:
· · ·
378}
379
380▶function getChildHostContextProd(
381 parentNamespace: HostContextNamespace,
382 type: string,
· · ·
401}
402
403▶export function getChildHostContext(
404 parentHostContext: HostContext,
405 type: string,
+ 263 more matches in this file
17 ReactIOInfo,
18 ReactStackTrace,
19▶ ReactFunctionLocation,
20 ReactErrorInfoDev,
21} from 'shared/ReactTypes';
· · ·
267
268// $FlowFixMe[missing-this-annot]
269▶function ReactPromise(status: any, value: any, reason: any) {
270 this.status = status;
271 this.value = value;
· · ·
282ReactPromise.prototype = Object.create(Promise.prototype) as any;
283// TODO: This doesn't return a new Promise chain unlike the real .then
284▶function reactPromiseThen<T>(
285 this: SomeChunk<T>,
286 resolve: (value: T) => mixed,
· · ·
322 switch (chunk.status) {
323 case INITIALIZED:
324▶ if (typeof resolve === 'function') {
325 resolve(chunk.value);
326 }
· · ·
329 case PENDING_WEAK:
330 case BLOCKED:
331▶ if (typeof resolve === 'function') {
332 if (chunk.value === null) {
333 chunk.value = [] as Array<InitializationReference | (T => mixed)>;
+ 199 more matches in this file
47 HostPortal,
48 Fragment,
49▶ FunctionComponent,
50} from './ReactWorkTags';
51import isArray from 'shared/isArray';
· · ·
87let currentDebugInfo: null | ReactDebugInfo = null;
88
89▶function pushDebugInfo(
90 debugInfo: null | ReactDebugInfo,
91): null | ReactDebugInfo {
· · ·
107}
108
109▶function getCurrentDebugTask(): null | ConsoleTask {
110 // Get the debug task of the parent Server Component if there is one.
111 if (__DEV__) {
· · ·
129let didWarnAboutGenerators;
130let ownerHasKeyUseWarning;
131▶let ownerHasFunctionTypeWarning;
132let ownerHasSymbolTypeWarning;
133let warnForMissingKey = (
· · ·
147 */
148 ownerHasKeyUseWarning = {} as {[string]: boolean};
149▶ ownerHasFunctionTypeWarning = {} as {[string]: boolean};
150 ownerHasSymbolTypeWarning = {} as {[string]: boolean};
151
+ 98 more matches in this file
64 ReactStackTrace,
65 ReactCallSite,
66▶ ReactFunctionLocation,
67 ReactErrorInfo,
68 ReactErrorInfoDev,
· · ·
170const doNotLimit: WeakSet<Reference> = __DEV__ ? new WeakSet() : (null as any);
171
172▶function defaultFilterStackFrame(
173 filename: string,
174 functionName: string,
· · ·
174▶ functionName: string,
175): boolean {
176 return (
· · ·
181}
182
183▶function devirtualizeURL(url: string): string {
184 if (url.startsWith('about://React/')) {
185 // This callsite is a virtual fake callsite that came from another Flight client.
· · ·
196}
197
198▶function isPromiseCreationInternal(url: string, functionName: string): boolean {
199 // Various internals of the JS VM can create Promises but the call frame of the
200 // internals are not very interesting for our purposes so we need to skip those.
+ 267 more matches in this file
48
49import {
50▶ FunctionComponent,
51 ClassComponent,
52 HostRoot,
· · ·
68 LazyComponent,
69 IncompleteClassComponent,
70▶ IncompleteFunctionComponent,
71 ScopeComponent,
72 OffscreenComponent,
· · ·
170 getRenderTargetTime,
171 getWorkInProgressTransitions,
172▶ shouldRemainOnPreviousScreen,
173 markSpawnedRetryLane,
174} from './ReactFiberWorkLoop';
· · ·
199 * a PlacementAndUpdate.
200 */
201▶function markUpdate(workInProgress: Fiber) {
202 workInProgress.flags |= Update;
203}
· · ·
207 * it received an update that requires a clone of the tree above.
208 */
209▶function markCloned(workInProgress: Fiber) {
210 // $FlowFixMe[constant-condition]
211 if (supportsPersistence) {
+ 32 more matches in this file
15} from '../CompilerError';
16import {CompileErrorDetail} from './Options';
17▶import {ExternalFunction, ReactFunctionType} from '../HIR/Environment';
18import {CodegenFunction} from '../ReactiveScopes';
19import {isComponentDeclaration} from '../Utils/ComponentDeclaration';
· · ·
18▶import {CodegenFunction} from '../ReactiveScopes';
19import {isComponentDeclaration} from '../Utils/ComponentDeclaration';
20import {isHookDeclaration} from '../Utils/HookDeclaration';
· · ·
21import {assertExhaustive} from '../Utils/utils';
22▶import {insertGatedFunctionDeclaration} from './Gating';
23import {
24 addImportsToProgram,
· · ·
34import {compileFn} from './Pipeline';
35import {
36▶ filterSuppressionsThatAffectFunction,
37 findProgramSuppressions,
38 suppressionsToCompilerError,
· · ·
51const DYNAMIC_GATING_DIRECTIVE = new RegExp('^use memo if\\(([^\\)]*)\\)$');
52
53▶export function tryFindDirectiveEnablingMemoization(
54 directives: Array<t.Directive>,
55 opts: ParsedPluginOptions,
+ 171 more matches in this file
4// LICENSE file in the root directory of this source tree.
5
6▶//! Main entrypoint for the React Compiler.
7//!
8//! This module is a port of Program.ts from the TypeScript compiler. It orchestrates
· · ·
11//! 2. Validating restricted imports
12//! 3. Finding program-level suppressions
13▶//! 4. Discovering functions to compile (components, hooks)
14//! 5. Processing each function through the compilation pipeline
15//! 6. Applying compiled functions back to the AST
· · ·
14▶//! 5. Processing each function through the compilation pipeline
15//! 6. Applying compiled functions back to the AST
16
· · ·
15▶//! 6. Applying compiled functions back to the AST
16
17use rustc_hash::{FxHashMap, FxHashSet};
· · ·
40use react_compiler_diagnostics::ErrorCategory;
41use react_compiler_diagnostics::SourceLocation;
42▶use react_compiler_hir::ReactFunctionType;
43use react_compiler_hir::environment_config::EnvironmentConfig;
44use react_compiler_lowering::FunctionNode;
+ 373 more matches in this file
29import type {SuspenseState, RetryQueue} from './ReactFiberSuspenseComponent';
30import type {UpdateQueue} from './ReactFiberClassUpdateQueue';
31▶import type {FunctionComponentUpdateQueue} from './ReactFiberHooks';
32import type {Wakeable, ViewTransitionProps} from 'shared/ReactTypes';
33import type {
· · ·
64} from 'shared/ReactFeatureFlags';
65import {
66▶ FunctionComponent,
67 ForwardRef,
68 ClassComponent,
· · ·
309let needsFormReset = false;
310
311▶const PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
312
313let nextEffect: Fiber | null = null;
· · ·
327let rootViewTransitionNameCanceled: boolean = false;
328
329▶function isHydratingParent(current: Fiber, finishedWork: Fiber): boolean {
330 if (finishedWork.tag === ActivityComponent) {
331 const prevState: ActivityState | null = current.memoizedState;
· · ·
350}
351
352▶export function commitBeforeMutationEffects(
353 root: FiberRoot,
354 firstChild: Fiber,
+ 117 more matches in this file
107 requestDeferredLane,
108 markSkippedUpdateLanes,
109▶ isInvalidExecutionContextForEventFunction,
110} from './ReactFiberWorkLoop';
111
· · ·
203};
204
205▶// The effect "instance" is a shared object that remains the same for the entire
206// lifetime of an effect. In Rust terms, a RefCell. We use it to store the
207// "destroy" function that is returned from an effect, because that is stateful.
· · ·
207▶// "destroy" function that is returned from an effect, because that is stateful.
208// The field is `undefined` if the effect is unmounted, or if the effect ran
209// but is not stateful. We don't explicitly track whether the effect is mounted
· · ·
239};
240
241▶type EventFunctionPayload<Args, Return, F: (...Array<Args>) => Return> = {
242 ref: {
243 eventFn: F,
· · ·
247};
248
249▶export type FunctionComponentUpdateQueue = {
250 lastEffect: Effect | null,
251 events: Array<EventFunctionPayload<any, any, any>> | null,
+ 185 more matches in this file
43 enableProfilerTimer &&
44 typeof console !== 'undefined' &&
45▶ typeof console.timeStamp === 'function' &&
46 (!__DEV__ ||
47 // In DEV we also rely on performance.measure
· · ·
48 (typeof performance !== 'undefined' &&
49 // $FlowFixMe[method-unbinding]
50▶ typeof performance.measure === 'function'));
51
52const COMPONENTS_TRACK = 'Components ⚛';
· · ·
55let currentTrack: string = 'Blocking'; // Lane
56
57▶export function setCurrentTrackFromLanes(lanes: Lanes): void {
58 currentTrack = getGroupNameOfHighestPriorityLane(lanes);
59}
· · ·
60
61▶export function markAllLanesInOrder() {
62 if (supportsUserTiming) {
63 // Ensure we create all tracks in priority order. Currently performance.mark() are in
· · ·
110}
111
112▶function logComponentTrigger(
113 fiber: Fiber,
114 startTime: number,
+ 35 more matches in this file
12use crate::globals::{self};
13use crate::object_shape::BUILT_IN_MIXED_READONLY_ID;
14▶use crate::object_shape::FunctionSignature;
15use crate::object_shape::HookKind;
16use crate::object_shape::HookSignatureBuilder;
· · ·
49 pub types: Vec<Type>,
50 pub scopes: Vec<ReactiveScope>,
51▶ pub functions: Vec<HirFunction>,
52
53 // Error accumulation
· · ·
54 pub errors: CompilerError,
55
56▶ // Function type classification (Component, Hook, Other)
57 pub fn_type: ReactFunctionType,
58
· · ·
57▶ pub fn_type: ReactFunctionType,
58
59 // Output mode (Client, Ssr, Lint)
· · ·
105 default_mutating_hook: Option<Global>,
106
107▶ // Outlined functions: functions extracted from the component during outlining passes
108 outlined_functions: Vec<OutlinedFunctionEntry>,
109
+ 55 more matches in this file
167const SESSION_ID = `react-devtools-cdt-mcp-${process.pid}-${Date.now()}`;
168
169▶function log(message: string): void {
170 process.stdout.write(`${message}\n`);
171}
· · ·
172
173▶function sleep(ms: number): Promise<void> {
174 return new Promise(resolve => setTimeout(resolve, ms));
175}
· · ·
176
177▶function createError(message: string): Error {
178 // eslint-disable-next-line react-internal/prod-error-codes
179 return new Error(message);
· · ·
180}
181
182▶function ensureBuiltModules(): void {
183 if (!fs.existsSync(BUILT_MODULES_DIR)) {
184 throw createError(
· · ·
189}
190
191▶function getFreePort(): Promise<number> {
192 return new Promise((resolve, reject) => {
193 const server = net.createServer();
+ 68 more matches in this file
123 IdleHydrationLane;
124
125▶// This function is used for the experimental timeline (react-devtools-timeline)
126// It should be kept in sync with the Lanes values above.
127export function getLabelForLane(lane: Lane): string | void {
· · ·
127▶export function getLabelForLane(lane: Lane): string | void {
128 if (enableSchedulingProfiler) {
129 if (lane & SyncHydrationLane) {
· · ·
178let nextRetryLane: Lane = RetryLane1;
179
180▶function getHighestPriorityLanes(lanes: Lanes | Lane): Lanes {
181 const pendingSyncLanes = lanes & SyncUpdateLanes;
182 if (pendingSyncLanes !== 0) {
· · ·
247}
248
249▶export function getNextLanes(
250 root: FiberRoot,
251 wipLanes: Lanes,
· · ·
301 }
302 } else {
303▶ // The only remaining work is Idle.
304 // TODO: Idle isn't really used anywhere, and the thinking around
305 // speculative rendering has evolved since this was implemented. Consider
+ 71 more matches in this file
67var timerQueue: Array<Task> = [];
68
69▶// Incrementing id counter. Used to maintain insertion order.
70var taskIdCounter = 1;
71
· · ·
83 | null
84 | ((
85▶ hasTimeRemaining: boolean,
86 initialTime: DOMHighResTimeStamp | number,
87 ) => boolean) = null;
· · ·
97var disableYieldValue = false;
98
99▶function setDisableYieldValue(newValue: boolean) {
100 disableYieldValue = newValue;
101}
· · ·
102
103▶function advanceTimers(currentTime: number) {
104 // Check for tasks that are no longer delayed and add them to the queue.
105 let timer = peek(timerQueue);
· · ·
119 }
120 } else {
121▶ // Remaining timers are pending.
122 return;
123 }
+ 35 more matches in this file
25} from './HIR';
26
27▶export function* eachInstructionLValue(
28 instr: ReactiveInstruction,
29): Iterable<Place> {
· · ·
34}
35
36▶export function* eachInstructionLValueWithKind(
37 instr: ReactiveInstruction,
38): Iterable<[Place, InstructionKind]> {
· · ·
60}
61
62▶export function* eachInstructionValueLValue(
63 value: ReactiveValue,
64): Iterable<Place> {
· · ·
83}
84
85▶export function* eachInstructionOperand(instr: Instruction): Iterable<Place> {
86 yield* eachInstructionValueOperand(instr.value);
87}
· · ·
88▶export function* eachInstructionValueOperand(
89 instrValue: InstructionValue,
90): Iterable<Place> {
+ 24 more matches in this file
27 * character to exclude identifiers like "user".
28 */
29▶function isHookName(s: string): boolean {
30 return s === 'use' || /^use[A-Z0-9]/.test(s);
31}
· · ·
35 * containing a hook name.
36 */
37▶function isHook(node: Node): boolean {
38 if (node.type === 'Identifier') {
39 return isHookName(node.name);
· · ·
55 * always start with an uppercase letter.
56 */
57▶function isComponentName(node: Node): boolean {
58 return node.type === 'Identifier' && /^[A-Z]/.test(node.name);
59}
· · ·
60
61▶function isReactFunction(node: Node, functionName: string): boolean {
62 return (
63 ('name' in node && node.name === functionName) ||
· · ·
63▶ ('name' in node && node.name === functionName) ||
64 (node.type === 'MemberExpression' &&
65 'name' in node.object &&
+ 90 more matches in this file
1▶(function () {
2 'use strict';
3
· · ·
4▶ var ReactImage0 = function (x) {
5 if (x === 0) {
6 return React.createElement('i', {
· · ·
233 };
234
235▶ var AbstractLink1 = function (x) {
236 if (x === 1) {
237 return React.createElement(
· · ·
244 href: '#',
245 rel: undefined,
246▶ onClick: function () {},
247 },
248 null,
· · ·
277 href: '#',
278 rel: undefined,
279▶ onClick: function () {},
280 },
281 undefined,
+ 277 more matches in this file
60const hasPerformanceNow =
61 // $FlowFixMe[method-unbinding]
62▶ typeof performance === 'object' && typeof performance.now === 'function';
63
64if (hasPerformanceNow) {
· · ·
80var timerQueue: Array<Task> = [];
81
82▶// Incrementing id counter. Used to maintain insertion order.
83var taskIdCounter = 1;
84
· · ·
95
96// Capture local references to native APIs, in case a polyfill overrides them.
97▶const localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
98const localClearTimeout =
99 typeof clearTimeout === 'function' ? clearTimeout : null;
· · ·
99▶ typeof clearTimeout === 'function' ? clearTimeout : null;
100const localSetImmediate =
101 typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
· · ·
102
103▶function advanceTimers(currentTime: number) {
104 // Check for tasks that are no longer delayed and add them to the queue.
105 let timer = peek(timerQueue);
+ 29 more matches in this file
114let currentEventTransitionLane: Lane = NoLane;
115
116▶export function ensureRootIsScheduled(root: FiberRoot): void {
117 // This function is called whenever a root receives an update. It does two
118 // things 1) it ensures the root is in the root schedule, and 2) it ensures
· · ·
117▶ // This function is called whenever a root receives an update. It does two
118 // things 1) it ensures the root is in the root schedule, and 2) it ensures
119 // there's a pending microtask to process the root schedule.
· · ·
152}
153
154▶export function ensureScheduleIsScheduled(): void {
155 // At the end of the current event, go through each of the roots and ensure
156 // there's a task scheduled for each one at the correct priority.
· · ·
169}
170
171▶export function flushSyncWorkOnAllRoots() {
172 // This is allowed to be called synchronously, but the caller should check
173 // the execution context first.
· · ·
175}
176
177▶export function flushSyncWorkOnLegacyRootsOnly() {
178 // This is allowed to be called synchronously, but the caller should check
179 // the execution context first.
+ 22 more matches in this file
20use react_compiler_hir::visitors::{ScopeBlockInfo, ScopeBlockTraversal};
21use react_compiler_hir::{
22▶ BasicBlock, BlockId, DeclarationId, DependencyPathEntry, EvaluationOrder, FunctionId,
23 GotoVariant, HirFunction, IdentifierId, Instruction, InstructionId, InstructionKind,
24 InstructionValue, MutableRange, ParamPattern, Place, PlaceOrSpread, PropertyLiteral,
· · ·
23▶ GotoVariant, HirFunction, IdentifierId, Instruction, InstructionId, InstructionKind,
24 InstructionValue, MutableRange, ParamPattern, Place, PlaceOrSpread, PropertyLiteral,
25 ReactFunctionType, ReactiveScopeDependency, ScopeId, Terminal, Type, visitors,
· · ·
25▶ ReactFunctionType, ReactiveScopeDependency, ScopeId, Terminal, Type, visitors,
26};
27
· · ·
30// =============================================================================
31
32▶/// Main entry point: propagate scope dependencies through the HIR.
33/// Corresponds to TS `propagateScopeDependenciesHIR(fn)`.
34pub fn propagate_scope_dependencies_hir(func: &mut HirFunction, env: &mut Environment) {
· · ·
34▶pub fn propagate_scope_dependencies_hir(func: &mut HirFunction, env: &mut Environment) {
35 let used_outside_declaring_scope = find_temporaries_used_outside_declaring_scope(func, env);
36 let temporaries = collect_temporaries_sidemap(func, env, &used_outside_declaring_scope);
+ 148 more matches in this file