builder.io 1.6.10 → 1.6.12

package/figma/jsx-runtime/index.d.ts

@@ -31,7 +31,7 @@ export namespace JSX {
 export function jsx(
   type: React.ElementType,
   props: unknown,
-  key?: React.Key
+  key?: React.Key,
 ): React.ReactElement;
 
 /**
@@ -42,5 +42,5 @@ export function jsx(
 export function jsxs(
   type: React.ElementType,
   props: unknown,
-  key?: React.Key
+  key?: React.Key,
 ): React.ReactElement;

package/figma/jsx-runtime/prop-types.d.ts

@@ -40,7 +40,7 @@ export interface Validator<T> {
     propName: string,
     componentName: string,
     location: string,
-    propFullName: string
+    propFullName: string,
   ): Error | null;
   [nominalTypeHack]?:
     | {
@@ -64,8 +64,8 @@ export type WeakValidationMap<T> = {
   [K in keyof T]?: null extends T[K]
     ? Validator<T[K] | null | undefined>
     : undefined extends T[K]
-    ? Validator<T[K] | null | undefined>
-    : Validator<T[K]>;
+      ? Validator<T[K] | null | undefined>
+      : Validator<T[K]>;
 };
 
 export type InferType<V> = V extends Validator<infer T> ? T : any;
@@ -84,21 +84,21 @@ export const element: Requireable<ReactElementLike>;
 export const symbol: Requireable<symbol>;
 export const elementType: Requireable<ReactComponentLike>;
 export function instanceOf<T>(
-  expectedClass: new (...args: any[]) => T
+  expectedClass: new (...args: any[]) => T,
 ): Requireable<T>;
 export function oneOf<T>(types: readonly T[]): Requireable<T>;
 export function oneOfType<T extends Validator<any>>(
-  types: T[]
+  types: T[],
 ): Requireable<NonNullable<InferType<T>>>;
 export function arrayOf<T>(type: Validator<T>): Requireable<T[]>;
 export function objectOf<T>(
-  type: Validator<T>
+  type: Validator<T>,
 ): Requireable<{ [K in keyof any]: T }>;
 export function shape<P extends ValidationMap<any>>(
-  type: P
+  type: P,
 ): Requireable<InferProps<P>>;
 export function exact<P extends ValidationMap<any>>(
-  type: P
+  type: P,
 ): Requireable<Required<InferProps<P>>>;
 
 /**
@@ -116,7 +116,7 @@ export function checkPropTypes(
   values: any,
   location: string,
   componentName: string,
-  getStack?: () => any
+  getStack?: () => any,
 ): void;
 
 /**

package/figma/jsx-runtime/react.d.ts

@@ -85,7 +85,7 @@ declare namespace React {
    */
   type ElementType<
     P = any,
-    Tag extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements
+    Tag extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements,
   > =
     | { [K in Tag]: P extends JSX.IntrinsicElements[K] ? K : never }[Tag]
     | ComponentType<P>;
@@ -121,7 +121,7 @@ declare namespace React {
          *
          * @see {@link https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-stateless-function-components React Docs}
          */
-        deprecatedLegacyContext?: any
+        deprecatedLegacyContext?: any,
       ) => ReactNode)
     | (new (
         props: P,
@@ -130,7 +130,7 @@ declare namespace React {
          *
          * @see {@link https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-lifecycle-methods React Docs}
          */
-        deprecatedLegacyContext?: any
+        deprecatedLegacyContext?: any,
       ) => Component<any, any>);
 
   /**
@@ -171,7 +171,7 @@ declare namespace React {
    */
   type RefCallback<T> = {
     bivarianceHack(
-      instance: T | null
+      instance: T | null,
     ):
       | void
       | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES];
@@ -221,7 +221,7 @@ declare namespace React {
       | ForwardRefExoticComponent<any>
       | { new (props: any): Component<any> }
       | ((props: any, deprecatedLegacyContext?: any) => ReactNode)
-      | keyof JSX.IntrinsicElements
+      | keyof JSX.IntrinsicElements,
   > =
     // need to check first if `ref` is a valid prop for ts@3.0
     // otherwise it will infer `{}` instead of `never`
@@ -326,7 +326,7 @@ declare namespace React {
     P = any,
     T extends string | JSXElementConstructor<any> =
       | string
-      | JSXElementConstructor<any>
+      | JSXElementConstructor<any>,
   > {
     type: T;
     props: P;
@@ -338,7 +338,10 @@ declare namespace React {
    */
   export interface ReactComponentElement<
     T extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>,
-    P = Pick<ComponentProps<T>, Exclude<keyof ComponentProps<T>, "key" | "ref">>
+    P = Pick<
+      ComponentProps<T>,
+      Exclude<keyof ComponentProps<T>, "key" | "ref">
+    >,
   > extends ReactElement<P, Exclude<T, number>> {}
 
   export interface FunctionComponentElement<P>
@@ -354,7 +357,7 @@ declare namespace React {
 
   export type CElement<
     P,
-    T extends Component<P, ComponentState>
+    T extends Component<P, ComponentState>,
   > = ComponentElement<P, T>;
   export interface ComponentElement<P, T extends Component<P, ComponentState>>
     extends ReactElement<P, ComponentClass<P>> {
@@ -372,7 +375,7 @@ declare namespace React {
   // string fallback for custom web-components
   export interface DOMElement<
     P extends HTMLAttributes<T> | SVGAttributes<T>,
-    T extends Element
+    T extends Element,
   > extends ReactElement<P, string> {
     ref: LegacyRef<T>;
   }
@@ -383,7 +386,7 @@ declare namespace React {
 
   export interface DetailedReactHTMLElement<
     P extends HTMLAttributes<T>,
-    T extends HTMLElement
+    T extends HTMLElement,
   > extends DOMElement<P, T> {
     type: keyof ReactHTML;
   }
@@ -424,7 +427,7 @@ declare namespace React {
 
   export type CFactory<
     P,
-    T extends Component<P, ComponentState>
+    T extends Component<P, ComponentState>,
   > = ComponentFactory<P, T>;
   export type ClassicFactory<P> = CFactory<
     P,
@@ -441,7 +444,7 @@ declare namespace React {
 
   export interface DetailedHTMLFactory<
     P extends HTMLAttributes<T>,
-    T extends HTMLElement
+    T extends HTMLElement,
   > extends DOMFactory<P, T> {
     (
       props?: (ClassAttributes<T> & P) | null,
@@ -531,25 +534,25 @@ declare namespace React {
   // DOM Elements
   /** @deprecated */
   function createFactory<T extends HTMLElement>(
-    type: keyof ReactHTML
+    type: keyof ReactHTML,
   ): HTMLFactory<T>;
   /** @deprecated */
   function createFactory(type: keyof ReactSVG): SVGFactory;
   /** @deprecated */
   function createFactory<P extends DOMAttributes<T>, T extends Element>(
-    type: string
+    type: string,
   ): DOMFactory<P, T>;
 
   // Custom components
   /** @deprecated */
   function createFactory<P>(
-    type: FunctionComponent<P>
+    type: FunctionComponent<P>,
   ): FunctionComponentFactory<P>;
   /** @deprecated */
   function createFactory<
     P,
     T extends Component<P, ComponentState>,
-    C extends ComponentClass<P>
+    C extends ComponentClass<P>,
   >(type: ClassType<P, T, C>): CFactory<P, T>;
   /** @deprecated */
   function createFactory<P>(type: ComponentClass<P>): Factory<P>;
@@ -593,7 +596,7 @@ declare namespace React {
   function createElement<
     P extends {},
     T extends Component<P, ComponentState>,
-    C extends ComponentClass<P>
+    C extends ComponentClass<P>,
   >(
     type: ClassType<P, T, C>,
     props?: (ClassAttributes<T> & P) | null,
@@ -725,9 +728,8 @@ declare namespace React {
    * // ContextType = { foo: string }
    * ```
    */
-  export type ContextType<C extends Context<any>> = C extends Context<infer T>
-    ? T
-    : never;
+  export type ContextType<C extends Context<any>> =
+    C extends Context<infer T> ? T : never;
 
   /**
    * Wraps your components to specify the value of this context for all components inside.
@@ -824,11 +826,11 @@ declare namespace React {
   function createContext<T>(
     // If you thought this should be optional, see
     // https://github.com/DefinitelyTyped/DefinitelyTyped/pull/24509#issuecomment-382213106
-    defaultValue: T
+    defaultValue: T,
   ): Context<T>;
 
   function isValidElement<P>(
-    object: {} | null | undefined
+    object: {} | null | undefined,
   ): object is ReactElement<P>;
 
   /**
@@ -837,18 +839,18 @@ declare namespace React {
   const Children: {
     map<T, C>(
       children: C | readonly C[],
-      fn: (child: C, index: number) => T
+      fn: (child: C, index: number) => T,
     ): C extends null | undefined
       ? C
       : Array<Exclude<T, boolean | null | undefined>>;
     forEach<C>(
       children: C | readonly C[],
-      fn: (child: C, index: number) => void
+      fn: (child: C, index: number) => void,
     ): void;
     count(children: any): number;
     only<C>(children: C): C extends any[] ? never : C;
     toArray(
-      children: ReactNode | ReactNode[]
+      children: ReactNode | ReactNode[],
     ): Array<Exclude<ReactNode, boolean | null | undefined>>;
   };
   /**
@@ -980,7 +982,7 @@ declare namespace React {
      *
      * @see {@link https://react.dev/reference/react/Profiler#onrender-callback React Docs}
      */
-    commitTime: number
+    commitTime: number,
   ) => void;
 
   /**
@@ -1073,10 +1075,10 @@ declare namespace React {
       state:
         | ((
             prevState: Readonly<S>,
-            props: Readonly<P>
+            props: Readonly<P>,
           ) => Pick<S, K> | S | null)
         | (Pick<S, K> | S | null),
-      callback?: () => void
+      callback?: () => void,
     ): void;
 
     forceUpdate(callback?: () => void): void;
@@ -1183,7 +1185,7 @@ declare namespace React {
        *
        * @see {@link https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-lifecycle-methods React Docs}
        */
-      deprecatedLegacyContext?: any
+      deprecatedLegacyContext?: any,
     ): ReactNode;
     /**
      * Used to declare the types of the props accepted by the
@@ -1270,7 +1272,7 @@ declare namespace React {
        *
        * @see {@link https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-lifecycle-methods React Docs}
        */
-      deprecatedLegacyContext?: any
+      deprecatedLegacyContext?: any,
     ): ReactNode;
     propTypes?: WeakValidationMap<P> | undefined;
     contextTypes?: ValidationMap<any> | undefined;
@@ -1348,7 +1350,7 @@ declare namespace React {
        *
        * @see {@link https://legacy.reactjs.org/docs/legacy-context.html#referencing-context-in-lifecycle-methods React Docs}
        */
-      deprecatedLegacyContext?: any
+      deprecatedLegacyContext?: any,
     ): Component<P, S>;
     /**
      * Used to declare the types of the props accepted by the
@@ -1401,10 +1403,10 @@ declare namespace React {
    * @see {@link https://www.npmjs.com/package/create-react-class `create-react-class` on npm}
    */
   interface ClassicComponentClass<P = {}> extends ComponentClass<P> {
-    new (props: P, deprecatedLegacyContext?: any): ClassicComponent<
-      P,
-      ComponentState
-    >;
+    new (
+      props: P,
+      deprecatedLegacyContext?: any,
+    ): ClassicComponent<P, ComponentState>;
     getDefaultProps?(): P;
   }
 
@@ -1420,7 +1422,7 @@ declare namespace React {
   type ClassType<
     P,
     T extends Component<P, ComponentState>,
-    C extends ComponentClass<P>
+    C extends ComponentClass<P>,
   > = C & (new (props: P, deprecatedLegacyContext?: any) => T);
 
   //
@@ -1450,7 +1452,7 @@ declare namespace React {
     shouldComponentUpdate?(
       nextProps: Readonly<P>,
       nextState: Readonly<S>,
-      nextContext: any
+      nextContext: any,
     ): boolean;
     /**
      * Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as
@@ -1499,7 +1501,7 @@ declare namespace React {
      */
     getSnapshotBeforeUpdate?(
       prevProps: Readonly<P>,
-      prevState: Readonly<S>
+      prevState: Readonly<S>,
     ): SS | null;
     /**
      * Called immediately after updating occurs. Not called for the initial render.
@@ -1509,7 +1511,7 @@ declare namespace React {
     componentDidUpdate?(
       prevProps: Readonly<P>,
       prevState: Readonly<S>,
-      snapshot?: SS
+      snapshot?: SS,
     ): void;
   }
 
@@ -1577,7 +1579,7 @@ declare namespace React {
      */
     UNSAFE_componentWillReceiveProps?(
       nextProps: Readonly<P>,
-      nextContext: any
+      nextContext: any,
     ): void;
     /**
      * Called immediately before rendering when new props or state is received. Not called for the initial render.
@@ -1595,7 +1597,7 @@ declare namespace React {
     componentWillUpdate?(
       nextProps: Readonly<P>,
       nextState: Readonly<S>,
-      nextContext: any
+      nextContext: any,
     ): void;
     /**
      * Called immediately before rendering when new props or state is received. Not called for the initial render.
@@ -1615,7 +1617,7 @@ declare namespace React {
     UNSAFE_componentWillUpdate?(
       nextProps: Readonly<P>,
       nextState: Readonly<S>,
-      nextContext: any
+      nextContext: any,
     ): void;
   }
 
@@ -1697,7 +1699,7 @@ declare namespace React {
    * ```
    */
   function forwardRef<T, P = {}>(
-    render: ForwardRefRenderFunction<T, PropsWithoutRef<P>>
+    render: ForwardRefRenderFunction<T, PropsWithoutRef<P>>,
   ): ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
 
   /**
@@ -1754,12 +1756,13 @@ declare namespace React {
    * ```
    */
   type ComponentProps<
-    T extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>
-  > = T extends JSXElementConstructor<infer P>
-    ? P
-    : T extends keyof JSX.IntrinsicElements
-    ? JSX.IntrinsicElements[T]
-    : {};
+    T extends keyof JSX.IntrinsicElements | JSXElementConstructor<any>,
+  > =
+    T extends JSXElementConstructor<infer P>
+      ? P
+      : T extends keyof JSX.IntrinsicElements
+        ? JSX.IntrinsicElements[T]
+        : {};
 
   /**
    * Used to retrieve the props a component accepts with its ref. Can either be
@@ -1785,7 +1788,7 @@ declare namespace React {
    * ```
    */
   type ComponentPropsWithRef<T extends ElementType> = T extends new (
-    props: infer P
+    props: infer P,
   ) => Component<any, any>
     ? PropsWithoutRef<P> & RefAttributes<InstanceType<T>>
     : PropsWithRef<ComponentProps<T>>;
@@ -1806,12 +1809,12 @@ declare namespace React {
    * ```
    */
   type CustomComponentPropsWithRef<T extends ComponentType> = T extends new (
-    props: infer P
+    props: infer P,
   ) => Component<any, any>
     ? PropsWithoutRef<P> & RefAttributes<InstanceType<T>>
     : T extends (props: infer P, legacyContext?: any) => ReactNode
-    ? PropsWithRef<P>
-    : never;
+      ? PropsWithRef<P>
+      : never;
 
   /**
    * Used to retrieve the props a component accepts without its ref. Can either be
@@ -1840,13 +1843,14 @@ declare namespace React {
     ComponentProps<T>
   >;
 
-  type ComponentRef<T extends ElementType> = T extends NamedExoticComponent<
-    ComponentPropsWithoutRef<T> & RefAttributes<infer Method>
-  >
-    ? Method
-    : ComponentPropsWithRef<T> extends RefAttributes<infer Method>
-    ? Method
-    : never;
+  type ComponentRef<T extends ElementType> =
+    T extends NamedExoticComponent<
+      ComponentPropsWithoutRef<T> & RefAttributes<infer Method>
+    >
+      ? Method
+      : ComponentPropsWithRef<T> extends RefAttributes<infer Method>
+        ? Method
+        : never;
 
   // will show `Memo(${Component.displayName || Component.name})` in devtools by default,
   // but can be given its own specific name
@@ -1876,14 +1880,14 @@ declare namespace React {
    */
   function memo<P extends object>(
     Component: FunctionComponent<P>,
-    propsAreEqual?: (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean
+    propsAreEqual?: (prevProps: Readonly<P>, nextProps: Readonly<P>) => boolean,
   ): NamedExoticComponent<P>;
   function memo<T extends ComponentType<any>>(
     Component: T,
     propsAreEqual?: (
       prevProps: Readonly<ComponentProps<T>>,
-      nextProps: Readonly<ComponentProps<T>>
-    ) => boolean
+      nextProps: Readonly<ComponentProps<T>>,
+    ) => boolean,
   ): MemoExoticComponent<T>;
 
   interface LazyExoticComponent<T extends ComponentType<any>>
@@ -1912,7 +1916,7 @@ declare namespace React {
    * ```
    */
   function lazy<T extends ComponentType<any>>(
-    load: () => Promise<{ default: T }>
+    load: () => Promise<{ default: T }>,
   ): LazyExoticComponent<T>;
 
   //
@@ -1956,18 +1960,10 @@ declare namespace React {
   type ReducerWithoutAction<S> = (prevState: S) => S;
   // types used to try and prevent the compiler from reducing S
   // to a supertype common with the second argument to useReducer()
-  type ReducerState<R extends Reducer<any, any>> = R extends Reducer<
-    infer S,
-    any
-  >
-    ? S
-    : never;
-  type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<
-    any,
-    infer A
-  >
-    ? A
-    : never;
+  type ReducerState<R extends Reducer<any, any>> =
+    R extends Reducer<infer S, any> ? S : never;
+  type ReducerAction<R extends Reducer<any, any>> =
+    R extends Reducer<any, infer A> ? A : never;
   // The identity check is done with the SameValue algorithm (Object.is), which is stricter than ===
   type ReducerStateWithoutAction<R extends ReducerWithoutAction<any>> =
     R extends ReducerWithoutAction<infer S> ? S : never;
@@ -1989,7 +1985,7 @@ declare namespace React {
    * @see {@link https://react.dev/reference/react/useContext}
    */
   function useContext<T>(
-    context: Context<T> /*, (not public API) observedBits?: number|boolean */
+    context: Context<T> /*, (not public API) observedBits?: number|boolean */,
   ): T;
   /**
    * Returns a stateful value, and a function to update it.
@@ -1998,7 +1994,7 @@ declare namespace React {
    * @see {@link https://react.dev/reference/react/useState}
    */
   function useState<S>(
-    initialState: S | (() => S)
+    initialState: S | (() => S),
   ): [S, Dispatch<SetStateAction<S>>];
   // convenience overload when first argument is omitted
   /**
@@ -2009,7 +2005,7 @@ declare namespace React {
    */
   function useState<S = undefined>(): [
     S | undefined,
-    Dispatch<SetStateAction<S | undefined>>
+    Dispatch<SetStateAction<S | undefined>>,
   ];
   /**
    * An alternative to `useState`.
@@ -2025,7 +2021,7 @@ declare namespace React {
   function useReducer<R extends ReducerWithoutAction<any>, I>(
     reducer: R,
     initializerArg: I,
-    initializer: (arg: I) => ReducerStateWithoutAction<R>
+    initializer: (arg: I) => ReducerStateWithoutAction<R>,
   ): [ReducerStateWithoutAction<R>, DispatchWithoutAction];
   /**
    * An alternative to `useState`.
@@ -2041,7 +2037,7 @@ declare namespace React {
   function useReducer<R extends ReducerWithoutAction<any>>(
     reducer: R,
     initializerArg: ReducerStateWithoutAction<R>,
-    initializer?: undefined
+    initializer?: undefined,
   ): [ReducerStateWithoutAction<R>, DispatchWithoutAction];
   /**
    * An alternative to `useState`.
@@ -2059,7 +2055,7 @@ declare namespace React {
   function useReducer<R extends Reducer<any, any>, I>(
     reducer: R,
     initializerArg: I & ReducerState<R>,
-    initializer: (arg: I & ReducerState<R>) => ReducerState<R>
+    initializer: (arg: I & ReducerState<R>) => ReducerState<R>,
   ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
   /**
    * An alternative to `useState`.
@@ -2075,7 +2071,7 @@ declare namespace React {
   function useReducer<R extends Reducer<any, any>, I>(
     reducer: R,
     initializerArg: I,
-    initializer: (arg: I) => ReducerState<R>
+    initializer: (arg: I) => ReducerState<R>,
   ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
   /**
    * An alternative to `useState`.
@@ -2100,7 +2096,7 @@ declare namespace React {
   function useReducer<R extends Reducer<any, any>>(
     reducer: R,
     initialState: ReducerState<R>,
-    initializer?: undefined
+    initializer?: undefined,
   ): [ReducerState<R>, Dispatch<ReducerAction<R>>];
   /**
    * `useRef` returns a mutable ref object whose `.current` property is initialized to the passed argument
@@ -2178,7 +2174,7 @@ declare namespace React {
   function useImperativeHandle<T, R extends T>(
     ref: Ref<T> | undefined,
     init: () => R,
-    deps?: DependencyList
+    deps?: DependencyList,
   ): void;
   // I made 'inputs' required here and in useMemo as there's no point to memoizing without the memoization key
   // useCallback(X) is identical to just using X, useMemo(() => Y) is identical to just using Y.
@@ -2194,7 +2190,7 @@ declare namespace React {
   // eslint-disable-next-line @typescript-eslint/ban-types
   function useCallback<T extends Function>(
     callback: T,
-    deps: DependencyList
+    deps: DependencyList,
   ): T;
   /**
    * `useMemo` will only recompute the memoized value when one of the `deps` has changed.
@@ -2294,7 +2290,7 @@ declare namespace React {
    */
   export function useInsertionEffect(
     effect: EffectCallback,
-    deps?: DependencyList
+    deps?: DependencyList,
   ): void;
 
   /**
@@ -2307,7 +2303,7 @@ declare namespace React {
   export function useSyncExternalStore<Snapshot>(
     subscribe: (onStoreChange: () => void) => () => void,
     getSnapshot: () => Snapshot,
-    getServerSnapshot?: () => Snapshot
+    getServerSnapshot?: () => Snapshot,
   ): Snapshot;
 
   //
@@ -4529,8 +4525,8 @@ declare namespace React {
     [K in keyof T]?: null extends T[K]
       ? Validator<T[K] | null | undefined>
       : undefined extends T[K]
-      ? Validator<T[K] | null | undefined>
-      : Validator<T[K]>;
+        ? Validator<T[K] | null | undefined>
+        : Validator<T[K]>;
   };
 
   /**
@@ -4566,18 +4562,18 @@ declare namespace React {
   interface ReactChildren {
     map<T, C>(
       children: C | readonly C[],
-      fn: (child: C, index: number) => T
+      fn: (child: C, index: number) => T,
     ): C extends null | undefined
       ? C
       : Array<Exclude<T, boolean | null | undefined>>;
     forEach<C>(
       children: C | readonly C[],
-      fn: (child: C, index: number) => void
+      fn: (child: C, index: number) => void,
     ): void;
     count(children: any): number;
     only<C>(children: C): C extends any[] ? never : C;
     toArray(
-      children: ReactNode | ReactNode[]
+      children: ReactNode | ReactNode[],
     ): Array<Exclude<ReactNode, boolean | null | undefined>>;
   }
 
@@ -4661,14 +4657,14 @@ type MergePropTypes<P, T> =
       IsExactlyAny<P> extends true
       ? T
       : // If declared props have indexed properties, ignore inferred props entirely as keyof gets widened
-      string extends keyof P
-      ? P
-      : // Prefer declared types which are not exactly any
-        Pick<P, NotExactlyAnyPropertyKeys<P>> &
-          // For props which are exactly any, use the type inferred from propTypes if present
-          Pick<T, Exclude<keyof T, NotExactlyAnyPropertyKeys<P>>> &
-          // Keep leftover props not specified in propTypes
-          Pick<P, Exclude<keyof P, keyof T>>
+        string extends keyof P
+        ? P
+        : // Prefer declared types which are not exactly any
+          Pick<P, NotExactlyAnyPropertyKeys<P>> &
+            // For props which are exactly any, use the type inferred from propTypes if present
+            Pick<T, Exclude<keyof T, NotExactlyAnyPropertyKeys<P>>> &
+            // Keep leftover props not specified in propTypes
+            Pick<P, Exclude<keyof P, keyof T>>
     : never;
 
 type InexactPartial<T> = { [K in keyof T]?: T[K] | undefined };
@@ -4691,10 +4687,10 @@ type ReactManagedAttributes<C, P> = C extends {
 }
   ? Defaultize<MergePropTypes<P, PropTypes.InferProps<T>>, D>
   : C extends { propTypes: infer T }
-  ? MergePropTypes<P, PropTypes.InferProps<T>>
-  : C extends { defaultProps: infer D }
-  ? Defaultize<P, D>
-  : P;
+    ? MergePropTypes<P, PropTypes.InferProps<T>>
+    : C extends { defaultProps: infer D }
+      ? Defaultize<P, D>
+      : P;
 
 /**
  * @deprecated Use `React.JSX` instead of the global `JSX` namespace.