styled-components 6.4.2 → 6.4.3

package/dist/types.d.ts

@@ -121,10 +121,48 @@ export interface IStyledStatics<out R extends Runtime, in out OuterProps extends
 /**
  * Used by PolymorphicComponent to define prop override cascading order.
  */
-export type PolymorphicComponentProps<R extends Runtime, BaseProps extends BaseObject, AsTarget extends StyledTarget<R> | void, ForwardedAsTarget extends StyledTarget<R> | void, AsTargetProps extends BaseObject = AsTarget extends KnownTarget ? React.ComponentPropsWithRef<AsTarget> : {}, ForwardedAsTargetProps extends BaseObject = ForwardedAsTarget extends KnownTarget ? React.ComponentPropsWithRef<ForwardedAsTarget> : {}> = OverrideStyle<NoInfer<FastOmit<Substitute<BaseProps, Substitute<ForwardedAsTargetProps, AsTargetProps>>, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
+export type PolymorphicComponentProps<R extends Runtime, BaseProps extends BaseObject, AsTarget extends StyledTarget<R> | (BaseProps extends {
+    as?: infer A;
+} ? A : never) | void, ForwardedAsTarget extends StyledTarget<R> | void, AsTargetProps extends BaseObject = AsTarget extends KnownTarget ? React.ComponentPropsWithRef<AsTarget> : {}, ForwardedAsTargetProps extends BaseObject = ForwardedAsTarget extends KnownTarget ? React.ComponentPropsWithRef<ForwardedAsTarget> : {}> = OverrideStyle<NoInfer<FastOmit<Substitute<BaseProps, Substitute<ForwardedAsTargetProps, AsTargetProps>>, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
     as?: AsTarget;
     forwardedAs?: ForwardedAsTarget;
 }>;
+/**
+ * Resolves the call-site props for one usage of a polymorphic component,
+ * branching on the supplied `as` / `forwardedAs` targets into the three prior
+ * overload shapes:
+ *  - `as` is a real render target (e.g. `as="video"`, `as={Component}`):
+ *    substitute that target's props and require `as`.
+ *  - no `as`, or `as` is the wrapped component's own non-target type (e.g.
+ *    Next.js Link's `as?: Url`): Substitute-free base props so ref callbacks
+ *    infer with spread props (#5687), the wrapped `as` type stays assignable and
+ *    optional (#5734), and BaseProps keys keep completing for plain usage (#5741).
+ *  - `forwardedAs` only: substitute the forwarded target's props.
+ *
+ * Extracted to a named alias so identical (R, BaseProps, AsTarget,
+ * ForwardedAsTarget) tuples dedupe across the many JSX call sites in an app.
+ *
+ * The target test is `string | AnyComponent`, not the broader `WebTarget`
+ * (`KnownTarget | (string & {})`): both describe the same set (any string or
+ * component), but comparing against the ~156 literal members of `KnownTarget`
+ * here costs ~6% more type instantiations across all call sites. Don't narrow it
+ * to bare `KnownTarget` -- that drops custom element strings (`as="my-element"`)
+ * out of the target branch and makes them error.
+ */
+type PolymorphicCallProps<R extends Runtime, BaseProps extends BaseObject, AsTarget extends StyledTarget<R> | (BaseProps extends {
+    as?: infer A;
+} ? A : never) | void, ForwardedAsTarget extends StyledTarget<R> | void> = [AsTarget] extends [string | AnyComponent] ? PolymorphicComponentProps<R, BaseProps, AsTarget, ForwardedAsTarget> & {
+    as: AsTarget;
+} : [ForwardedAsTarget] extends [void] ? OverrideStyle<NoInfer<FastOmit<BaseProps, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
+    as?: BaseProps extends {
+        as?: infer A;
+    } ? A : void;
+    forwardedAs?: BaseProps extends {
+        forwardedAs?: infer A;
+    } ? A : void;
+}> : PolymorphicComponentProps<R, BaseProps, void, ForwardedAsTarget> & {
+    forwardedAs: ForwardedAsTarget;
+};
 /**
  * This type forms the signature for a forwardRef-enabled component
  * that accepts the "as" prop to dynamically change the underlying
@@ -136,22 +174,32 @@ export interface PolymorphicComponent<out R extends Runtime, in out BaseProps ex
     as?: StyledTarget<R> | undefined;
     forwardedAs?: StyledTarget<R> | undefined;
 }> {
-    (props: OverrideStyle<NoInfer<FastOmit<BaseProps, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
-        as?: BaseProps extends {
-            as?: infer A;
-        } ? A : void;
-        forwardedAs?: BaseProps extends {
-            forwardedAs?: infer A;
-        } ? A : void;
-    }>): React.JSX.Element;
-    <AsTarget extends StyledTarget<R>, ForwardedAsTarget extends StyledTarget<R> | void = void>(props: PolymorphicComponentProps<R, BaseProps, AsTarget, ForwardedAsTarget> & {
-        as: AsTarget;
-    }): React.JSX.Element;
-    <ForwardedAsTarget extends StyledTarget<R>>(props: PolymorphicComponentProps<R, BaseProps, void, ForwardedAsTarget> & {
-        forwardedAs: ForwardedAsTarget;
-    }): React.JSX.Element;
-}
-export interface IStyledComponentBase<out R extends Runtime, in out Props extends BaseObject = BaseObject> extends PolymorphicComponent<R, Props>, IStyledStatics<R, Props>, StyledComponentBrand {
+    <AsTarget extends StyledTarget<R> | (BaseProps extends {
+        as?: infer A;
+    } ? A : never) | void = void, ForwardedAsTarget extends StyledTarget<R> | void = void>(props: PolymorphicCallProps<R, BaseProps, AsTarget, ForwardedAsTarget>): React.JSX.Element;
+}
+/**
+ * Some wrapped targets can't be statically introspected and their props
+ * collapse to `{}` -- most notably polymorphic-factory components (e.g. Mantine
+ * v7's `Button`, `Card`, `Menu.Item`), whose generic callable signature defeats
+ * `React.ComponentPropsWithRef`. A closed `{}` would reject every prop at the JSX
+ * call site, including `children`. Falling back to a permissive prop bag keeps
+ * these components usable; targets with introspectable props are unchanged.
+ *
+ * Applied only to the JSX call surface (`PolymorphicComponent`), never to the
+ * statics (`IStyledStatics`, `defaultProps`), so internal code keeps the real
+ * `Props` and the widening can't leak past the call site.
+ *
+ * The "no known keys" test is distributed over `Props` first. `keyof` on a union
+ * intersects each member's keys, so a bare union of disjoint shapes (e.g.
+ * `{ a: string } | { b: string }`) has `keyof` of `never` despite being fully
+ * introspectable. Checking each constituent independently widens only when every
+ * member is truly empty.
+ */
+export type WidenUntypedProps<Props extends BaseObject> = (Props extends unknown ? (keyof Props extends never ? true : false) : never) extends true ? Props & {
+    [key: string]: unknown;
+} : Props;
+export interface IStyledComponentBase<out R extends Runtime, in out Props extends BaseObject = BaseObject> extends PolymorphicComponent<R, WidenUntypedProps<Props>>, IStyledStatics<R, Props>, StyledComponentBrand {
     defaultProps?: (ExecutionProps & Partial<Props>) | undefined;
     toString: () => string;
 }

package/native/dist/constructors/constructWithOptions.d.ts

@@ -1,4 +1,4 @@
-import { Attrs, BaseObject, ExecutionProps, Interpolation, IStyledComponent, IStyledComponentFactory, KnownTarget, MakeAttrsOptional, Runtime, StyledOptions, StyledTarget, Styles, Substitute } from '../types';
+import { Attrs, BaseObject, ExecutionProps, Interpolation, IStyledComponent, IStyledComponentFactory, KnownTarget, MakeAttrsOptional, Runtime, StyledOptions, StyledTarget, Styles, Substitute, WidenUntypedProps } from '../types';
 type AttrsResult<T extends Attrs<any>> = T extends (...args: any) => infer P ? P extends object ? P : never : T extends object ? T : never;
 /**
  * Based on Attrs being a simple object or function that returns
@@ -10,7 +10,7 @@ type AttrsTarget<R extends Runtime, T extends Attrs<any>, FallbackTarget extends
 } ? RuntimeTarget extends KnownTarget ? RuntimeTarget : FallbackTarget : FallbackTarget;
 export interface Styled<out R extends Runtime, out Target extends StyledTarget<R>, in out OuterProps extends object, out OuterStatics extends object = BaseObject, out AttrsKeys extends keyof any = never> {
     <Props extends object = BaseObject, Statics extends object = BaseObject>(initialStyles: Styles<Substitute<OuterProps, NoInfer<Props>>>, ...interpolations: Interpolation<Substitute<OuterProps, NoInfer<Props>>>[]): IStyledComponent<R, MakeAttrsOptional<Substitute<OuterProps, Props>, AttrsKeys>> & OuterStatics & Statics & (R extends 'web' ? Target extends string ? {} : Omit<Target, keyof React.Component<any>> : {});
-    attrs: <Props extends object = BaseObject, PrivateMergedProps extends object = Substitute<OuterProps, Props>, PrivateAttrsArg extends Attrs<PrivateMergedProps> = Attrs<PrivateMergedProps>, PrivateResolvedTarget extends StyledTarget<R> = AttrsTarget<R, PrivateAttrsArg, Target>>(attrs: PrivateAttrsArg) => Styled<R, PrivateResolvedTarget, PrivateResolvedTarget extends KnownTarget ? Substitute<Substitute<OuterProps, React.ComponentPropsWithRef<PrivateResolvedTarget>>, Props> : PrivateMergedProps, OuterStatics, AttrsKeys | keyof AttrsResult<PrivateAttrsArg>>;
+    attrs: <Props extends object = BaseObject, PrivateMergedProps extends object = Substitute<OuterProps, Props>, PrivateAttrsArg extends Attrs<WidenUntypedProps<PrivateMergedProps>> = Attrs<WidenUntypedProps<PrivateMergedProps>>, PrivateResolvedTarget extends StyledTarget<R> = AttrsTarget<R, PrivateAttrsArg, Target>>(attrs: PrivateAttrsArg) => Styled<R, PrivateResolvedTarget, PrivateResolvedTarget extends KnownTarget ? Substitute<Substitute<OuterProps, React.ComponentPropsWithRef<PrivateResolvedTarget>>, Props> : PrivateMergedProps, OuterStatics, AttrsKeys | keyof AttrsResult<PrivateAttrsArg>>;
     withConfig: (config: StyledOptions<R, OuterProps>) => Styled<R, Target, OuterProps, OuterStatics, AttrsKeys>;
 }
 export default function constructWithOptions<R extends Runtime, Target extends StyledTarget<R>, OuterProps extends object = Target extends KnownTarget ? React.ComponentPropsWithRef<Target> : BaseObject, OuterStatics extends object = BaseObject, AttrsKeys extends keyof any = never>(componentConstructor: IStyledComponentFactory<R, StyledTarget<R>, object, any>, tag: StyledTarget<R>, options?: StyledOptions<R, OuterProps>): Styled<R, Target, OuterProps, OuterStatics, AttrsKeys>;

package/native/dist/dist/constructors/constructWithOptions.d.ts

@@ -1,4 +1,4 @@
-import { Attrs, BaseObject, ExecutionProps, Interpolation, IStyledComponent, IStyledComponentFactory, KnownTarget, MakeAttrsOptional, Runtime, StyledOptions, StyledTarget, Styles, Substitute } from '../types';
+import { Attrs, BaseObject, ExecutionProps, Interpolation, IStyledComponent, IStyledComponentFactory, KnownTarget, MakeAttrsOptional, Runtime, StyledOptions, StyledTarget, Styles, Substitute, WidenUntypedProps } from '../types';
 type AttrsResult<T extends Attrs<any>> = T extends (...args: any) => infer P ? P extends object ? P : never : T extends object ? T : never;
 /**
  * Based on Attrs being a simple object or function that returns
@@ -10,7 +10,7 @@ type AttrsTarget<R extends Runtime, T extends Attrs<any>, FallbackTarget extends
 } ? RuntimeTarget extends KnownTarget ? RuntimeTarget : FallbackTarget : FallbackTarget;
 export interface Styled<out R extends Runtime, out Target extends StyledTarget<R>, in out OuterProps extends object, out OuterStatics extends object = BaseObject, out AttrsKeys extends keyof any = never> {
     <Props extends object = BaseObject, Statics extends object = BaseObject>(initialStyles: Styles<Substitute<OuterProps, NoInfer<Props>>>, ...interpolations: Interpolation<Substitute<OuterProps, NoInfer<Props>>>[]): IStyledComponent<R, MakeAttrsOptional<Substitute<OuterProps, Props>, AttrsKeys>> & OuterStatics & Statics & (R extends 'web' ? Target extends string ? {} : Omit<Target, keyof React.Component<any>> : {});
-    attrs: <Props extends object = BaseObject, PrivateMergedProps extends object = Substitute<OuterProps, Props>, PrivateAttrsArg extends Attrs<PrivateMergedProps> = Attrs<PrivateMergedProps>, PrivateResolvedTarget extends StyledTarget<R> = AttrsTarget<R, PrivateAttrsArg, Target>>(attrs: PrivateAttrsArg) => Styled<R, PrivateResolvedTarget, PrivateResolvedTarget extends KnownTarget ? Substitute<Substitute<OuterProps, React.ComponentPropsWithRef<PrivateResolvedTarget>>, Props> : PrivateMergedProps, OuterStatics, AttrsKeys | keyof AttrsResult<PrivateAttrsArg>>;
+    attrs: <Props extends object = BaseObject, PrivateMergedProps extends object = Substitute<OuterProps, Props>, PrivateAttrsArg extends Attrs<WidenUntypedProps<PrivateMergedProps>> = Attrs<WidenUntypedProps<PrivateMergedProps>>, PrivateResolvedTarget extends StyledTarget<R> = AttrsTarget<R, PrivateAttrsArg, Target>>(attrs: PrivateAttrsArg) => Styled<R, PrivateResolvedTarget, PrivateResolvedTarget extends KnownTarget ? Substitute<Substitute<OuterProps, React.ComponentPropsWithRef<PrivateResolvedTarget>>, Props> : PrivateMergedProps, OuterStatics, AttrsKeys | keyof AttrsResult<PrivateAttrsArg>>;
     withConfig: (config: StyledOptions<R, OuterProps>) => Styled<R, Target, OuterProps, OuterStatics, AttrsKeys>;
 }
 export default function constructWithOptions<R extends Runtime, Target extends StyledTarget<R>, OuterProps extends object = Target extends KnownTarget ? React.ComponentPropsWithRef<Target> : BaseObject, OuterStatics extends object = BaseObject, AttrsKeys extends keyof any = never>(componentConstructor: IStyledComponentFactory<R, StyledTarget<R>, object, any>, tag: StyledTarget<R>, options?: StyledOptions<R, OuterProps>): Styled<R, Target, OuterProps, OuterStatics, AttrsKeys>;

package/native/dist/dist/types.d.ts

@@ -121,10 +121,48 @@ export interface IStyledStatics<out R extends Runtime, in out OuterProps extends
 /**
  * Used by PolymorphicComponent to define prop override cascading order.
  */
-export type PolymorphicComponentProps<R extends Runtime, BaseProps extends BaseObject, AsTarget extends StyledTarget<R> | void, ForwardedAsTarget extends StyledTarget<R> | void, AsTargetProps extends BaseObject = AsTarget extends KnownTarget ? React.ComponentPropsWithRef<AsTarget> : {}, ForwardedAsTargetProps extends BaseObject = ForwardedAsTarget extends KnownTarget ? React.ComponentPropsWithRef<ForwardedAsTarget> : {}> = OverrideStyle<NoInfer<FastOmit<Substitute<BaseProps, Substitute<ForwardedAsTargetProps, AsTargetProps>>, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
+export type PolymorphicComponentProps<R extends Runtime, BaseProps extends BaseObject, AsTarget extends StyledTarget<R> | (BaseProps extends {
+    as?: infer A;
+} ? A : never) | void, ForwardedAsTarget extends StyledTarget<R> | void, AsTargetProps extends BaseObject = AsTarget extends KnownTarget ? React.ComponentPropsWithRef<AsTarget> : {}, ForwardedAsTargetProps extends BaseObject = ForwardedAsTarget extends KnownTarget ? React.ComponentPropsWithRef<ForwardedAsTarget> : {}> = OverrideStyle<NoInfer<FastOmit<Substitute<BaseProps, Substitute<ForwardedAsTargetProps, AsTargetProps>>, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
     as?: AsTarget;
     forwardedAs?: ForwardedAsTarget;
 }>;
+/**
+ * Resolves the call-site props for one usage of a polymorphic component,
+ * branching on the supplied `as` / `forwardedAs` targets into the three prior
+ * overload shapes:
+ *  - `as` is a real render target (e.g. `as="video"`, `as={Component}`):
+ *    substitute that target's props and require `as`.
+ *  - no `as`, or `as` is the wrapped component's own non-target type (e.g.
+ *    Next.js Link's `as?: Url`): Substitute-free base props so ref callbacks
+ *    infer with spread props (#5687), the wrapped `as` type stays assignable and
+ *    optional (#5734), and BaseProps keys keep completing for plain usage (#5741).
+ *  - `forwardedAs` only: substitute the forwarded target's props.
+ *
+ * Extracted to a named alias so identical (R, BaseProps, AsTarget,
+ * ForwardedAsTarget) tuples dedupe across the many JSX call sites in an app.
+ *
+ * The target test is `string | AnyComponent`, not the broader `WebTarget`
+ * (`KnownTarget | (string & {})`): both describe the same set (any string or
+ * component), but comparing against the ~156 literal members of `KnownTarget`
+ * here costs ~6% more type instantiations across all call sites. Don't narrow it
+ * to bare `KnownTarget` -- that drops custom element strings (`as="my-element"`)
+ * out of the target branch and makes them error.
+ */
+type PolymorphicCallProps<R extends Runtime, BaseProps extends BaseObject, AsTarget extends StyledTarget<R> | (BaseProps extends {
+    as?: infer A;
+} ? A : never) | void, ForwardedAsTarget extends StyledTarget<R> | void> = [AsTarget] extends [string | AnyComponent] ? PolymorphicComponentProps<R, BaseProps, AsTarget, ForwardedAsTarget> & {
+    as: AsTarget;
+} : [ForwardedAsTarget] extends [void] ? OverrideStyle<NoInfer<FastOmit<BaseProps, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
+    as?: BaseProps extends {
+        as?: infer A;
+    } ? A : void;
+    forwardedAs?: BaseProps extends {
+        forwardedAs?: infer A;
+    } ? A : void;
+}> : PolymorphicComponentProps<R, BaseProps, void, ForwardedAsTarget> & {
+    forwardedAs: ForwardedAsTarget;
+};
 /**
  * This type forms the signature for a forwardRef-enabled component
  * that accepts the "as" prop to dynamically change the underlying
@@ -136,22 +174,32 @@ export interface PolymorphicComponent<out R extends Runtime, in out BaseProps ex
     as?: StyledTarget<R> | undefined;
     forwardedAs?: StyledTarget<R> | undefined;
 }> {
-    (props: OverrideStyle<NoInfer<FastOmit<BaseProps, keyof ExecutionProps>> & FastOmit<ExecutionProps, 'as' | 'forwardedAs'> & {
-        as?: BaseProps extends {
-            as?: infer A;
-        } ? A : void;
-        forwardedAs?: BaseProps extends {
-            forwardedAs?: infer A;
-        } ? A : void;
-    }>): React.JSX.Element;
-    <AsTarget extends StyledTarget<R>, ForwardedAsTarget extends StyledTarget<R> | void = void>(props: PolymorphicComponentProps<R, BaseProps, AsTarget, ForwardedAsTarget> & {
-        as: AsTarget;
-    }): React.JSX.Element;
-    <ForwardedAsTarget extends StyledTarget<R>>(props: PolymorphicComponentProps<R, BaseProps, void, ForwardedAsTarget> & {
-        forwardedAs: ForwardedAsTarget;
-    }): React.JSX.Element;
-}
-export interface IStyledComponentBase<out R extends Runtime, in out Props extends BaseObject = BaseObject> extends PolymorphicComponent<R, Props>, IStyledStatics<R, Props>, StyledComponentBrand {
+    <AsTarget extends StyledTarget<R> | (BaseProps extends {
+        as?: infer A;
+    } ? A : never) | void = void, ForwardedAsTarget extends StyledTarget<R> | void = void>(props: PolymorphicCallProps<R, BaseProps, AsTarget, ForwardedAsTarget>): React.JSX.Element;
+}
+/**
+ * Some wrapped targets can't be statically introspected and their props
+ * collapse to `{}` -- most notably polymorphic-factory components (e.g. Mantine
+ * v7's `Button`, `Card`, `Menu.Item`), whose generic callable signature defeats
+ * `React.ComponentPropsWithRef`. A closed `{}` would reject every prop at the JSX
+ * call site, including `children`. Falling back to a permissive prop bag keeps
+ * these components usable; targets with introspectable props are unchanged.
+ *
+ * Applied only to the JSX call surface (`PolymorphicComponent`), never to the
+ * statics (`IStyledStatics`, `defaultProps`), so internal code keeps the real
+ * `Props` and the widening can't leak past the call site.
+ *
+ * The "no known keys" test is distributed over `Props` first. `keyof` on a union
+ * intersects each member's keys, so a bare union of disjoint shapes (e.g.
+ * `{ a: string } | { b: string }`) has `keyof` of `never` despite being fully
+ * introspectable. Checking each constituent independently widens only when every
+ * member is truly empty.
+ */
+export type WidenUntypedProps<Props extends BaseObject> = (Props extends unknown ? (keyof Props extends never ? true : false) : never) extends true ? Props & {
+    [key: string]: unknown;
+} : Props;
+export interface IStyledComponentBase<out R extends Runtime, in out Props extends BaseObject = BaseObject> extends PolymorphicComponent<R, WidenUntypedProps<Props>>, IStyledStatics<R, Props>, StyledComponentBrand {
     defaultProps?: (ExecutionProps & Partial<Props>) | undefined;
     toString: () => string;
 }