Commits on Aug 26, 2020

1. Remove distinction between long, short transitions …

   We're removing the `timeoutMs` option, so there's no longer any
   distinction between "short" and "long" transitions. They're all treated
   the same.
   
   This commit doesn't remove `timeoutMs` yet, only combines the internal
   priority levels.

   

   acdlite committed Aug 26, 2020
   Copy the full SHA

   350196b View commit details

   Browse the repository at this point in the history

2. Disable timeoutMs argument …

   tl;dr
   -----
   
   - We're removing the `timeoutMs` argument from `useTransition`.
   - Transitions will either immediately switch to a skeleton/placeholder
     view (when loading new content) or wait indefinitely until the data
     resolves (when refreshing stale content).
   - This commit disables the `timeoutMS` so that the API has the desired
     semantics. It doesn't yet update the types or migrate all the test
     callers. I'll do those steps in follow-up PRs.
   
   Motivation
   ----------
   
   Currently, transitions initiated by `startTransition` / `useTransition`
   accept a `timeoutMs` option. You can use this to control the maximum
   amount of time that a transition is allowed to delay before we give up
   and show a placeholder.
   
   What we've discovered is that, in practice, every transition falls into
   one of two categories: a **load** or a **refresh**:
   
   - **Loading a new screen**: show the next screen as soon as possible,
     even if the data hasn't finished loading. Use a skeleton/placeholder
     UI to show progress.
   - **Refreshing a screen that's already visible**: keep showing the
     current screen indefinitely, for as long as it takes to load the fresh
     data, even if the current data is stale. Use a pending state (and
     maybe a busy indicator) to show progress.
   
   In other words, transitions should either *delay indefinitely* (for a
   refresh) or they should show a placeholder *instantly* (for a load).
   There's not much use for transitions that are delayed for a
   small-but-noticeable amount of time.
   
   So, the plan is to remove the `timeoutMs` option. Instead, we'll assign
   an effective timeout of `0` for loads, and `Infinity` for refreshes.
   
   The mechanism for distinguishing a load from a refresh already exists in
   the current model. If a component suspends, and the nearest Suspense
   boundary hasn't already mounted, we treat that as a load, because
   there's nothing on the screen. However, if the nearest boundary is
   mounted, we treat that as a refresh, since it's already showing content.
   
   If you need to fix a transition to be treated as a load instead of a
   refresh, or vice versa, the solution will involve rearranging the
   location of your Suspense boundaries. It may also involve adding a key.
   
   We're still working on proper documentation for these patterns. In the
   meantime, please reach out to us if you run into problems that you're
   unsure how to fix.
   
   We will remove `timeoutMs` from `useDeferredValue`, too, and apply the
   same load versus refresh semantics to the update that spawns the
   deferred value.
   
   Note that there are other types of delays that are not related to
   transitions; for example, we will still throttle the appearance of
   nested placeholders (we refer to this as the placeholder "train model"),
   and we may still apply a Just Noticeable Difference heuristic (JND) in
   some cases. These aren't going anywhere. (Well, the JND heuristic might
   but for different reasons than those discussed above.)

   

   acdlite committed Aug 26, 2020
   Copy the full SHA

   93ca66a View commit details

   Browse the repository at this point in the history