prettierx: Update flow-parser -> 0.306.1 - devDependency

[renovate]

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Age	Confidence
flow-parser (source)	0.155.0 → 0.306.1

---

Release Notes

facebook/flow (flow-parser)

v0.306.1

Compare Source

• Fix in Meta-internal saved state logic

v0.306.0

Compare Source

New Features:

• Support for using well-known symbols as property names in types - the form should be exactly Symbol.iterator.

Notable bug fixes:

• Report prop-missing errors for unbound module properties in explicit type args used with implicit instantiation (e.g. try-Flow)

Library Definitions:

• Updated core.js library definitions to accept readonly tuples in Map constructor

v0.305.1

Compare Source

• Fix in saved state on projects including files outside the project root.

v0.305.0

Compare Source

Misc:

• Add autofix for colon-style type parameter bounds to extends-style type parameter bounds

v0.304.0

Compare Source

Notable bug fixes:

• Fixed analysis of number literal keys in object destructuring rest type computation

v0.303.0

Compare Source

New Features:

• Adds a new stylex_shorthand_prop flowconfig option that enables syntactic sugar for StyleX on lowercase (intrinsic) JSX elements. When set to a prop name (e.g. stylex_shorthand_prop=sx), <div sx={[styles.foo, styles.bar]} /> desugars to <div {...stylex.props(styles.foo, styles.bar)} />.

v0.302.0

Compare Source

Notable bug fixes:

• Fix #​9357

Misc:

• Flow no longer errors on colon-style extends and now supports extends by default, previously gated by the ts_syntax option.
• Add format, and test commands to LLM rules

IDE:

• Fixed #​9350

v0.301.0

Compare Source

IDE:

• For React autoimport, it will now always be in the form of import * as React from 'react'

v0.300.0

Compare Source

Misc:

• Minor changes to the flow-upgrade script

v0.299.0

Compare Source

Parser:

• Support export declare, like declare export
• For component in implicit declare context, the ast we produce will include implicitDeclare: true

v0.298.0

Compare Source

Likely to cause new Flow errors:

• Imported functions that conform to hook naming conventions will always be treated like hooks. As a result, new errors might be surfaced. e.g. conditional hook call

Parser:

• flow_parser.js now allows you to pass in filename in the option object

v0.297.0

Compare Source

New Features:

• declare keyword can be omitted for declare function under declaration context (.flow file, declare module, declare namespace)

v0.296.1

Compare Source

Parser:

• Fix parsing of experimental record expressions that are multiline

v0.296.0

Compare Source

Declarations:

• The declare keyword can be omitted for declare const/let/var variable: type and declare component under a declaration context (libdef file, .js.flow file, declare module, declare namespace)
• declare component now requires the rest props to be named - matching normal component declarations

Misc:

• The Omit<O, K> utility type will no longer enforce that the provided keys K need to be part of O

v0.295.0

Compare Source

New Features:

• Support 4 well-known symbols (Symbol.iterator, Symbol.asyncIterator, Symbol.dispose, Symbol.asyncDispose) in class methods. For now, the computed method name needs to be exactly in the form of Symbol.iterator (or other 3 names) to be recognized.

Notable bug fixes:

• Flow will now error when a function parameter appears in the default expression for the same binding. (e.g. try-Flow)

Misc:

• Introduced a codemod for migrating legacy utility types to modern equivalents (yarn run flow-codemod convertLegacyUtilityTypes)

Parser:

• Flow now parses import attributes. For now, we don't do any semantic validation yet

v0.294.0

Compare Source

Parser:

• Support second argument of import expressions

Bug Fixes:

• Fixed bug in computing type hints under JSX expressions (Example of bug fixed)

v0.293.0

Compare Source

Config:

• use_mixed_in_catch_variables option was renamed use_unknown_in_catch_variables because mixed is being renamed to unknown

v0.292.0

Compare Source

Likely to cause new Flow errors:

• Flow will start to validate variance for declare classes.

Parser:

• Rename ClassDeclaration property 'superTypeParameters' to 'superTypeArguments'

v0.291.0

Compare Source

IDE:

• Flow now provides a code action to fix all invalid-type-cast-syntax errors in the file.

v0.290.0

Compare Source

Likely to cause new Flow errors:

• flow will now validate variance in interface declarations
• Bad cyclic object types are now banned. e.g. type O_loop = { p: 0, __proto__: O_loop } will cause an error.
• Flow is now stricter with generic mapped type. example

Notable bug fixes:

• We improved the refinement system of match. Some code that previously gets a general type will now get a refined type. example
• allow opaque types to be used as keys to computed object properties
• autocomplete on import { | } from 'a'; will only suggest values, not types.
• flow-dev-tools now properly detects unused suppressions

IDE:

• Flow now provide auto-import code actions for all unbound names, even through they might resolve to a global. It can be helpful when the global is not what you want.

Library Definitions:

• Add bigint functions to DataView

v0.289.0

Compare Source

Likely to cause new Flow errors:

• For a poorly bounded generic indexed access types, we will no longer generate an error for it when it's being first subtyped against. Instead, we will make it opaque so that when it's being subtyped against, it will error. example
• Flow will error when you are trying to redefine the following reserved types: $NonMaybeType, NonNullable, $ReadOnly, Readonly, $Keys, $Values, Values, $ReadOnlyMap, ReadonlyMap, $ReadOnlySet, ReadonlySet.

Notable bug fixes:

• We no longer incorrectly report conditional hook call for loops with a break. example
• Fixed a potential crash when evaluating a conditional type. example
• Flow will now allow computed keys of type StringPrefix/StringSuffix to be included in object initializers with other non-overlapping keys (example try-Flow)

Library Definitions:

• Update React API types from recent releases
  Added

• act: 19.0: https://react.dev/reference/react/act
• captureOwnerStack: 19.1: See https://react.dev/reference/react/captureOwnerStack
• useEffectEvent: 19.2: https://react.dev/reference/react/useEffectEvent
• <Activity />: 19.2: See https://react.dev/reference/react/Activity
  Updated
• useDeferredValue: 19.0: Accepts a second argument for initial value
• useTransition: 19.0: Accepts an async action function
• startTransition: 19.0: Accepts an async action function

v0.288.0

Compare Source

Likely to cause new Flow errors:

• React.ElementProps is removed. You should use React.ElementConfig instead.
• For a function named as a hook but not annotated as a hook, it will no longer be treated like a hook when you try to use it from property access or property destructuring in component syntax components and hook syntax hooks. They will now cause react-rule-hook-non-hook-syntax errors. To fix, annotate them with hook annotation. example
• Calling functions passed to function and component with hook like name but not annotated as hook will now error. example.
• React$RefSetter<...> and and React$Context are removed. It continues to be available in the form of React.RefSetter<...> and React.Context<...>, regardless of whether you have imported React.
• React$ElementRef<...> was removed. It continues to be available in the form of React.ElementRef<...>, regardless of whether you have imported React.

Breaking Changes:

• The config option max_literal_length was removed. Flow will always decide whether to infer a specific or general type of string literal based on the natural inference algorithm.

Notable bug fixes:

• You can now use @@​dispose and @@​asyncDispose in your library typings. You can access the respective properties with obj[Symbol.dispose] and obj[Symbol.asyncDispose].
• Allow comparisons of bigint singletons

Library Definitions:

• The second type argument of ExactReactElement will be populated by React.ElementConfig<C> instead of React.ElementProps<C>. Most of the code that doesn't depend on exact react element types won't be affected.

v0.287.0

Compare Source

Breaking Changes:

• We will stop publishing new versions of flow-parser-bin. If you want to parse flow code with native-like performance, you should use hermes-parser package, which is running on wasm.

Likely to cause new Flow errors:

• The deprecated React$Element type is now removed. You should use React.Node or React.MixedElement in most cases. If you really want exact react elements, you can use ExactReactElement_DEPRECATED

New Features:

• Flow has full React 19 ref-as-prop support. Since this version, you are allowed to spread ref prop in component syntax components.

IDE:

• We now provide a rewrite refactor to convert arrays, map, set, and object types into their readonly forms.

v0.286.0

Compare Source

Breaking Changes:

• Starting from this version, flow-bin will only contain ARM64 binaries for macOS.

Likely to cause new Flow errors:

• Flow now errors on constant conditions and invalid comparisons. example (D830142 samzhou19815)
• Flow will no longer infer an unsound type for array and object literals passed to a general function. example
• React.ElementConfig<...> and React.PropsOf<...> will now always include the ref prop in the props object type.
• The config option for an earlier mode react.ref_as_prop=partial_support is removed, and Flow now has better support for React 19's ref-as-prop behavior:
  1. All the ref prop in component syntax components must be made optional
  2. You might need to rewrite some of your higher order components. e.g. previously an identity HOC must be written as

declare function id<Props: {...}, Ref>(c: component(ref?: Ref, ...Props)): component(ref?: Ref...Props)

now it must be written as

declare function id<Props: {...}>(c: component(...Props)): component(...Props)

v0.285.0

Compare Source

Library Definitions:

• Fix type of useActionState hook in React. Type should be Awaited instead of Promise (the opposite operation).
• Added types for Object.groupBy and Map.groupBy
  • https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
  • https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/groupBy

Bug fixes:

• Fixed a bug that when experimental.ts_utility_syntax=true, imported Readonly, ReadonlyArray, NonNullable, ReadonlyMap, ReadonlySet types are considered any.

v0.284.0

Compare Source

Likely to cause new Flow errors:

• Flow now strictly enforces that Array.includes, .indexOf, and .lastIndexOf take only values that could potentially be present in the array -- it is now an error to check if arrays include values whose types are unrelated to the array's element type. This catches many cases where developers accidentally test the wrong thing, which may lead to errors at runtime.
• Flow will infer general types for react jsx elements. The new behavior is described in the docs.

v0.283.0

Compare Source

Likely to cause new Flow errors:

• Invalid suppressions like // $FlowFixMe[incompatible will now cause an error on the suppression

v0.282.0

Compare Source

Likely to cause new Flow errors:

• Multiple object property invariant subtyping errors on the same object will be combined into one error. Some error locations might be moved.

Notable bug fixes:

• Fixes crash happening on exported functions with signatures of the form <X>(x: X, y: typeof x): T

IDE:

• We now provide a best effort quickfix for some invariant subtyping errors.

Library Definitions:

• Array.find can now return a more precise value if the predicate is inferred to be a type guard. example

v0.281.0

Compare Source

Breaking Changes:

• Support for the casting_syntax=colon is removed. This means that the as casting syntax is always enabled.
• experimental.error_code_migration config option is removed. In the previously version, the only allowed value was new.

Likely to cause new Flow errors:

• We have fixed more source of object literal unsoundness. More errors will be exposed. (example)
• For most of the common invariant subtyping errors (arrays, objects with mutable fields), we will now emit a single subtyping error with explanation how to fix. Error locations might change. See https://flow.org/en/docs/lang/variance/#toc-invariance to learn more about variance of types
• Suppressions without error code will now be an error instead of a warning.
• Suppressions without error code will no longer apply. You can download and use this script to automatically migrate most of the suppressions.
• Only $FlowFixMe and $FlowExpectedError are supported suppression comments. Existing $FlowIgnore and $FlowIssue will no longer suppress anything.

New Features:

• Added a Flow lint require-explicit-enum-checks which works like require-explicit-enum-switch-cases but for match.

Notable bug fixes:

• Various codemods will now insert parentheses around expressions in class extends if they are changed. Previously, it might result in invalid code like class Foo extends myExpr() as Bar
• Fixes an inconsistency in recording the this-type guard on a regular (non-declare) method in the same vs different files.

IDE:

• Added a quickfix to convert type to value imports on type-as-value errors.

v0.280.0

Compare Source

Likely to cause new Flow errors:

• Accessing missing exports on namespaced import will now trigger missing-export error instead of prop-missing error. (example)
• The only supported suppress_type $FlowFixMe is now just a type alias of any. For most of the code, there will be no functional differences. However, you might see new errors if you have any local definitions of $FlowFixMe, or you used the undocumented $FlowFixMe<arbitrary type arguments>.
• Support for suppress_type config has been removed. The only supported supress_type now is $FlowFixMe. If you want other variants, you can add

type MySuppressType = any

in your global library definitions.

• Many subtyping type errors' error codes have been standardized into incompatible-type, so some previously suppressed errors will reappear until you change the suppression error code into incompatible-type. The change was announced in the previous version, with option to enable it via experimental.error_code_migration=new. Now the only valid option to experimental.error_code_migration is new. You can run flow codemod error-code-migration --write . with the previous version of Flow to help migrate, since the codemod is removed in this version.

v0.279.0

Compare Source

New Features:

• In the next release (0.280.0) of Flow, we intend to standardize the error code for various subtyping errors into incompatible-type. You can add experimental.error_code_migration=new in your flowconfig to enable the new behavior now. We also provide a codemod flow codemod error-code-migration --write . that you can run over your codebase to automatically change the error code. Both the flowconfig option and the codemod will be removed in the next version.

Notable bug fixes:

• Improved precision of error messages when inferred primitive types are checked against other incompatible primitive types (e.g. try-Flow)

Misc:

• Thanks @​JamBalaya56562 for fixing various typos across the codebase!

v0.278.0

Compare Source

Likely to cause new Flow errors:

• Hooks calls inside normal functions in component or hooks as conditional calls. They will get react-rule-hook-conditional error instead of react-rule-hook error.
• Array literals that cannot be contextually typed will be inferred as an actual array type. It might cause additional errors. example

v0.277.1

Compare Source

Notable bug fixes:

• Fixed windows builds.

v0.277.0

Compare Source

Likely to cause new Flow errors:

• Array literals that cannot be contextually typed can no longer be passed to mutable tuples with a more general element type. It might cause additional errors. example

v0.276.0

Compare Source

Likely to cause new Flow errors:

• Hook calls inside anonymous functions bound to a variable will get react-rule-hook-definitely-not-in-component-or-hook error, if the variable name doesn't conform to hook naming convention. example

IDE:

• Added support for workspace symbol feature

Misc:

• Thanks @​jbroma for improving as casts with function generics and component generics!

v0.275.0

Compare Source

Likely to cause new Flow errors:

• For all object literals in positions that cannot be contextually typed, we will infer a stricter type for them. It will cause new errors in code like

const foo = {baz: new Dog()};
type Foo = {bar?: string, baz: Animal};
declare function acceptFoo(foo: Foo): void;
acceptFoo(foo); // error

To fix the error, you can either annotate the object

const foo: Foo = {baz: new Dog()};

type Foo = {bar?: string, baz: Animal};
declare function acceptFoo(foo: Foo): void;

acceptFoo(foo);

or make the call site accepts readonly objects:

const foo = {baz: new Dog()};

type Foo = $ReadOnly<{bar?: string, baz: Animal}>;
declare function acceptFoo(foo: Foo): void;

acceptFoo(foo);

We provide a codemod to automate the annotation process. flow codemod annotate-literal-declaration --write --max-type-size 5. (You can adjust the max type size based on your needs).

IDE:

• Support rename on private properties and methods.

Library Definitions:

• React$MixedElement is removed from builtin libdef. It will cause internal-type error since v0.258.0. You should use React.MixedElement instead.

v0.274.2

Compare Source

• Bug fixes for match

v0.274.1

Compare Source

New Features:

• Support for experimental match feature using option experimental.pattern_matching=true

v0.274.0

Compare Source

Likely to cause new Flow errors:

• Unannotated object literals reachable from exports will now be inferred to have all mutable fields when being imported. Previously, it has unsound types, so new errors might appear.
• When comparing two object types whose properties have variance incompatibilities, Flow will raise a single error that will summarize the properties with incompatible variances, instead of a single error for each property. (e.g. try-Flow)
• When an object with extra properties is passed to a place that expect an exact object, we will now generate a single error with all extra properties. The error message will list the extra properties, and state that "Exact objects do not accept extra props". In rare cases, the error locations might be moved.
• Flow will error more consistently with sketchy-bool on nullable boolean types (e.g. try-Flow)

Library Definitions:

• All properties in the builtin PropertyDescriptor type are marked as readonly. If you need a mutable version, you can introduce something like type MutablePropertyDescriptor<T> = {...$Exact<PropertyDescriptor<T>>, ...}

v0.273.1

Compare Source

Notable bug fixes:

• Fixed windows builds.
• Fixed crash when loading saved state.

v0.273.0

Compare Source

Likely to cause new Flow errors:

• We are announcing Natural Inference for Flow, an improved way to infer types for primitive values, that resolves a long-standing correctness gap and source of confusion. See more in this post.
• Added nested-hook and nested-component lint errors which detect nested hook or component syntax within component or hook syntax. This is on by default.

Notable bug fixes:

• For default imports, the autoimport ranking will now consider the names of the importing side. (e.g. Previously we completely ignored the name of foo in import foo from './bar', but now we will count foo. If the pattern of import foo from './bar' happens a lot, then the autoimport algorithm will be more likely to suggest import foo from './bar' rather than import bar from './bar').
• Flow will infer a correct type when viewing the type of an object literal as a dictionary type. For example, the error in this try-Flow will be raised.
• Previously, we undercounted some imports during indexing, which causes autoimport ranking to behave incorrectly. The issue is now fixed.
• Flow will no longer emit react-rule-hook-conditional error for hooks called in a conditionally defined nested component.

v0.272.2

Compare Source

Notable bug fixes:

• Prevent non-termination when computing code actions.

v0.272.1

Compare Source

Notable bug fixes:

• Fixed https://flow.org/try. It was broken from v0.270.0 to v0.272.0.
• Documentation in hover now preserves indentations. Therefore, code blocks in jsdoc will no longer lose indentation.

v0.272.0

Compare Source

Likely to cause new Flow errors:

• When component syntax is enabled, hook calls happen inside an upper case function that doesn't have a props param that's a subtype of interface {} will get react-rule-hook-definitely-not-in-component-or-hook error.
• Calling a function that's a union of hook and non-hook will now get react-rule-hook-mixed-with-non-hook error instead of react-rule-hook error. Calling functions named like hook but not in hook syntax will now get react-rule-hook-non-hook-syntax instead of react-rule-hook error.

Notable bug fixes:

• Go-to-definition on default import of module.exports will correctly jump to the exporting file

Parser:

• Fix crash on ''#!/usr/bin/env node\n'' when generating token list

Library Definitions:

• React.forwardRef is marked as deprecated. We might remove it from our builtin libdef in the future.

v0.271.0

Compare Source

Notable bug fixes:

• Multiple levels of export * will now be correctly indexed so that they won't be missing in autoimport results.

Library Definitions

• Add Float16Array type

v0.270.0

Compare Source

Likely to cause new Flow errors:

• When component syntax support is enabled, upper case functions with component-like name but doesn't return React.Node will no longer be treated like components. Thus, all the hooks call in such functions will have react-rule-hook-definitely-not-in-component-or-hook errors.
• Usage of Object.assign will now trigger unsafe-object-assign lint error that's on by default. The type checking behavior for Object.assign will otherwise stay the same for now.
• When Flow decides that the hook call definitely doesn't happen within component or hook body, it will emit errors with code react-rule-hook-definitely-not-in-component-or-hook.

Parser:

• Parse the TS nonnull assertion operator.

v0.269.1

Compare Source

It should have the same behavior as 0.269.0.

v0.268.0

Compare Source

Breaking:

• The Linux x86 build is now built from ubuntu-22.04. It might make Flow not runnable on older linux distributions.

Likely to cause new Flow errors:

• Code like the (example) will have [react-rule-hook-conditional] instead of [react-rule-hook-naming-convention] errors.
• $Diff support is removed. If you have trouble migrating, you can try to polyfill it by this. However, $Diff has surprising behavior with regard to optional props in the second type parameter, which cannot be easily polyfilled (example).

New Features:

• We now allow you to configure certain error code to be unsuppressable. For example, to make react-rule-hook-naming-convention and react-rule-hook-conditional errors unsuppressable, you can add the following to the [options] section in flowconfig:

unsuppressable_error_codes=react-rule-hook-naming-convention
unsuppressable_error_codes=react-rule-hook-conditional

v0.267.0

Compare Source

Likely to cause new Flow errors:

• We have updated the way type parameters are instantiated in generic calls, specifically when using upper bounds:

  • We will no longer infer synthetic intersection types.
  • If multiple upper bounds are available, we pick the smallest type based on subtyping (example).

• Support for $Rest is removed. Omit should be used instead. If you still have many instances of $Rest, you can replace them with $Diff as a temporary measure, but note that we intend to eventually remove $Diff as well.

• React-rule hook errors related to conditional hook calls will now have react-rule-hook-conditional error code.

• React-rule hook errors related to naming convention issues will now have react-rule-hook-naming-convention error code.

Notable bug fixes:

• We are rolling out the initial phase of a fix to a fundamental soundness issue related to primitive literal type inference. This unsoundness has allowed invalid code like: const x = 'a'; 'b' as typeof x as 'a'; (try-Flow) to type check without errors. With this fix, Flow will infer singleton literal types for primitive literals in contexts where such precision is required. Examples of this are: const-declarations (e.g. in const x = 42 will infer the type 42 for x), annotation positions (e.g. typeof x is equivalent to the type 42), conditionals (e.g. in if (x.tag === 42) {} Flow will infer the type 42 for the value 42, instead of number). In this part of the rollout, whenever this precision is not required Flow will infer the unsound type it used to infer before (a hybrid between the singleton and general type). Eliminating this unsound type completely will be done soon.
• flow-remove-types now handles the removal of empty imports after removing type/typeof imports (thanks @​jbroma)

v0.266.1

Compare Source

• Fix a bug that causes fixed libdef-override error to stick around after an incremental recheck.

v0.266.0

Compare Source

Likely to cause new Flow errors:

• Support for $PropertyType and $ElementType has been removed. Now referencing these types will just resolve to a global type if you have your own definition for them, and result in a cannot-resolve-name error otherwise. These types have been replaced by index access types for a long time. You can migrate to index access types by enabling use-indexed-access-type from https://www.npmjs.com/package/eslint-plugin-fb-flow and running the quickfixes. If you are unable to migrate, you can add the following to your global libdefs:

type $PropertyType<T, K> = T[K];
type $ElementType<T, K> = T[K];

• Now given the subtyping check component()<: component(ref?: ref_prop), Flow will ensure that ref_prop is a subtype of void instead of a subtype of React.RefSetter<void>.
• React$ComponentType, which was previously given [internal-type] error on every usage, is now removed.
• React.ComponentType<Props> is now only an alias of component(...Props), instead of some special cased types. This comes with stricter checks and conversions, such as making Props readonly, erroring on the presence the ref prop instead of silently ignoring them, and ensures that Props is a subtype of {...}. In addition, the React$AbstractComponent type is removed.

Notable bug fixes:

• fixed a subtle unsoundness in the inference of computed-property dictionary object creation (e.g. try-Flow)

Library Definitions:

• React.lazy and React.memo is now generic over the presence or absence of ref prop.

v0.265.3

Compare Source

• Make @flowtyped resolution support work on Windows.

v0.265.2

Compare Source

Notable bug fixes:

• We fixed a bug that caused suppressions to not apply for libdef-override errors.
• We fixed a bug that caused `libdef

---

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.