@allxsmith/bestax-bulma 5.16.7 → 5.16.8

package/dist/types/components/Avatar.d.ts

@@ -32,11 +32,11 @@ export interface AvatarOwnProps extends Omit<BulmaClassesProps, 'color'> {
     shape?: AvatarShape;
     /** Background color for initials/icon avatars (else auto-derived from `name`). */
     color?: AvatarColor;
-    /** When set, renders the avatar as a link. */
+    /** When set, renders the avatar as a link: an `<a>` unless `as` names the element itself. An `as` target declaring its own `href` supersedes this one, and its type and its requiredness are what apply. */
     href?: string;
-    /** Anchor target — forwarded only when rendering a link (an `a` or a custom `as` component). */
+    /** Anchor target — forwarded only when rendering a link (an `a` or a custom `as` component), and superseded by the target's own declaration the way `href` is. */
     target?: string;
-    /** Anchor rel — forwarded only when rendering a link (an `a` or a custom `as` component). */
+    /** Anchor rel — forwarded only when rendering a link (an `a` or a custom `as` component), and superseded by the target's own declaration the way `href` is. */
     rel?: string;
     /** Extra props forwarded to the underlying `<img>` (e.g. `loading`, `crossOrigin`); its `onError` is chained before the fallback fires. */
     imageProps?: React.ImgHTMLAttributes<HTMLImageElement>;
@@ -51,14 +51,23 @@ export interface AvatarOwnProps extends Omit<BulmaClassesProps, 'color'> {
      */
     children?: never;
 }
+/**
+ * The own props Avatar hands to the element `as` names rather than consuming.
+ *
+ * They are what *chooses* the element when `as` is absent — an `<a>` with an
+ * `href`, a `<figure>` without one — so Avatar has to accept them before `as` is
+ * known. Declaring them is only half of it. `PolymorphicProps` explains what
+ * naming them here buys, and what leaving them unnamed cost (#665).
+ */
+type AvatarForwardedProp = 'href' | 'target' | 'rel';
 /**
  * Props for the Avatar component. The DOM attributes and the `ref` both follow
  * `as`.
  *
- * `href`, `target` and `rel` stay Avatar's own props rather than being derived:
- * they are what *chooses* the element when `as` is absent (an `<a>` with an
- * `href`, a `<figure>` without one), so they have to be accepted before `as` is
- * known.
+ * `href`, `target` and `rel` are Avatar's own props only for a target that has
+ * none of its own: `<Avatar href="/x" />` needs no `as`, while
+ * `<Avatar as={NextLink} />` takes `next/link`'s `href` — required, and a URL
+ * object as readily as a string.
  *
  * The type parameter defaults to `'figure'`, not to `React.ElementType`.
  * Defaulting to the constraint sounds truer to a runtime default that is
@@ -70,7 +79,7 @@ export interface AvatarOwnProps extends Omit<BulmaClassesProps, 'color'> {
  *
  * @extraProp {PolymorphicRef<React.ElementType>} [ref] - Ref forwarded to the element `as` renders, typed from `as`: the DOM node for an intrinsic tag, or whatever handle a custom component exposes.
  */
-export type AvatarProps<T extends React.ElementType = 'figure'> = AvatarOwnProps & Omit<React.ComponentPropsWithoutRef<T>, keyof AvatarOwnProps | 'as'> & {
+export type AvatarProps<T extends React.ElementType = 'figure'> = Omit<AvatarOwnProps, Extract<AvatarForwardedProp, keyof React.ComponentPropsWithoutRef<T>>> & Omit<React.ComponentPropsWithoutRef<T>, Exclude<keyof AvatarOwnProps, AvatarForwardedProp> | 'as'> & {
     /** Element/component to render as. Defaults to `'a'` when `href` is set, else `'figure'`. */
     as?: T;
 };
@@ -87,5 +96,5 @@ export type AvatarProps<T extends React.ElementType = 'figure'> = AvatarOwnProps
  * @example
  * <Avatar name="Grace Hopper" />
  */
-export declare const Avatar: PolymorphicComponent<AvatarOwnProps, "figure">;
+export declare const Avatar: PolymorphicComponent<AvatarOwnProps, "figure", AvatarForwardedProp>;
 export default Avatar;

package/dist/types/components/Avatars.d.ts

@@ -25,6 +25,6 @@ export interface AvatarsProps extends Omit<React.HTMLAttributes<HTMLDivElement>,
     children?: React.ReactNode;
 }
 export declare const Avatars: React.FC<AvatarsProps> & {
-    Avatar: import("../index.js").PolymorphicComponent<import("./Avatar.js").AvatarOwnProps, "figure">;
+    Avatar: import("../index.js").PolymorphicComponent<import("./Avatar.js").AvatarOwnProps, "figure", "rel" | "href" | "target">;
 };
 export default Avatars;

package/dist/types/components/Dropdown.d.ts

@@ -98,7 +98,7 @@ export declare const DropdownItem: ConstrainedPolymorphicComponentWithoutRef<Dro
 export declare const DropdownDivider: React.FC;
 /** Bulma Dropdown component with Item and Divider sub-components. */
 export declare const Dropdown: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLDivElement>> & {
-    Item: ConstrainedPolymorphicComponentWithoutRef<DropdownItemOwnProps, DropdownItemElement, "a">;
+    Item: ConstrainedPolymorphicComponentWithoutRef<DropdownItemOwnProps, DropdownItemElement, "a", never>;
     Divider: React.FC<{}>;
 };
 export default Dropdown;

package/dist/types/components/Menu.d.ts

@@ -95,6 +95,6 @@ export declare const MenuItem: PolymorphicComponent<MenuItemOwnProps, "a">;
 export declare const Menu: React.FC<MenuProps> & {
     Label: React.FC<MenuLabelProps>;
     List: React.FC<MenuListProps>;
-    Item: PolymorphicComponent<MenuItemOwnProps, "a">;
+    Item: PolymorphicComponent<MenuItemOwnProps, "a", never>;
 };
 export default Menu;

package/dist/types/components/Navbar.d.ts

@@ -289,8 +289,8 @@ export declare const NavbarDropdownMenu: React.FC<NavbarDropdownMenuProps>;
 export declare const NavbarDivider: React.FC<React.HTMLAttributes<HTMLHRElement>>;
 export declare const Navbar: React.ForwardRefExoticComponent<NavbarProps & React.RefAttributes<HTMLElement>> & {
     Brand: React.FC<NavbarBrandProps>;
-    Item: PolymorphicComponent<NavbarItemOwnProps, "a">;
-    Link: PolymorphicComponent<NavbarLinkOwnProps, "a">;
+    Item: PolymorphicComponent<NavbarItemOwnProps, "a", never>;
+    Link: PolymorphicComponent<NavbarLinkOwnProps, "a", never>;
     Burger: React.ForwardRefExoticComponent<NavbarBurgerProps & React.RefAttributes<HTMLButtonElement>>;
     Menu: React.FC<NavbarMenuProps>;
     Start: React.FC<NavbarStartEndProps>;

package/dist/types/elements/Buttons.d.ts

@@ -34,7 +34,7 @@ interface ButtonsProps extends React.HTMLAttributes<HTMLDivElement>, Omit<BulmaC
     children: React.ReactNode;
 }
 export declare const Buttons: React.FC<ButtonsProps> & {
-    Button: import("../index.js").PolymorphicComponent<import("./Button.js").ButtonOwnProps, "button">;
-    LinkButton: import("../index.js").PolymorphicComponent<import("./LinkButton.js").LinkButtonOwnProps, "button">;
+    Button: import("../index.js").PolymorphicComponent<import("./Button.js").ButtonOwnProps, "button", never>;
+    LinkButton: import("../index.js").PolymorphicComponent<import("./LinkButton.js").LinkButtonOwnProps, "button", never>;
 };
 export {};

package/dist/types/helpers/polymorphic.d.ts

@@ -29,14 +29,44 @@ export type PolymorphicRef<T extends React.ElementType> = 'ref' extends keyof Re
 /**
  * A component's own props, plus the attributes of the element `as` names.
  *
- * `Own` wins every collision — a component that declares `color` as a Bulma
- * variant keeps it, rather than inheriting the DOM attribute of the same name.
- * That subtraction is the ONLY one. `color` used to be dropped here as well, to
- * stop the deprecated presentational HTML attribute reaching the three
- * components whose own props do not declare one — but doing it in the shared
- * type also stripped `color` from a CUSTOM target that legitimately has one.
- * Those three declare `color?: never` themselves instead, which lands in
- * `keyof Own` and reaches the same result without a special case here.
+ * `Own` wins a collision by default — a component that declares
+ * `color` as a Bulma variant keeps it, rather than inheriting the DOM attribute
+ * of the same name. `color` used to be dropped here as well, to stop the
+ * deprecated presentational HTML attribute reaching the components whose own
+ * props do not declare one — but doing it in the shared type also stripped
+ * `color` from a CUSTOM target that legitimately has one. Those components
+ * declare `color?: never` themselves instead, which lands in `keyof Own` and
+ * reaches the same result without a special case here.
+ *
+ * `Forwarded` names the own props the component hands STRAIGHT to the target
+ * instead of consuming, and the subtraction runs the other way for them: the
+ * TARGET's declaration wins, and the own one is what covers a target that has
+ * no such prop. Subtracting them threw the target's declaration away, so an
+ * OPTIONAL own prop hid a REQUIRED one — `<Avatar as={NextLink} name="Ada" />`
+ * compiled because Avatar's `href?: string` survived while `next/link`'s
+ * required `href` was omitted, and the target threw on what it never received
+ * (#665). The target wins rather than both declarations applying at once,
+ * because for a prop the component only passes along its own type has no
+ * standing: `next/link` accepts a URL object as well as a string, and
+ * intersecting Avatar's `string` with that would refuse the object.
+ *
+ * `Forwarded` defaults to `never`, so a prop the component CONSUMES stays
+ * subtracted — the common case, and the one `color` needs. What that costs is
+ * that a target REQUIRING a consumed prop is still satisfiable with the prop
+ * omitted, and the value goes wherever the component sends it: `Menu.Item`
+ * spends several of its own props on its wrapping `<li>`, `title` and `style`
+ * among them, so a target requiring one of those never sees it. Erroring on
+ * that needs a category this pair cannot express, since `className` is consumed
+ * too and yet every component composes one and passes it on. It is pinned as a
+ * limitation in `__typetests__/polymorphic.tsx` rather than guessed at here.
+ *
+ * `Own` is returned untouched when nothing is forwarded, rather than run through
+ * an `Omit` that names no keys. `Omit` is not the identity it looks like: it
+ * keys off `keyof Own`, which for a UNION `Own` is only what the members share,
+ * so `PolymorphicProps<'div', A | B>` lost every prop of both. It is public API
+ * and a consumer's wrapper can pass a union; the untouched branch also keeps
+ * each own prop's TSDoc reaching an IDE, which a mapped type drops. The
+ * forwarded branch distributes over `Own` for the same reason.
  *
  * Distributive over `T` on purpose. `Omit<A | B, K>` keys off `keyof (A | B)`,
  * which is only what A and B share — so a union-typed `as` (a ternary, or a
@@ -51,7 +81,7 @@ export type PolymorphicRef<T extends React.ElementType> = 'ref' extends keyof Re
  * This type is here for the component's cast target and for consumers writing
  * wrappers.
  */
-export type PolymorphicProps<T extends React.ElementType, Own> = T extends unknown ? Own & Omit<React.ComponentPropsWithoutRef<T>, keyof Own | 'as'> & {
+export type PolymorphicProps<T extends React.ElementType, Own, Forwarded extends keyof Own = never> = T extends unknown ? ([Forwarded] extends [never] ? Own : Own extends unknown ? Omit<Own, Extract<Forwarded, keyof React.ComponentPropsWithoutRef<T>>> : never) & Omit<React.ComponentPropsWithoutRef<T>, Exclude<keyof Own, Forwarded> | 'as'> & {
     /** The element or component to render. */
     as?: T;
 } : never;
@@ -86,11 +116,11 @@ export type PolymorphicProps<T extends React.ElementType, Own> = T extends unkno
  * const MemoButton = React.memo(Button) as typeof Button;
  * ```
  */
-export interface PolymorphicComponent<Own, Default extends React.ElementType> {
-    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own> & {
+export interface PolymorphicComponent<Own, Default extends React.ElementType, Forwarded extends keyof Own = never> {
+    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own, Forwarded> & {
         ref?: PolymorphicRef<T>;
     }): React.ReactElement | null;
-    (props: PolymorphicProps<Default, Own> & {
+    (props: PolymorphicProps<Default, Own, Forwarded> & {
         ref?: PolymorphicRef<Default>;
     }): React.ReactElement | null;
     displayName?: string;
@@ -101,10 +131,14 @@ export interface PolymorphicComponent<Own, Default extends React.ElementType> {
  * For components that own the node they observe — `Reveal` keeps its own ref on
  * the element it watches for scroll intersection, which is not always the
  * element `as` names.
+ *
+ * It carries `Forwarded` even with no component passing one today: the default
+ * is the behaviour without it, and a component that grows a forwarded own prop
+ * would otherwise reintroduce #665 here with nothing to say so.
  */
-export interface PolymorphicComponentWithoutRef<Own, Default extends React.ElementType> {
-    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own>): React.ReactElement | null;
-    (props: PolymorphicProps<Default, Own>): React.ReactElement | null;
+export interface PolymorphicComponentWithoutRef<Own, Default extends React.ElementType, Forwarded extends keyof Own = never> {
+    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own, Forwarded>): React.ReactElement | null;
+    (props: PolymorphicProps<Default, Own, Forwarded>): React.ReactElement | null;
     displayName?: string;
 }
 /**
@@ -131,8 +165,8 @@ export interface PolymorphicComponentWithoutRef<Own, Default extends React.Eleme
  * than losing every prop the members do not share. Narrowing it is not a
  * constrained-component question; it would have to change for `Button` first.
  */
-export interface ConstrainedPolymorphicComponentWithoutRef<Own, Allowed extends React.ElementType, Default extends Allowed> {
-    <T extends Allowed = Default>(props: PolymorphicProps<T, Own>): React.ReactElement | null;
-    (props: PolymorphicProps<Default, Own>): React.ReactElement | null;
+export interface ConstrainedPolymorphicComponentWithoutRef<Own, Allowed extends React.ElementType, Default extends Allowed, Forwarded extends keyof Own = never> {
+    <T extends Allowed = Default>(props: PolymorphicProps<T, Own, Forwarded>): React.ReactElement | null;
+    (props: PolymorphicProps<Default, Own, Forwarded>): React.ReactElement | null;
     displayName?: string;
 }

package/dist/types-cjs/components/Avatar.d.ts

@@ -32,11 +32,11 @@ export interface AvatarOwnProps extends Omit<BulmaClassesProps, 'color'> {
     shape?: AvatarShape;
     /** Background color for initials/icon avatars (else auto-derived from `name`). */
     color?: AvatarColor;
-    /** When set, renders the avatar as a link. */
+    /** When set, renders the avatar as a link: an `<a>` unless `as` names the element itself. An `as` target declaring its own `href` supersedes this one, and its type and its requiredness are what apply. */
     href?: string;
-    /** Anchor target — forwarded only when rendering a link (an `a` or a custom `as` component). */
+    /** Anchor target — forwarded only when rendering a link (an `a` or a custom `as` component), and superseded by the target's own declaration the way `href` is. */
     target?: string;
-    /** Anchor rel — forwarded only when rendering a link (an `a` or a custom `as` component). */
+    /** Anchor rel — forwarded only when rendering a link (an `a` or a custom `as` component), and superseded by the target's own declaration the way `href` is. */
     rel?: string;
     /** Extra props forwarded to the underlying `<img>` (e.g. `loading`, `crossOrigin`); its `onError` is chained before the fallback fires. */
     imageProps?: React.ImgHTMLAttributes<HTMLImageElement>;
@@ -51,14 +51,23 @@ export interface AvatarOwnProps extends Omit<BulmaClassesProps, 'color'> {
      */
     children?: never;
 }
+/**
+ * The own props Avatar hands to the element `as` names rather than consuming.
+ *
+ * They are what *chooses* the element when `as` is absent — an `<a>` with an
+ * `href`, a `<figure>` without one — so Avatar has to accept them before `as` is
+ * known. Declaring them is only half of it. `PolymorphicProps` explains what
+ * naming them here buys, and what leaving them unnamed cost (#665).
+ */
+type AvatarForwardedProp = 'href' | 'target' | 'rel';
 /**
  * Props for the Avatar component. The DOM attributes and the `ref` both follow
  * `as`.
  *
- * `href`, `target` and `rel` stay Avatar's own props rather than being derived:
- * they are what *chooses* the element when `as` is absent (an `<a>` with an
- * `href`, a `<figure>` without one), so they have to be accepted before `as` is
- * known.
+ * `href`, `target` and `rel` are Avatar's own props only for a target that has
+ * none of its own: `<Avatar href="/x" />` needs no `as`, while
+ * `<Avatar as={NextLink} />` takes `next/link`'s `href` — required, and a URL
+ * object as readily as a string.
  *
  * The type parameter defaults to `'figure'`, not to `React.ElementType`.
  * Defaulting to the constraint sounds truer to a runtime default that is
@@ -70,7 +79,7 @@ export interface AvatarOwnProps extends Omit<BulmaClassesProps, 'color'> {
  *
  * @extraProp {PolymorphicRef<React.ElementType>} [ref] - Ref forwarded to the element `as` renders, typed from `as`: the DOM node for an intrinsic tag, or whatever handle a custom component exposes.
  */
-export type AvatarProps<T extends React.ElementType = 'figure'> = AvatarOwnProps & Omit<React.ComponentPropsWithoutRef<T>, keyof AvatarOwnProps | 'as'> & {
+export type AvatarProps<T extends React.ElementType = 'figure'> = Omit<AvatarOwnProps, Extract<AvatarForwardedProp, keyof React.ComponentPropsWithoutRef<T>>> & Omit<React.ComponentPropsWithoutRef<T>, Exclude<keyof AvatarOwnProps, AvatarForwardedProp> | 'as'> & {
     /** Element/component to render as. Defaults to `'a'` when `href` is set, else `'figure'`. */
     as?: T;
 };
@@ -87,5 +96,5 @@ export type AvatarProps<T extends React.ElementType = 'figure'> = AvatarOwnProps
  * @example
  * <Avatar name="Grace Hopper" />
  */
-export declare const Avatar: PolymorphicComponent<AvatarOwnProps, "figure">;
+export declare const Avatar: PolymorphicComponent<AvatarOwnProps, "figure", AvatarForwardedProp>;
 export default Avatar;

package/dist/types-cjs/components/Avatars.d.ts

@@ -25,6 +25,6 @@ export interface AvatarsProps extends Omit<React.HTMLAttributes<HTMLDivElement>,
     children?: React.ReactNode;
 }
 export declare const Avatars: React.FC<AvatarsProps> & {
-    Avatar: import("../index.js").PolymorphicComponent<import("./Avatar.js").AvatarOwnProps, "figure">;
+    Avatar: import("../index.js").PolymorphicComponent<import("./Avatar.js").AvatarOwnProps, "figure", "rel" | "href" | "target">;
 };
 export default Avatars;

package/dist/types-cjs/components/Dropdown.d.ts

@@ -98,7 +98,7 @@ export declare const DropdownItem: ConstrainedPolymorphicComponentWithoutRef<Dro
 export declare const DropdownDivider: React.FC;
 /** Bulma Dropdown component with Item and Divider sub-components. */
 export declare const Dropdown: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLDivElement>> & {
-    Item: ConstrainedPolymorphicComponentWithoutRef<DropdownItemOwnProps, DropdownItemElement, "a">;
+    Item: ConstrainedPolymorphicComponentWithoutRef<DropdownItemOwnProps, DropdownItemElement, "a", never>;
     Divider: React.FC<{}>;
 };
 export default Dropdown;

package/dist/types-cjs/components/Menu.d.ts

@@ -95,6 +95,6 @@ export declare const MenuItem: PolymorphicComponent<MenuItemOwnProps, "a">;
 export declare const Menu: React.FC<MenuProps> & {
     Label: React.FC<MenuLabelProps>;
     List: React.FC<MenuListProps>;
-    Item: PolymorphicComponent<MenuItemOwnProps, "a">;
+    Item: PolymorphicComponent<MenuItemOwnProps, "a", never>;
 };
 export default Menu;

package/dist/types-cjs/components/Navbar.d.ts

@@ -289,8 +289,8 @@ export declare const NavbarDropdownMenu: React.FC<NavbarDropdownMenuProps>;
 export declare const NavbarDivider: React.FC<React.HTMLAttributes<HTMLHRElement>>;
 export declare const Navbar: React.ForwardRefExoticComponent<NavbarProps & React.RefAttributes<HTMLElement>> & {
     Brand: React.FC<NavbarBrandProps>;
-    Item: PolymorphicComponent<NavbarItemOwnProps, "a">;
-    Link: PolymorphicComponent<NavbarLinkOwnProps, "a">;
+    Item: PolymorphicComponent<NavbarItemOwnProps, "a", never>;
+    Link: PolymorphicComponent<NavbarLinkOwnProps, "a", never>;
     Burger: React.ForwardRefExoticComponent<NavbarBurgerProps & React.RefAttributes<HTMLButtonElement>>;
     Menu: React.FC<NavbarMenuProps>;
     Start: React.FC<NavbarStartEndProps>;

package/dist/types-cjs/elements/Buttons.d.ts

@@ -34,7 +34,7 @@ interface ButtonsProps extends React.HTMLAttributes<HTMLDivElement>, Omit<BulmaC
     children: React.ReactNode;
 }
 export declare const Buttons: React.FC<ButtonsProps> & {
-    Button: import("../index.js").PolymorphicComponent<import("./Button.js").ButtonOwnProps, "button">;
-    LinkButton: import("../index.js").PolymorphicComponent<import("./LinkButton.js").LinkButtonOwnProps, "button">;
+    Button: import("../index.js").PolymorphicComponent<import("./Button.js").ButtonOwnProps, "button", never>;
+    LinkButton: import("../index.js").PolymorphicComponent<import("./LinkButton.js").LinkButtonOwnProps, "button", never>;
 };
 export {};

package/dist/types-cjs/helpers/polymorphic.d.ts

@@ -29,14 +29,44 @@ export type PolymorphicRef<T extends React.ElementType> = 'ref' extends keyof Re
 /**
  * A component's own props, plus the attributes of the element `as` names.
  *
- * `Own` wins every collision — a component that declares `color` as a Bulma
- * variant keeps it, rather than inheriting the DOM attribute of the same name.
- * That subtraction is the ONLY one. `color` used to be dropped here as well, to
- * stop the deprecated presentational HTML attribute reaching the three
- * components whose own props do not declare one — but doing it in the shared
- * type also stripped `color` from a CUSTOM target that legitimately has one.
- * Those three declare `color?: never` themselves instead, which lands in
- * `keyof Own` and reaches the same result without a special case here.
+ * `Own` wins a collision by default — a component that declares
+ * `color` as a Bulma variant keeps it, rather than inheriting the DOM attribute
+ * of the same name. `color` used to be dropped here as well, to stop the
+ * deprecated presentational HTML attribute reaching the components whose own
+ * props do not declare one — but doing it in the shared type also stripped
+ * `color` from a CUSTOM target that legitimately has one. Those components
+ * declare `color?: never` themselves instead, which lands in `keyof Own` and
+ * reaches the same result without a special case here.
+ *
+ * `Forwarded` names the own props the component hands STRAIGHT to the target
+ * instead of consuming, and the subtraction runs the other way for them: the
+ * TARGET's declaration wins, and the own one is what covers a target that has
+ * no such prop. Subtracting them threw the target's declaration away, so an
+ * OPTIONAL own prop hid a REQUIRED one — `<Avatar as={NextLink} name="Ada" />`
+ * compiled because Avatar's `href?: string` survived while `next/link`'s
+ * required `href` was omitted, and the target threw on what it never received
+ * (#665). The target wins rather than both declarations applying at once,
+ * because for a prop the component only passes along its own type has no
+ * standing: `next/link` accepts a URL object as well as a string, and
+ * intersecting Avatar's `string` with that would refuse the object.
+ *
+ * `Forwarded` defaults to `never`, so a prop the component CONSUMES stays
+ * subtracted — the common case, and the one `color` needs. What that costs is
+ * that a target REQUIRING a consumed prop is still satisfiable with the prop
+ * omitted, and the value goes wherever the component sends it: `Menu.Item`
+ * spends several of its own props on its wrapping `<li>`, `title` and `style`
+ * among them, so a target requiring one of those never sees it. Erroring on
+ * that needs a category this pair cannot express, since `className` is consumed
+ * too and yet every component composes one and passes it on. It is pinned as a
+ * limitation in `__typetests__/polymorphic.tsx` rather than guessed at here.
+ *
+ * `Own` is returned untouched when nothing is forwarded, rather than run through
+ * an `Omit` that names no keys. `Omit` is not the identity it looks like: it
+ * keys off `keyof Own`, which for a UNION `Own` is only what the members share,
+ * so `PolymorphicProps<'div', A | B>` lost every prop of both. It is public API
+ * and a consumer's wrapper can pass a union; the untouched branch also keeps
+ * each own prop's TSDoc reaching an IDE, which a mapped type drops. The
+ * forwarded branch distributes over `Own` for the same reason.
  *
  * Distributive over `T` on purpose. `Omit<A | B, K>` keys off `keyof (A | B)`,
  * which is only what A and B share — so a union-typed `as` (a ternary, or a
@@ -51,7 +81,7 @@ export type PolymorphicRef<T extends React.ElementType> = 'ref' extends keyof Re
  * This type is here for the component's cast target and for consumers writing
  * wrappers.
  */
-export type PolymorphicProps<T extends React.ElementType, Own> = T extends unknown ? Own & Omit<React.ComponentPropsWithoutRef<T>, keyof Own | 'as'> & {
+export type PolymorphicProps<T extends React.ElementType, Own, Forwarded extends keyof Own = never> = T extends unknown ? ([Forwarded] extends [never] ? Own : Own extends unknown ? Omit<Own, Extract<Forwarded, keyof React.ComponentPropsWithoutRef<T>>> : never) & Omit<React.ComponentPropsWithoutRef<T>, Exclude<keyof Own, Forwarded> | 'as'> & {
     /** The element or component to render. */
     as?: T;
 } : never;
@@ -86,11 +116,11 @@ export type PolymorphicProps<T extends React.ElementType, Own> = T extends unkno
  * const MemoButton = React.memo(Button) as typeof Button;
  * ```
  */
-export interface PolymorphicComponent<Own, Default extends React.ElementType> {
-    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own> & {
+export interface PolymorphicComponent<Own, Default extends React.ElementType, Forwarded extends keyof Own = never> {
+    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own, Forwarded> & {
         ref?: PolymorphicRef<T>;
     }): React.ReactElement | null;
-    (props: PolymorphicProps<Default, Own> & {
+    (props: PolymorphicProps<Default, Own, Forwarded> & {
         ref?: PolymorphicRef<Default>;
     }): React.ReactElement | null;
     displayName?: string;
@@ -101,10 +131,14 @@ export interface PolymorphicComponent<Own, Default extends React.ElementType> {
  * For components that own the node they observe — `Reveal` keeps its own ref on
  * the element it watches for scroll intersection, which is not always the
  * element `as` names.
+ *
+ * It carries `Forwarded` even with no component passing one today: the default
+ * is the behaviour without it, and a component that grows a forwarded own prop
+ * would otherwise reintroduce #665 here with nothing to say so.
  */
-export interface PolymorphicComponentWithoutRef<Own, Default extends React.ElementType> {
-    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own>): React.ReactElement | null;
-    (props: PolymorphicProps<Default, Own>): React.ReactElement | null;
+export interface PolymorphicComponentWithoutRef<Own, Default extends React.ElementType, Forwarded extends keyof Own = never> {
+    <T extends React.ElementType = Default>(props: PolymorphicProps<T, Own, Forwarded>): React.ReactElement | null;
+    (props: PolymorphicProps<Default, Own, Forwarded>): React.ReactElement | null;
     displayName?: string;
 }
 /**
@@ -131,8 +165,8 @@ export interface PolymorphicComponentWithoutRef<Own, Default extends React.Eleme
  * than losing every prop the members do not share. Narrowing it is not a
  * constrained-component question; it would have to change for `Button` first.
  */
-export interface ConstrainedPolymorphicComponentWithoutRef<Own, Allowed extends React.ElementType, Default extends Allowed> {
-    <T extends Allowed = Default>(props: PolymorphicProps<T, Own>): React.ReactElement | null;
-    (props: PolymorphicProps<Default, Own>): React.ReactElement | null;
+export interface ConstrainedPolymorphicComponentWithoutRef<Own, Allowed extends React.ElementType, Default extends Allowed, Forwarded extends keyof Own = never> {
+    <T extends Allowed = Default>(props: PolymorphicProps<T, Own, Forwarded>): React.ReactElement | null;
+    (props: PolymorphicProps<Default, Own, Forwarded>): React.ReactElement | null;
     displayName?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allxsmith/bestax-bulma",
-  "version": "5.16.7",
+  "version": "5.16.8",
   "description": "A fully-typed React component library for the Bulma CSS framework. Build modern UIs quickly with reusable, accessible, and customizable Bulma-based React components.",
   "main": "dist/index.cjs",
   "module": "dist/index.esm.js",