Repository navigation
v0.257.0
·
4439 commits
to main
since this release
Likely to cause new Flow errors:
- We have improved inference for exported primitive literal values.
- Before this change the inferred type for
export const obj = {f: "foo"};was{f: str<"foo">}, wherestr<"foo">was a type that opportunistically and unsoundly behaved either asstringor as the singleton type"foo". - Flow will now infer the type
{f: string}forobj. - For const like exports, e.g.
export const x = "foo";Flow will export the type"foo". - To fix errors that arise due to this change, you can provide annotations around exported literals or use the
as constmodifier.
- Before this change the inferred type for
- We fixed a major unsoundness with regards to dictionary object creation. Previously, the computed property will just be ignored for
stringoranykeys. Now, if the computed property is added to some existing objects (e.g.{foo: string, [stringTypedKey]: v}), then we will error on the property. Otherwise, the{[key]: value}will be{[typeof key}: typeof value} - We fixed a bug that causes opaque type's underlying representation to leak beyond the file it's defined. You might see more errors as a result.
- Flow will now perform a complete function call check even when
[react-rule-unsafe-mutation]errors are raised. - Previously we incorrectly distribute-over-union for maybe or optional input types of conditional type. (e.g.
(?string) extends string ? true : falseis evaluated totrue | falseinstead offalse). This is now fixed, and code that depends on the bug might have new errors. - If you have refiend a value based on
typeof x === 'function', and then dotypeof x === 'object', the result is nowemptyas that is impossible. - Singleton types are now also considered in conditional equality checks on member expressions. (e.g. try-Flow)
React.Configtype, deprecated in v0.254, is now removed.
New Features:
'key' in xnow refines the type ofxto objects which have the propertykey.inchecks for both own and non-own properties.- If we find that a key does not exist in an inexact object or instance/interface, then the negation is not refined since the property may or may not exist.
- An optional property is also considered as if it may or may not exist.
- If a proto/super is a union, every member of the union must have it
- If the input to the refinement is an intersection, one member of that intersection must have it
- We don't refine arrays since it's not useful (check for
.lengthinstead), and also because Flow doesn't handle array holes.
- Flow now supports
no_unchecked_indexed_access=truein flowconfig, which is equivalent to noUncheckedIndexedAccess from TS. It will add| voidto every indexed access with general string key on dictionary objects or number key on arrays. - Support for React 19's ref-as-prop model is now available via
react.ref_as_prop=partial_support, and this is now the default. (To disable it, usereact.ref_as_prop=disabled.) Under this mode, ref prop in jsx will be treated as a regular prop for function components, but utility types likeReact.ElementConfig<...>still won't include the regular ref prop yet. - Flow now allows using union of strings as the type of computed property keys.
- You can now destructure object properties using number literal keys (which are int-like).
Notable bug fixes:
- Refining type guards with opaque types will now refine the general type (example of code that used to fail before, but now passes: try-Flow)
- Allow more flexibility in checks involving super type of opaque type (e.g. try-Flow)
- Fixed a bug when using opaque types in type guards in files other than the one where the type guard function was defined.
- We now allow a union of generic or opaque string typed values to be used as a key of computed property, if it's bounded by a string type.
Library Definitions:
- Add libdef types for
getNotificationsandshowNotificationAPI forServiceWorkerRegistration