[Fizz]: Unify preload queue #27190
Merged
[Fizz]: Unify preload queue #27190
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
facebook-github-bot
added
CLA Signed
React Core Team
gnoff
force-pushed
the
unify-preload-queue
branch
from
10f8295 to
29f352c
Compare
gnoff
force-pushed
the
unify-preload-queue
branch
from
29f352c to
c8add69
Compare
sebmarkbage
approved these changes
Aug 7, 2023
|
I'm saying that absent another singal, like the fact that a resource was actually rendered, we should treat all preloads as the same priority from a flushing order standpoint because it allows the user to decide which assets to prioritize over others using fetchPriority. If we create a flushing hierarchy this can still be done but the browser (or responding server) may already be busy handling lower priority requests when something high priority comes in. So by making there be a single queue we influence the implicit priority of "arbitrary" preloads less. There are exceptions like fonts which we will never "render" but must be treated as being very high priority so those still have their own queue. Does that help clarify or is it still not clear? |
…int is to allow a sort of prioritization by the user via fetchPriority and order of preload calls and by making them use different queues we limit how much control you can have it ordering preloads
gnoff
force-pushed
the
unify-preload-queue
branch
from
c8add69 to
2e5e20e
Compare
github-actions bot
pushed a commit
that referenced
this pull request
Aug 7, 2023
Currently React attempts to prioritize certain preloads over others based on their type. This is at odds with allowing the user to control priority by ordering which calls are made first. There are some asset types that generally should just be prioritized first such as fonts since we don't know when fonts will be used and they either block display or may lead to fallback fonts being used. But for scripts and stylesheets we can emit them in the order received with other arbitrary preload types. We will eventually add support for emitting suspensey image preloads before other resources because these also block display however that implementation will look at which images are actually rendered rather than simply preloaded. DiffTrain build for [cb3404a](cb3404a)
kodiakhq bot
pushed a commit
to vercel/next.js
that referenced
this pull request
Aug 8, 2023
Updated React from 9377e1010 to cb3404a0c. ### React upstream changes - facebook/react#27190 - facebook/react#27189 - facebook/react#27201 - facebook/react#27147 - facebook/react#26949 - facebook/react#27058 - facebook/react#27142 - facebook/react#27133 - facebook/react#27130 - facebook/react#27105 - facebook/react#27117 - facebook/react#27057
EdisonVan
pushed a commit
to EdisonVan/react
that referenced
this pull request
Apr 15, 2024
Currently React attempts to prioritize certain preloads over others based on their type. This is at odds with allowing the user to control priority by ordering which calls are made first. There are some asset types that generally should just be prioritized first such as fonts since we don't know when fonts will be used and they either block display or may lead to fallback fonts being used. But for scripts and stylesheets we can emit them in the order received with other arbitrary preload types. We will eventually add support for emitting suspensey image preloads before other resources because these also block display however that implementation will look at which images are actually rendered rather than simply preloaded.
bigfootjon
pushed a commit
that referenced
this pull request
Apr 18, 2024
Currently React attempts to prioritize certain preloads over others based on their type. This is at odds with allowing the user to control priority by ordering which calls are made first. There are some asset types that generally should just be prioritized first such as fonts since we don't know when fonts will be used and they either block display or may lead to fallback fonts being used. But for scripts and stylesheets we can emit them in the order received with other arbitrary preload types. We will eventually add support for emitting suspensey image preloads before other resources because these also block display however that implementation will look at which images are actually rendered rather than simply preloaded. DiffTrain build for commit cb3404a.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
stacked on #27189
Currently React attempts to prioritize certain preloads over others based on their type. This is at odds with allowing the user to control priority by ordering which calls are made first. There are some asset types that generally should just be prioritized first such as fonts since we don't know when fonts will be used and they either block display or may lead to fallback fonts being used. But for scripts and stylesheets we can emit them in the order received with other arbitrary preload types.
We will eventually add support for emitting suspensey image preloads before other resources because these also block display however that implementation will look at which images are actually rendered rather than simply preloaded.