prettierx: Update flow-parser -> 0.258.0 - devDependency

[renovate]

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
flow-parser (source)	0.155.0 -> 0.258.0

---

Release Notes

facebook/flow (flow-parser)

v0.258.0

Compare Source

Likely to cause new Flow errors:

• method-unbinding errors will not affect choice over intersection members. (e.g. try-Flow)
• We now disallow coercions between functions and class statics.
• The ability to configure react.ref_as_prop=disabled is removed.
• Use of React$Node and React$MixedElement outside of libdefs will now trigger internal-type errors.

Library Definitions:

• Improved definition of Array.concat().

v0.257.1

Compare Source

Misc:

• Flow language server will stop advertising that we can handle all code actions kinds prefixed with "source". It can help to prevent VSCode sending flow irrelevant code actions to handle during save.

v0.257.0

Compare Source

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">}, where str<"foo"> was a type that opportunistically and unsoundly behaved either as string or as the singleton type "foo".
  • Flow will now infer the type {f: string} for obj.
  • 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 const modifier.
• We fixed a major unsoundness with regards to dictionary object creation. Previously, the computed property will just be ignored for string or any keys. 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 : false is evaluated to true | false instead of false). 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 do typeof x === 'object', the result is now empty as that is impossible.
• Singleton types are now also considered in conditional equality checks on member expressions. (e.g. try-Flow)
• React.Config type, deprecated in v0.254, is now removed.

New Features:

• 'key' in x now refines the type of x to objects which have the property key.
  • in checks 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 .length instead), and also because Flow doesn't handle array holes.
• Flow now supports no_unchecked_indexed_access=true in flowconfig, which is equivalent to noUncheckedIndexedAccess from TS. It will add | void to 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, use react.ref_as_prop=disabled.) Under this mode, ref prop in jsx will be treated as a regular prop for function components, but utility types like React.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 getNotifications and showNotification API for ServiceWorkerRegistration

v0.256.0

Compare Source

Notable bug fixes:

• Fixed a limitation when checking intersections of polymorphic types (e.g. tryFlow)
• Fixed an internal error raised when using super in an object method. Such cases are now user-facing errors.

v0.255.0

Compare Source

Likely to cause new Flow errors:

• Referencing a react-component typed value in type position will now create a React$RendersExactly<typeof Component> type instead of React$Element<typeof Component> type. All existing usages intended to create an exact react element will now error as a result. Using it as type passed to render type, React.PropsOf, React.PropOf and React.RefOf is unaffected and will not be affected in the future. If you want exact react elements, the only way that doesn't trigger Flow error is by ExactReactElement_DEPRECATED<typeof Component>.

Library Definitions:

• React.Config type is marked as deprecated and will be removed soon. You can create your own equivalent type with

type ReactConfigShim<Props, DefaultProps> = $ReadOnly<{
  ...Omit<Props, $Keys<DefaultProps>>, ...Partial<DefaultProps>
}>;

v0.254.2

Compare Source

Misc:

• Add option to disable experimental configuration

v0.254.1

Compare Source

Notable bug fixes:

• Fixed a potential crash when experimental multiplatform support is enabled.

v0.254.0

Compare Source

Likely to cause new Flow errors:

• Previously we incorrectly applied truthy refinement on optional chaining where it shouldn't be applied. The issue is now fixed, and you might see change in behavior similar to these examples

Library Definitions:

• Improve Array toSpliced method type (thanks @​aph!)

v0.253.0

Compare Source

Likely to cause new Flow errors:

• React$ElementRef is now implemented with a conditional type instead of a builtin Flow utility type. You might see new errors with generic React$ElementRef. Most of the times, you should replace React.ElementRef<T> with just T if there are no other uses of generic T.
• We've increased safety in checks involving recursive types.

New Features:

• You can now set multiple @flowtyped like directories via module.declaration_dirnames config. e.g.

module.declaration_dirnames=<PROJECT_ROOT>/decl1
module.declaration_dirnames=<PROJECT_ROOT>/decl2

Please note that when you set this, @flowtyped at the root will no longer be considered special, and you will need to explicitly add it like

module.declaration_dirnames=<PROJECT_ROOT>/@&#8203;flowtyped

Notable bug fixes:

• A generic type as input to conditional type will have type parameters pinned with their default or upper bound, instead of being empty.
• We fixed a cache collision issue that might cause instantiation of a value-imported generic component type to interfere with a typeof-imported generic component type.

IDE:

• Flow now respects includeDeclaration from LSP request for find-references command. In practice, this means that "find all references" in vscode will continue to return both declaration and all uses, while "go to references" will exclude the declaration.

v0.252.0

Compare Source

Likely to cause new Flow errors:

• Flow will no longer apply type transformation to function components' props when you extract props through the utility types. For example, function components' props won't automatically get $ReadOnly applied, which might cause new errors.

New Features:

• We have removed the restriction of not allowing generics with ref prop in component syntax

Notable bug fixes:

• Files in [declarations] section will have all lint errors silenced.
• Fixed an issue that caused errors in hover type on unions of evaluated types (example)
• Flow allows unions of strings to be used as the key in creation of objects with computed properties.

v0.251.1

Compare Source

Misc:

• Performance fix

v0.251.0

Compare Source

Likely to cause new Flow errors:

• Remove the deprecated React.AbstractComponent type. We recommend replacing them with component types. Since v0.249.0, we have provided a codemod via the flow-upgrade package to aid larger codebases with this conversion: yarn run flow-codemod eliminateAbstractComponent path/to/src.
• In addition to the removal of React.AbstractComponent type, we also removed support for the internal React$AbstractComponent when more than 1 type argument has been passed. Similarly, you should migrate to use component types if you want to specify ref props and renders.

New Features:

• We now support a new way to easily specify library definitions for npm modules. For all files in @flowtyped directory at the root, they can be resolved by the relative path without leading ./ relative to @flowtyped. e.g. <PROJECT_ROOT>/@&#8203;flowtyped/react.js.flow can be used to type the react package, and <PROJECT_ROOT>/@&#8203;flowtyped/react/jsx-runtime.js.flow can be used to type react/jsx-runtime module. We now recommend using this approach instead of using declare module in global libdef.

Notable bug fixes:

• any will now correctly propagate to inferred render type. example.
• Fixed a bug with regard to jsx type inference with generic callable objects. example
• Fixed a soundness hole that allowed frozen objects to be incompatible with non-readonly objects. This example will now produce an error.

Library Definitions:

• We have updated some core React type definitions to use the new component type instead of React.AbstractComponent. Most of the code won't be affected, but you might have to sometimes make the Props readonly.

v0.250.0

Compare Source

Likely to cause new Flow errors:

• Fix a bug where scope analysis of exported component type is done incorrectly, which causes generics mentioned within component type to be incorrectly typed as any.

Notable bug fixes:

• We will now remove previous props in generic component types in type argument inference. example
• When all option is specified in the config of flow-remove-types, we now respect it and will correctly handle Flow-typed files without @flow pragma.

v0.249.0

Compare Source

Likely to cause new Flow errors:

• Uses of React$AbstractComponent outside library definitions will now trigger internal-type lint error, which is on by default. React.AbstractComponent is also marked as deprecated. We recommend replacing them with component types. We have provided a codemod via the flow-upgrade package to aid larger codebases with this conversion: yarn run flow-codemod eliminateAbstractComponent path/to/src.

Notable bug fixes:

• Fixed issue with StringPrefix and StringSuffix when used as a component syntax prop.
• Fixed an issue that causes type argument inference on component type to be incorrectly under-constrained. (example)
• Fixed as cast support in flow-remove-types.

Library Definitions:

• React string refs are no longer supported in React.cloneElement. e.g. React.cloneElement(e, {ref: 'foo'}) will be an error.
• The deprecated React$Ref type and various aliases of it are removed.

v0.248.1

Compare Source

IDE:

• React.Component annotated exported will now also show up in auto-imports in a type position.

v0.248.0

Compare Source

Breaking changes:

• Support for long deprecated predicate function (%checks) is removed. It will still parse, but all of them will error with unsupported-syntax, and %checks will be completely ignored for type checking purpose as if it doesn't exist.
• $TupleMap support is now removed. $TupleMap will now resolve to the global definition is there is one, or it will fail and the type becomes any.

Likely to cause new Flow errors:

• Support for the unsound $TEMPORARY$* types is dropped. If your codebase happens to have any of these types, you can replace them with there sound and well-documented equivalents:
  • Replace $TEMPORARY$object<{props}> with $ReadOnly<{props}> or {props}
  • Replace $TEMPORARY$array<T> with $ReadOnlyArray<T> or Array<T>
  • Replace $TEMPORARY$number<42> with number or '42'
  • Replace $TEMPORARY$string<"foo"> with string or "foo"
  • We have provided a flow-runner codemod via the flow-upgrade package to aid larger codebases with this conversion: yarn run flow-codemod replaceTemporaryTypes path/to/src.
• The inferred type for Object.freeze({ A: 'a', B: 'b' }) is now {+A:'a',+B:'b'} both locally within a file and when the object is being exported. This replaces an earlier unsound behavior where the type of A would opportunistically behaved either as string or 'a' depending on the context where it appeared.
• React string refs are now banned.
• contextTypes and childContextTypes in react class components are now empty typed, so declaring legacy context in React will be an error.
• Component syntax component and component types' ref prop now must have React.RefSetter<...> type.

Parser:

• Component type in parentheses can now be correctly parsed. e.g. type Foo = (component(x: number) renders Bar);
• Trailing comma is now allowed after rest parameter in component syntax components and component types.
• The v regex flag is now supported.

IDE:

• We now provide a code action to stub out a react component, at the location of an unbound JSX identifier.
• Component declaration/type without renders clause will no longer show renders React.Node on hover.
• Hovering on components will now consistently show its props and renders information. Previously, the information is omitted for component declarations.
• If we see : renders <annot> at the position that expects a render declaration, the quickfix will suggest removing : instead of replacing : with renders.

Library Definitions:

• Added type for util.stripVTControlCharacters for NodeJS.

v0.247.1

Compare Source

Misc:

• Performance optimization for unions

v0.247.0

Compare Source

Breaking changes:

• Support for the deprecated $Call type is removed. $Call will now resolve to whatever $Call points to in the global libdef. If you need more time to migrate, you can create a shim like $Call<F, T> = $TupleMap<[T], F>[0], but please note that we intend to remove support for $TupleMap eventually.
• deprecated-type-dollar-call lint is removed, since the support for $Call is removed.
• react.disable_function_components_default_props config option is removed. It is on by default since v0.238.

Likely to cause new Flow errors:

• $TupleMap is deprecated and will be soon removed, now that mapped type works on array inputs. Existing $TupleMap will still work in this release, but every use will trigger a deprecated-type lint that is on by default.
• Flow now performs literal subtyping checks for strict equality conditions in non-refinement contexts. example
• Fixed destructuring with invalid literal defaults. The following now errors properly: example
• Using string ref on components that are definitely not a class component is now an error. example
• React utility types will no longer incorrectly accept hook types when they expect component types. e.g. type A = React$ElementConfig<hook (props: {foo: string}) => void>; will now error.

New Features:

• Refinements against negated bigint literals should now work.

Notable bug fixes:

• Mapped type on generic arrays is now supported. Previously it will fail with array is not an object error.
• flow-remove-types now correctly handles as cast with generics.

IDE:

• On hover, values that have React.AbstractComponent type will be shown in the component type syntax
• Flow now offers a code action to insert inferred render type when you hover on the name of the component.
• Flow now provides keyword completion for component type, hook types and render types.

Library Definitions:

• Overly restrictive typing of queueMicrotask is now fixed.

v0.246.0

Compare Source

Likely to cause new Flow errors:

• Support for $ObjMap has been completely removed. This change means that:
  • $ObjMap will resolve to a user-defined $ObjMap global if it's available in your libdef. You can use type $ObjMap<O, F> = {[K in keyof O]: $Call<F, O[K]>} to get most of the same behavior, except that in the mapped type version O[K] will include void for optional props. Please note that this should be considered as a permanent shim, because we intend to eventually remove $Call.
  • flow codemod key-mirror command was removed, since this codemod tries to convert $ObjMap to $KeyMirror
  • deprecated-type-objmap lint was removed.
• Component syntax components without ref prop will have void as the instance, so React.ElementRef<component> of such component will return void.

New Features:

• Mapped types now support array and tuple types in the form of {[K in keyof <array or tuple type>: <mapped type>}.
  • With this support, we intend to deprecate $TupleMap in the next release and remove the support for $TupleMap eventually
• You can now refine against variables and member expressions with a literal type, not just literal themselves.

Notable bug fixes:

• Flow now only reports one error when two disjoint large enum-like unions are compared (example).

IDE:

• Code actions on component syntax components will produce smaller targeted edits, rather than reprint the entire component.
• Deprecated utility type like $Call are no longer suggested in autocomplete.
• Flow will now provide a quick fix when the spread prop of a component with component syntax redefines some already defined props.

Library Definitions:

• React.Ref is marked as deprecated. Use React.RefSetter instead for ref props, and React.RefObject for returns of useRef.
• React.RefSetter now includes null and void.
• Promise.all and Promise.allSettled have been updated to use mapped type instead of $TupleMap. The requirement on the type arguments are slightly changed.

v0.245.2

Compare Source

Misc:

• The language for invalidated refinement is slightly tweaked. Instead of saying refactoring to a constant, we now say refactoring to a const variable.

v0.245.1

Compare Source

Website:

• Refined expressions are now highlighted in try-flow playground. Hovering on refined expressions will show where it's refined, and hovering on some invalidated property refinements will show the location and reason of the invalidation.

IDE:

• Flow now responds to textDocument/prepareName LSP request. This ensures that Flow's rename support can be surfaced when multiple VSCode extension adds rename support for JS files.

v0.245.0

Compare Source

Likely to cause new Flow errors:

• React.Element type, deprecated in 0.243.0, is now removed.
• Fixed a bug where refinements are incorrectly not invalidated. example
• Under custom jsx pragma, children is no longer incorrectly added to props. Some spurious errors will be gone. example

New Features:

• Added LSP signature help support for JSX attributes. The feature is triggered with the opening { of a JSX attribute value.
• Flow now allows to configure the typing of jsx creation under the new option react.custom_jsx_typing=true. Under this flag, Flow will type check jsx by through your self-defined global type React$CustomJSXFactory type, which should be a function type that accepts arguments according to jsx spec. e.g. You can write a loose one like type React$CustomJSXFactory = (component: any, props: any, ...children: any) => React.MixedElement

Notable bug fixes:

• Fixed jsdoc attachment to signature help results for overloaded functions. (example)
• Signature help on overloaded functions will show information in the correct order of signatures
• Labels of autocomplete on members will indicate if the property is optional with a "?"
• Fixed a bug where a type-only namespace within a namespace is accidentally dropped. This bug used to make globalThis.React.Node being incorrectly unavailable.
• Fixed poor interaction of "Add missing attributes" quickfix when Linked Editing Range is enabled.
• Clicking on related symbol location on hover will jump to the right location in VSCode. Previously it incorrectly jumped to the position 1 character left of the right location.

IDE:

• Elements of component syntax components (e.g. typeof <A /> where A is in component syntax) will no longer be shown in hover with shorthand syntax like A. Instead, it will be shown as React$Element<typeof A>

v0.244.0

Compare Source

Likely to cause new Flow errors:

• The inexact_tuple_types_syntax option (which was on by default) is now deleted. Make sure you are using hermes-parser and related packages at version >= 0.23.0
• Render types will no longer allow specific renders wrapping more general renders like renders React.Element<React.AbstractComponent<{}, mixed, renders* A>>. Invalid render types will behave like any.
• Some previously allowed generic render types are no longer allowed (example). This ensures that generic render types are only used to model transparent components like React.Fragment.
• renders* T where T is generic is now banned.

Notable bug fixes:

• Render type with union type arguments will be correctly wrapped with parentheses.

v0.243.0

Compare Source

Likely to cause new Flow errors:

• All deprecated-type and untyped-type-import lint are on and at error level by default.
• Use of some internal types of Flow that have other identical public-facing variants (e.g. React$ElementConfig vs React.ElementConfig) are now a lint error that's enabled by default. To disable it, set internal-type=off in the lints section of the flowconfig. For now, these types are still allowed in libdef files, but we plan to also disallow it in the future. To codemod existing code, get the latest flow-upgrade package and run yarn run flow-codemod replaceReactDollarUtilityTypes
• Direct use of React$Element type is banned via the internal-type lint. The React.Element alias still exists for now, but it is marked with @deprecated in the jsdoc. Please read the jsdoc for better alternatives. A global alias ExactReactElement_DEPRECATED is added to help you clearly mark the use of exact React element types, and you should use it to replace React.Element that you cannot replace without compromising runtime type safety.
• Flow now consistently errors on bad comparison with enums example

New Features:

• Allow generic bound by inexact tuple as function rest args. This example now works.
• Support for declare component statement and component type is enabled by default.
• Flow now provide the "insert inferred type as type cast" code action. You only need to select the expression in the editor to trigger the code action.

Notable bug fixes:

• Fixed a bug that causes an internal error. example

Misc:

• experimental.namespaces config option is removed. Namespaces support is enabled by default in the previous release.

Library Definitions:

• Add .replaceChildren method type definition for dom nodes.
• Object.getPrototypeof is still special cased, but the special-casing is only available for a syntactic Object.getPrototypeof(...) call. If you try to use Object.getPrototypeof in some other ways (e.g. const f = Object.getPrototypeof; f(...)), you will get a a less precise and accurate typing for it. The Object$GetPrototypeOf type, which was used to back the special case behavior, is removed.

v0.242.1

Compare Source

New Features:

• For Pick utility type with string literals in the second type argument, go-to-definition on the string literal will jump to corresponding prop's location

Notable bug fixes:

• Re-exported types will show in autoimports from files without any import statement.

v0.242.0

Compare Source

Likely to cause new Flow errors:

• Support for special function type $Flow$DebugPrint was removed. To see the internal representation of type, use the flow type-at-pos command with flag --debug-print-internal-repr. Note that this is for debugging purpose only, and you should never depend on the output of --debug-print-internal-repr
• More invalid compare errors will be consistently caught when using == and !=.
• invalid-render errors can no longer be suppressed without specific error code.
• Flow can now detect more bad cyclic types, including across module boundaries. example
• You may see some errors moved around when $Exact<...> is involved. Some invalid $Exact<...> type will now have not-an-object error code.
• Fixed a bug that makes some exported types accidentally any. Previously hidden errors might be exposed.

New Features:

• declare namespace support is enabled by default.
• Added "Add Missing Attributes" quickfix for JSX. This is available when the cursor is over the name of a JSX element that is missing a required attribute.
• Added a StringSuffix type, which goes along with the recently added StringPrefix type. StringSuffix can be used to type strings with a specified suffix. E.g. StringSuffix<'!'> allows for 'yay!' and 'woo!'. The type argument for the suffix must be a string literal. The second, optional, type argument can be used for the type of the remainder of the string after the suffix is removed.

Notable bug fixes:

• Fix a bug that caused Flow to infer incorrect render types for elements of polymorphic components under niche circumstances

IDE:

• Flow now supports symlinked node_modules in autoimports better. If allowed by the node resolution algorithm, autoimport will insert import specifier like my-package or my-package/foo instead of a relative path import.

Library Definitions:

• CredMgmtCredentialRequestOptions properties are now optional
• Reflect.setPrototypeof are no longer special-cased, and the backing special type Object$SetPrototypeOf is removed. The new typing is intentionally loose. Similar to Object.setPrototypeof, this is inherently unsafe since Flow won't track prototype mutations.
• Object.assign is still special cased, but the special-casing is only available for a syntactic Object.assign(...) call. If you try to use Object.assign in some other ways (e.g. const f = Object.assign; f(...)), you will get a a less precise and accurate typing for it. If you don't like the default fallback type, you can override the Object$Assign type. While the special-casing behavior will stay for the syntactic call, you should migrate your code to use the spread syntax instead.

v0.241.0

Compare Source

No changes from 0.240.0

v0.240.0

Compare Source

Likely to cause new Flow errors:

• We fixed a bug that causes Flow to incorrectly believe that the LHS of logical operators are not nullable. example
• Flow can now detect more kinds of bad cyclic types. (example)
• Flow will now consistently catch some invalid comparison of the kind obj.type === 'foo'. example
• Fixed a bug in the type guard refinement that involves sentinel properties (e.g. try-Flow)
• Function.prototype.apply and Function.prototype.call are now typed using userland types instead of hardcoded builtin support. You might see slight inference differences, error message and code changing as a result.
• Flow now enforces that only function types are assigned to the .constructor property of object types. (D585385 pvekris)
• Fix subtyping checks of unions of bigint types against other unions of bigints.
• Make array holes be typed as void, not empty.

New Features:

• You can now pass in an (optional) second type argument to the StringPrefix utility type. This is the type of the remainder of the string after the prefix is removed. For example, "$1", "$2" are subtypes of StringPrefix<'$', '1' | '2'>, but "$999" is not. StringPrefix<X> is equivalent to StringPrefix<X, string>
• You can use the $Values utility type to get the type of the elements of an array type or tuple type.
• You can now do sentinel refinements on tuples, like you can already do for objects. This is especially useful for function arguments (you can type the ...args as a union of tuples). [example]
• Sentinel refinements now work when using number keys on objects [example]
• Flow now keep original type after invalid object prop-exists refinement on write-only property.

Notable bug fixes:

• Some operations can now be performed on an opaque type with appropriate bounds. example
• Fixed a bug that occurs when you have a tuple type spread after two or more non-spread arguments. Those will now be resolved in the correct order.

Library Definitions:

• String.codePointAt now returns number | void

v0.239.1

Compare Source

Notable bug fixes:

• Fixed a bug where IDE services doesn't respect files.implicitly_include_root=false config.

v0.239.0

Compare Source

Likely to cause new Flow errors:

• We now detect errors when props of React components using component syntax, or hook argument/return values of React hooks using hook syntax, contain arrays, sets, or maps that are mutated using their methods (Array.push, Set.add, Map.set, etc). These values are expected to be read-only, a

---

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.