3,080 matches across 25 files for TODO
snippet_mode: auto · sorted by relevance
173 builder.recordError(
174 CompilerDiagnostic.create({
175▶ category: ErrorCategory.Todo,
176 reason: `Handle ${param.node.type} parameters`,
177 description: `[BuildHIR] Add support for ${param.node.type} parameters`,
· · ·
250 params,
251 fnType: bindings == null ? env.fnType : 'Other',
252▶ returnTypeAnnotation: null, // TODO: extract the actual return type node if present
253 returns: createTemporaryPlace(env, func.node.loc ?? GeneratedSource),
254 body: hirBody,
· · ·
285 reason:
286 '(BuildHIR::lowerStatement) Support ThrowStatement inside of try/catch',
287▶ category: ErrorCategory.Todo,
288 loc: stmt.node.loc ?? null,
289 suggestions: null,
· · ·
473 builder.recordError(
474 new CompilerErrorDetail({
475▶ category: ErrorCategory.Todo,
476 reason: 'Unsupported declaration type for hoisting',
477 description: `variable "${binding.identifier.name}" declared with ${binding.path.type}`,
· · ·
484 builder.recordError(
485 new CompilerErrorDetail({
486▶ category: ErrorCategory.Todo,
487 reason: 'Handle non-const declarations for hoisting',
488 description: `variable "${binding.identifier.name}" declared with ${binding.kind}`,
+ 55 more matches in this file
364function commitBeforeMutationEffects_begin(isViewTransitionEligible: boolean) {
365 // If this commit is eligible for a View Transition we look into all mutated subtrees.
366▶ // TODO: We could optimize this by marking these with the Snapshot subtree flag in the render phase.
367 const subtreeMask = isViewTransitionEligible
368 ? BeforeAndAfterMutationTransitionMask
· · ·
374 // Let's skip the whole loop if it's off.
375 if (enableCreateEventHandleAPI || isViewTransitionEligible) {
376▶ // TODO: Should wrap this in flags check, too, as optimization
377 const deletions = fiber.deletions;
378 if (deletions !== null) {
· · ·
395 // to trigger updates of any nested view transitions and we shouldn't
396 // have any other before mutation effects since snapshot effects are
397▶ // only applied to updates. TODO: Model this using only flags.
398 if (isViewTransitionEligible) {
399 trackEnterViewTransitions(fiber);
· · ·
403 }
404
405▶ // TODO: This should really unify with the switch in commitBeforeMutationEffectsOnFiber recursively.
406 if (enableViewTransition && fiber.tag === OffscreenComponent) {
407 const isModernRoot =
· · ·
427 // to trigger updates of any nested view transitions and we shouldn't
428 // have any other before mutation effects since snapshot effects are
429▶ // only applied to updates. TODO: Model this using only flags.
430 if (isViewTransitionEligible) {
431 trackEnterViewTransitions(fiber);
+ 67 more matches in this file
258 } else {
259 // Auto-generated name.
260▶ // TODO: If Fizz starts applying a prefix to this name, we need to consider that.
261 return actualVtName.startsWith('_T_');
262 }
· · ·
378 // bookkeeping for it. Not sure if we need to clear it when the listener is
379 // removed.
380▶ // TODO: Only do this for the relevant Safaris maybe?
381 node.onclick = noop;
382}
· · ·
424 }
425 // These are very common props and therefore are in the beginning of the switch.
426▶ // TODO: aria-label is a very common prop but allows booleans so is not like the others
427 // but should ideally go in this list too.
428 case 'className':
· · ·
537 case 'action':
538 case 'formAction': {
539▶ // TODO: Consider moving these special cases to the form, input and button tags.
540 if (__DEV__) {
541 validateFormActionInDevelopment(tag, key, value, props);
· · ·
607 }
608 case 'onClick': {
609▶ // TODO: This cast may not be sound for SVG, MathML or custom elements.
610 if (value != null) {
611 if (__DEV__ && typeof value !== 'function') {
+ 32 more matches in this file
517// filled in with the resolved UI. This lets us throttle the appearance of new
518// content as it streams in, to minimize jank.
519▶// TODO: Think of a better name for this variable?
520let globalMostRecentFallbackTime: number = 0;
521// Track the most recent time we started a new Transition. This lets us apply
· · ·
898 const suspenseHandler = getSuspenseHandler();
899 if (suspenseHandler !== null) {
900▶ // TODO: As an optimization, we shouldn't entangle the lanes at the root; we
901 // can entangle them using the baseLanes of the Suspense boundary instead.
902 // We only need to do something special if there's no Suspense boundary.
· · ·
1065 // suspended now, right before marking the incoming update. This has the
1066 // effect of interrupting the current render and switching to the update.
1067▶ // TODO: Make sure this doesn't override pings that happen while we've
1068 // already started rendering.
1069 const didAttemptEntireTree = false;
· · ·
1159 // even if the lanes are synchronous, so that prerendering never blocks
1160 // the main thread.
1161▶ // TODO: We should consider doing this whenever a sync lane is suspended,
1162 // even for regular pings.
1163 checkIfRootIsPrerendering(root, lanes);
· · ·
1181 // render phase, but we do it here so that we resume in
1182 // prerendering mode.
1183▶ // TODO: Consider always calling markRootSuspended immediately.
1184 // Needs to be *after* we attach a ping listener, though.
1185 const didAttemptEntireTree = false;
+ 41 more matches in this file
188 multiple?: boolean,
189 type?: string,
190▶ src?: string | Blob | MediaSource | MediaStream, // TODO: Response
191 srcSet?: string,
192 loading?: 'eager' | 'lazy',
· · ·
481 const lower = scriptType.toLowerCase();
482 // Special non-MIME keywords recognized by the HTML spec
483▶ // TODO: May be fine to also not warn about having these types be parsed as "parser-inserted"
484 if (
485 lower === 'module' ||
· · ·
534 let hostContextProd: HostContextProd;
535 if (__DEV__) {
536▶ // TODO: take namespace into account when validating.
537 const hostContextDev: HostContextDev = hostContext as any;
538 validateDOMNesting(type, hostContextDev.ancestorInfo);
· · ·
671 if (!didWarnForClone) {
672 didWarnForClone = true;
673▶ // TODO: Once we have the ability to avoid cloning the root, suggest an absolutely
674 // positioned ViewTransition instead as the solution.
675 console.warn(
· · ·
868 ? callback =>
869 localPromise.resolve(null).then(callback).catch(handleErrorInNextTick)
870▶ : scheduleTimeout; // TODO: Determine the best fallback here.
871
872function handleErrorInNextTick(error: any) {
+ 30 more matches in this file
287 if (filterStackFrame(url, functionName, lineNumber, columnNumber)) {
288 // Use a clone because the Flight protocol isn't yet resilient to deduping
289▶ // objects in the debug info. TODO: Support deduping stacks.
290 const clone: ReactCallSite = callsite.slice(0) as any;
291 clone[1] = url;
· · ·
366 if (stack.length > firstFrame) {
367 // Check if the very first stack frame that awaited this Promise was in user space.
368▶ // TODO: This doesn't take into account wrapper functions such as our fake .then()
369 // in FlightClient which will always be considered third party awaits if you call
370 // .then directly.
· · ·
1267 finishHaltedTask(streamTask, request);
1268 } else {
1269▶ // TODO: Make this use abortTask() instead.
1270 erroredTask(request, streamTask, reason);
1271 enqueueFlush(request);
· · ·
1401 finishHaltedTask(streamTask, request);
1402 } else {
1403▶ // TODO: Make this use abortTask() instead.
1404 erroredTask(request, streamTask, signal.reason);
1405 enqueueFlush(request);
· · ·
1575 }, voidHandler);
1576 }
1577▶ // TODO: Once we accept Promises as children on the client, we can just return
1578 // the thenable here.
1579 return createLazyWrapperAroundWakeable(request, task, result);
+ 28 more matches in this file
112import type {SharedStateClient} from 'react/src/ReactSharedInternalsClient';
113
114▶// TODO: This is an unfortunate hack. We shouldn't feature detect the internals
115// like this. It's just that for now we support the same build of the Flight
116// client both in the RSC environment, in the SSR environments as well as the
· · ·
256// We subclass Promise.prototype so that we get other methods like .catch
257ReactPromise.prototype = Object.create(Promise.prototype) as any;
258▶// TODO: This doesn't return a new Promise chain unlike the real .then
259ReactPromise.prototype.then = function <T>(
260 this: SomeChunk<T>,
· · ·
577 });
578 }
579▶ // TODO: If the resolved value is a frozen element (e.g. a client-created
580 // element from a temporary reference, or a JSX element exported as a client
581 // reference), server debug info is currently dropped because the element
· · ·
772 // Ignore error parsing debug info, we'll report the original error instead.
773 } else if (initializingHandler.deps > 0) {
774▶ // TODO: Block the resolution of the error until all the debug info has loaded.
775 // We currently don't have a way to throw an error after all dependencies have
776 // loaded because we currently treat errors as immediately cancelling the handler.
· · ·
1067 // unresolved entries.
1068 initializeDebugChunk(response, chunk);
1069▶ // TODO: The chunk might have transitioned to ERRORED now.
1070 // Should we return early if that happens?
1071 }
+ 21 more matches in this file
179 );
180 if (className !== 'none') {
181▶ // TODO: Since the deleted instance already has layout we could
182 // check if it's in the viewport and if not skip the pairing.
183 // It would currently cause layout thrash though so if we did that
· · ·
225 if (className !== 'none') {
226 if (pair !== undefined) {
227▶ // TODO: Since the deleted instance already has layout we could
228 // check if it's in the viewport and if not skip the pairing.
229 // It would currently cause layout thrash though so if we did that
· · ·
314 );
315 if (className !== 'none') {
316▶ // TODO: Ideally we could determine if this exit is in the viewport and
317 // exclude it otherwise but that would require waiting until we insert
318 // and layout the clones first. Currently wait until the view transition
· · ·
440 // $FlowFixMe[constant-condition]
441 if (supportsResources) {
442▶ // TODO: Hoistables should get optimistically inserted and then removed.
443 recursivelyInsertNew(
444 finishedWork,
· · ·
520 }
521 case HostPortal: {
522▶ // TODO: Consider what should happen to Portals. For now we exclude them.
523 break;
524 }
+ 18 more matches in this file
1101 switch (tag) {
1102 case DehydratedSuspenseComponent:
1103▶ // TODO: ideally we would show dehydrated Suspense immediately.
1104 // However, it has some special behavior (like disconnecting
1105 // an alternate and turning into real Suspense) which breaks DevTools.
· · ·
1278 }
1279
1280▶ // TODO: Consider using a WeakMap instead. The only thing where that doesn't work
1281 // is React Native Paper which tracks tags but that support is eventually going away
1282 // and can use the old findFiberByHostInstance strategy.
· · ·
1579 const instance = suspense.instance;
1580 const isSuspended =
1581▶ // TODO: Track if other SuspenseNode like SuspenseList rows are suspended.
1582 (instance.kind === FIBER_INSTANCE ||
1583 instance.kind === FILTERED_FIBER_INSTANCE) &&
· · ·
1606 function measureHostInstance(instance: HostInstance): null | Array<Rect> {
1607 // Feature detect measurement capabilities of this environment.
1608▶ // TODO: Consider making this capability injected by the ReactRenderer.
1609 if (typeof instance !== 'object' || instance === null) {
1610 return null;
· · ·
2126 const fiberInstance = suspenseNode.instance;
2127 if (fiberInstance.kind !== FIBER_INSTANCE) {
2128▶ // TODO: Resizes of filtered Suspense nodes are currently dropped.
2129 return;
2130 }
+ 28 more matches in this file
509 _ => {
510 builder.record_error(CompilerErrorDetail {
511▶ category: ErrorCategory::Todo,
512 reason: format!(
513 "(BuildHIR::lowerMemberExpression) Handle {:?} property",
· · ·
592 _ => {
593 builder.record_error(CompilerErrorDetail {
594▶ category: ErrorCategory::Todo,
595 reason: format!(
596 "(BuildHIR::lowerMemberExpression) Handle {:?} property",
· · ·
715 ) {
716 builder.record_error(CompilerErrorDetail {
717▶ category: ErrorCategory::Todo,
718 reason: "(BuildHIR::lowerExpression) Pipe operator not supported".to_string(),
719 description: None,
· · ·
758 builder.record_error(CompilerErrorDetail {
759 reason: "Unsupported delete target".to_string(),
760▶ category: ErrorCategory::Todo,
761 loc: loc.clone(),
762 description: None,
· · ·
802 builder.record_error(CompilerErrorDetail {
803 reason: "throw expressions are not supported".to_string(),
804▶ category: ErrorCategory::Todo,
805 loc: loc.clone(),
806 description: None,
+ 41 more matches in this file
411 renderLanes: Lanes,
412) {
413▶ // TODO: current can be non-null here even if the component
414 // hasn't yet mounted. This happens after the first render suspends.
415 // We'll need to figure out if this is fine or can cause issues.
· · ·
545 renderLanes: Lanes,
546): null | Fiber {
547▶ // TODO: current can be non-null here even if the component
548 // hasn't yet mounted. This happens when the inner render suspends.
549 // We'll need to figure out if this is fine or can cause issues.
· · ·
587 // rather, it wraps around an inner component, which may or may not
588 // contains hooks.
589▶ // TODO: Move the reset at in beginWork out of the common path so that
590 // this is no longer necessary.
591 workInProgress.lanes = current.lanes;
· · ·
691 ) {
692 // In legacy sync mode, don't defer the subtree. Render it now.
693▶ // TODO: Consider how Offscreen should work with transitions in the future
694 const nextState: OffscreenState = {
695 baseLanes: NoLanes,
· · ·
741 // there was a refresh.
742 const prevCachePool = prevState !== null ? prevState.cachePool : null;
743▶ // TODO: Consider if and how Offscreen pre-rendering should
744 // be attributed to the transition that spawned it
745 pushTransition(workInProgress, prevCachePool, null);
+ 20 more matches in this file
80 consumed: boolean;
81};
82▶// TODO: create a kind: "Alias"
83
84// type T<X> = { foo: X}
· · ·
132 *
133 *
134▶ * // (todo: disallowed)
135 *type X' = {
136 *value: number,
· · ·
247 }
248 case 'Enum': {
249▶ return 'TODO enum printing';
250 }
251 case 'Union': {
· · ·
323 );
324 }
325▶ return Resolved.todo(platform);
326 }
327 case 'Open':
· · ·
328 return Resolved.mixed(platform);
329 case 'Any':
330▶ return Resolved.todo(platform);
331 case 'Annot':
332 return convertFlowTypeImpl(
+ 5 more matches in this file
290
291function coerceRef(workInProgress: Fiber, element: ReactElement): void {
292▶ // TODO: This is a temporary, intermediate step. Now that enableRefAsProp is on,
293 // we should resolve the `ref` prop during the begin phase of the component
294 // it's attached to (HostComponent, ClassComponent, etc).
· · ·
295 const refProp = element.props.ref;
296▶ // TODO: With enableRefAsProp now rolled out, we shouldn't use the `ref` field. We
297 // should always read the ref from the prop.
298 workInProgress.ref = refProp !== undefined ? refProp : null;
· · ·
455 }
456
457▶ // TODO: For the shouldClone case, this could be micro-optimized a bit by
458 // assuming that after the first child we've already added everything.
459 let childToDelete = currentFirstChild;
· · ·
1221 );
1222 if (newFiber === null) {
1223▶ // TODO: This breaks on empty slots like null children. That's
1224 // unfortunate because it triggers the slow path all the time. We need
1225 // a better way to communicate whether this was a miss or null,
· · ·
1249 lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
1250 if (previousNewFiber === null) {
1251▶ // TODO: Move out of the loop. This only happens for the first run.
1252 resultingFirstChild = newFiber;
1253 } else {
+ 9 more matches in this file
108
109 for (const ref of fn.context) {
110▶ // TODO: using InstructionValue as a bit of a hack, but it's pragmatic
111 const value: InstructionValue = {
112 kind: 'ObjectExpression',
· · ·
529 * throw (effectively) the result of the call.
530 *
531▶ * TODO: call applyEffect() instead. This meant that the catch param wasn't inferred
532 * as a mutable value, though. See `try-catch-try-value-modified-in-catch-escaping.js`
533 * fixture as an example
· · ·
581 * a known-frozen value.
582 *
583▶ * TODO: make sure we're also validating against global mutations somewhere, but
584 * account for this being allowed in effects/event handlers.
585 */
· · ·
816 effect.function.loweredFunc.func.aliasingEffects?.some(
817 effect =>
818▶ // TODO; include "render" here?
819 effect.kind === 'MutateFrozen' ||
820 effect.kind === 'MutateGlobal' ||
· · ·
1604 /*
1605 * Returns a copy of this state.
1606▶ * TODO: consider using persistent data structures to make
1607 * clone cheaper.
1608 */
+ 6 more matches in this file
306 recordReactMeasureStarted('commit', lanes);
307
308▶ // TODO (timeline) Re-think this approach to "batching"; I don't think it works for Suspense or pre-rendering.
309 // This issue applies to the User Timing data also.
310 nextRenderShouldStartNewBatch = true;
· · ·
340 const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
341
342▶ // TODO (timeline) Record and cache component stack
343 currentReactComponentMeasure = {
344 componentName,
· · ·
385 const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
386
387▶ // TODO (timeline) Record and cache component stack
388 currentReactComponentMeasure = {
389 componentName,
· · ·
430 const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
431
432▶ // TODO (timeline) Record and cache component stack
433 currentReactComponentMeasure = {
434 componentName,
· · ·
475 const componentName = getDisplayNameForFiber(fiber) || 'Unknown';
476
477▶ // TODO (timeline) Record and cache component stack
478 currentReactComponentMeasure = {
479 componentName,
+ 6 more matches in this file
128 )
129 .replace(
130▶ 'const __TODO_NEXT_RN_MAJOR__ = false;',
131 'const __TODO_NEXT_RN_MAJOR__ = "next-todo";'
132 ),
· · ·
131▶ 'const __TODO_NEXT_RN_MAJOR__ = "next-todo";'
132 ),
133 {
· · ·
295 if (value === true || value === 'next') {
296 return '✅';
297▶ } else if (value === 'next-todo') {
298 return '📋';
299 } else if (value === false || value === null || value === 'experimental') {
· · ·
321 value === 'experimental' ||
322 value === 'next' ||
323▶ value === 'next-todo'
324 ) {
325 return '❌';
· · ·
595 ❌ Off
596 💻 DEV
597▶ 📋 TODO
598 📊 Profiling
599 🧪 Experiment
419 case REACT_ELEMENT_TYPE: {
420 if (temporaryReferences !== undefined && key.indexOf(':') === -1) {
421▶ // TODO: If the property name contains a colon, we don't dedupe. Escape instead.
422 const parentReference = writtenObjects.get(parent);
423 if (parentReference !== undefined) {
· · ·
570 }
571 } else if (key.indexOf(':') === -1) {
572▶ // TODO: If the property name contains a colon, we don't dedupe. Escape instead.
573 const parentReference = writtenObjects.get(parent);
574 if (parentReference !== undefined) {
· · ·
588 return value;
589 }
590▶ // TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
591 if (value instanceof FormData) {
592 if (formData === null) {
· · ·
685 return serializeTypedArray('V', value);
686 }
687▶ // TODO: Blob is not available in old Node/browsers. Remove the typeof check later.
688 if (typeof Blob === 'function' && value instanceof Blob) {
689 if (formData === null) {
· · ·
715 }
716
717▶ // TODO: ReadableStream is not available in old Node. Remove the typeof check later.
718 if (
719 typeof ReadableStream === 'function' &&
+ 7 more matches in this file
1581 // I suspect that there might be some efficiency benefits from not creating the suspended task
1582 // and instead just using the stack if possible.
1583▶ // TODO: Call this directly instead of messing with saving and restoring contexts.
1584
1585 // We can reuse the current context and task to render the content immediately without
· · ·
1712 );
1713 pushComponentStack(suspendedFallbackTask);
1714▶ // TODO: This should be queued at a separate lower priority queue so that we only work
1715 // on preparing fallbacks if we don't have any more main content to task on.
1716 request.pingedTasks.push(suspendedFallbackTask);
· · ·
1862
1863 pushComponentStack(suspendedFallbackTask);
1864▶ // TODO: This should be queued at a separate lower priority queue so that we only work
1865 // on preparing fallbacks if we don't have any more main content to task on.
1866 request.pingedTasks.push(suspendedFallbackTask);
· · ·
1917 postponedRow: null | SuspenseListRow,
1918): void {
1919▶ // TODO: Because we unconditionally call this, it will be called by finishedTask
1920 // and so ends up recursive which can lead to stack overflow for very long lists.
1921 if (postponedRow !== null) {
· · ·
2028 task.treeContext = pushTreeContext(prevTreeContext, totalChildren, i);
2029 const resumeSegmentID = resumeSlots[i];
2030▶ // TODO: If this errors we should still continue with the next sibling.
2031 if (typeof resumeSegmentID === 'number') {
2032 resumeNode(request, task, resumeSegmentID, node, i);
+ 19 more matches in this file
225 }
226
227▶ // TODO: If we move the `doesRequireClone` call after `bubbleProperties`
228 // then we only have to check the `completedWork.subtreeFlags`.
229 let child = completedWork.child;
· · ·
552// loop will resume rendering as if the work-in-progress completed. So it must
553// fully complete.
554▶// TODO: This should ideally move to begin phase, but currently the instance is
555// not created until the complete phase. For our existing use cases, host nodes
556// that suspend don't have children, so it doesn't matter. But that might not
· · ·
594 // preload the instance if necessary. Even if this is an urgent render there
595 // could be benefits to preloading early.
596▶ // @TODO we should probably do the preload in begin work
597 const isReady = preloadInstance(workInProgress.stateNode, type, newProps);
598 if (!isReady) {
· · ·
643 if (wakeables !== null) {
644 // Schedule an effect to attach a retry listener to the promise.
645▶ // TODO: Move to passive phase
646 workInProgress.flags |= Update;
647 }
· · ·
656 if (workInProgress.flags & ScheduleRetry) {
657 const retryLane =
658▶ // TODO: This check should probably be moved into claimNextRetryLane
659 // I also suspect that we need some further consolidation of offscreen
660 // and retry lanes.
+ 8 more matches in this file
337 }
338
339▶ static throwTodo(
340 options: Omit<CompilerErrorDetailOptions, 'category'>,
341 ): never {
· · ·
344 new CompilerErrorDetail({
345 ...options,
346▶ category: ErrorCategory.Todo,
347 }),
348 );
· · ·
600 break;
601 }
602▶ case ErrorCategory.Todo: {
603 heading = 'Todo';
604 break;
· · ·
603▶ heading = 'Todo';
604 break;
605 }
· · ·
689 Invariant = 'Invariant',
690 /**
691▶ * Todos
692 */
693 Todo = 'Todo',
+ 5 more matches in this file
346 // We could update instance props and state here,
347 // but instead we rely on them being set during last render.
348▶ // TODO: revisit this when we implement resuming.
349 if (__DEV__) {
350 if (
· · ·
416 // We could update instance props and state here,
417 // but instead we rely on them being set during last render.
418▶ // TODO: revisit this when we implement resuming.
419 if (__DEV__) {
420 if (
· · ·
496
497export function commitClassDidMount(finishedWork: Fiber) {
498▶ // TODO: Check for LayoutStatic flag
499 const instance = finishedWork.stateNode;
500 if (typeof instance.componentDidMount === 'function') {
· · ·
517
518export function commitClassCallbacks(finishedWork: Fiber) {
519▶ // TODO: I think this is now always non-null by the time it reaches the
520 // commit phase. Consider removing the type check.
521 const updateQueue: UpdateQueue<mixed> | null =
· · ·
553 // We could update instance props and state here,
554 // but instead we rely on them being set during last render.
555▶ // TODO: revisit this when we implement resuming.
556 try {
557 if (__DEV__) {
+ 3 more matches in this file
275// Where an update was scheduled only during the current render pass. This
276// gets reset after each attempt.
277▶// TODO: Maybe there's some way to consolidate this with
278// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.
279let didScheduleRenderPhaseUpdateDuringThisPass: boolean = false;
· · ·
537 // thenableState = null;
538
539▶ // TODO Warn if no hooks are used at all during mount, then some are used during update.
540 // Currently we will identify the update render as a mount because memoizedState === null.
541 // This is tricky because it's valid for certain types of components (e.g. React.lazy)
· · ·
908): void {
909 workInProgress.updateQueue = current.updateQueue;
910▶ // TODO: Don't need to reset the flags here, because they're reset in the
911 // complete phase (bubbleProperties).
912 if (__DEV__ && (workInProgress.mode & StrictEffectsMode) !== NoMode) {
· · ·
1110 // what the following logic accounts for.
1111 //
1112▶ // TODO: Theoretically this logic only needs to go into the rerender
1113 // dispatcher. Could optimize, but probably not be worth it.
1114
· · ·
1236 }
1237 } else if (data.length !== size) {
1238▶ // TODO: consider warning or throwing here
1239 if (__DEV__) {
1240 console.error(
+ 18 more matches in this file
147 if (child.tag === HostComponent) {
148 const instance: Instance = child.stateNode;
149▶ // TODO: calculate whether component is in viewport
150 shouldStartViewTransition = true;
151 applyViewTransitionName(
· · ·
315 // Ideally we could undo the old transition but it's now too late. It's also on its
316 // on snapshot. We have know was for it to paint onto the original group.
317▶ // TODO: This will lead to things unexpectedly having exit animations that normally
318 // wouldn't happen. Consider if we should just let this fly off the screen instead.
319 restoreViewTransitionOnHostInstances(child.child, false);
· · ·
348 );
349 if (!inViewport) {
350▶ // TODO: If this was part of a pair we will still run the onShare callback.
351 // Revert the transition names. This boundary is not in the viewport
352 // so we won't bother animating it.
· · ·
353 restoreViewTransitionOnHostInstances(placement.child, false);
354▶ // TODO: Should we still visit the children in case a named one was in the viewport?
355 } else {
356 commitAppearingPairViewTransitions(placement);
· · ·
473 // so we won't bother animating it.
474 restoreViewTransitionOnHostInstances(deletion.child, false);
475▶ // TODO: Should we still visit the children in case a named one was in the viewport?
476 } else if (pair !== undefined) {
477 // We found a new appearing view transition with the same name as this deletion.
+ 3 more matches in this file
703 hasHtml: false,
704
705▶ // @TODO add bootstrap script to implicit preloads
706
707 // persistent
· · ·
1166 // Because this is a side-effect in render, we should ideally call pushViewTransitionAttributes
1167 // after we've suspended (like forms do), so that we don't increment each attempt.
1168▶ // TODO: Make this deterministic.
1169 viewTransition.nameIdx++;
1170 }
· · ·
1228 styleValue === ''
1229 ) {
1230▶ // TODO: We used to set empty string as a style with an empty value. Does that ever make sense?
1231 continue;
1232 }
· · ·
1313
1314function makeFormFieldPrefix(resumableState: ResumableState): string {
1315▶ // TODO: Make this deterministic.
1316 const id = resumableState.nextFormID++;
1317 return resumableState.idPrefix + id;
· · ·
1391 // work there.
1392 if (__DEV__) {
1393▶ // TODO: Should this be some kind of recoverable error?
1394 console.error(
1395 'Failed to serialize an action for progressive enhancement:\n%s',
+ 17 more matches in this file
12import type {ConcurrentUpdate} from './ReactFiberConcurrentUpdates';
13
14▶// TODO: Ideally these types would be opaque but that doesn't work well with
15// our reconciler fork infra, since these leak into non-reconciler packages.
16
· · ·
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
306 // removing until we've thought about this again.
· · ·
328 if (nextLanes === NoLanes) {
329 // This should only be reachable if we're suspended
330▶ // TODO: Consider warning in this path if a fallback timer is not scheduled.
331 return NoLanes;
332 }
· · ·
449 // lanes in the same batch, but it's not worth throwing out partially
450 // completed work in order to do it.
451▶ // TODO: Reconsider this. The counter-argument is that the partial work
452 // represents an intermediate state, which we don't want to show to the user.
453 // And by spending extra time finishing it, we're increasing the amount of
· · ·
514 case RetryLane3:
515 case RetryLane4:
516▶ // TODO: Retries should be allowed to expire if they are CPU bound for
517 // too long, but when I made this change it caused a spike in browser
518 // crashes. There must be some other underlying bug; not super urgent but
+ 9 more matches in this file