@ntbjs/react-components 3.0.0-rc.1 → 3.0.0-rc.3

package/types/components/data/_shared/FloatingArrow.styled.d.ts

@@ -8,122 +8,22 @@ import type { NtbTheme } from '../../../utils/defaultTheme';
  *   `Tooltip.styled.ts` sets `background: gray-700` unconditionally and has no border.
  */
 export type FloatingArrowSurface = 'popover' | 'tooltip';
-/**
- * THE ARROW'S GEOMETRY, PER SURFACE — and the numbers are derived, not chosen.
- *
- * `height` is how far the arrow protrudes from the floating element, because
- * `FloatingArrow` positions its `<svg>` at `[side]: '100%'`. It is therefore the term
- * `useFloatingPopover` adds to the main-axis offset, which is why the popover height is
- * IMPORTED from there rather than written twice: the offset maths and the rendered
- * triangle must be the same number or the arrow sits at the wrong gap.
- *
- * `popover` — from `Popover.styled.ts`'s override, `border-width: 15px 13px 0`: a triangle
- * 15px tall on a 13+13 = **26px** base. The full derivation, including why the `+15` in
- * `Popover.tsx` was never a fudge, is on `DEFAULT_ARROW_HEIGHT`.
- *
- * `tooltip` — `Tooltip.styled.ts` never overrode the geometry, so the numbers come from
- * `tippy.js/dist/tippy.css`, and they are the **VISIBLE** triangle rather than the declared
- * one. THE ONE PIXEL THE FIRST DRAFT OF THIS COMMENT CALLED UNAVOIDABLE IS NOT: it
- * disappears once the hidden part of tippy's triangle is subtracted instead of being
- * carried. The measurement, from the four rules that describe a top-placed tooltip arrow:
- *
- *   .tippy-arrow                                  { width: 16px; height: 16px }
- *   .tippy-box[data-placement^=top] > .tippy-arrow { bottom: 0 }
- *   .tippy-box[data-placement^=top] > .tippy-arrow:before {
- *       bottom: -7px; border-width: 8px 8px 0 }
- *
- * 1. The 16x16 arrow box sits with its bottom edge ON the box's bottom edge.
- * 2. The `:before` border-triangle is 8px tall on a 16px base, positioned `bottom: -7px`,
- *    so its apex is 7px OUTSIDE the box and its 16px-wide base is 1px INSIDE it.
- * 3. Therefore only 7 of the 8px are ever visible, and at the box edge — 1px down from a
- *    16px base on an 8px triangle — the triangle has already narrowed to
- *    16 x (1 - 1/8) = **14px**.
- * 4. So the triangle a user sees is **14px wide at the box edge and 7px tall**, which is
- *    `FloatingArrow`'s own default geometry, and `FloatingArrow` overlapping nothing is
- *    exactly right: there is nothing to overlap. The 1px tippy hides is the same
- *    `gray-700` as the box behind it (this surface has no border), so it was never
- *    contributing a pixel.
- *
- * The offset that goes with it is tippy's own default `[0, 10]` passed straight through,
- * with `arrowHeight: 0` handed to `useFloatingPopover` — see the block comment at
- * `TOOLTIP_OFFSET` in `Tooltip.tsx`, which is where the reason that `Tooltip` does NOT add
- * the arrow height while `Popover` does is written down. Box 10px out, tip 3px out, in both
- * implementations.
- *
- * `strokeWidth` is `FloatingArrow`'s border width in px. `0` means the outline `<path>` is
- * not rendered at all, which is why the `tooltip` surface needs no `stroke` rule.
- */
 export declare const POPOVER_ARROW: {
     readonly width: 26;
     readonly height: 15;
     readonly strokeWidth: 1;
 };
-/**
- * See `POPOVER_ARROW` — same derivation, from tippy's unmodified default geometry, reduced
- * to the part of it that is visible. 14x7 and not 16x8; the numbers coincide with
- * `FloatingArrow`'s own defaults, which is a result rather than a shortcut and is why they
- * are written out anyway.
- */
 export declare const TOOLTIP_ARROW: {
     readonly width: 14;
     readonly height: 7;
     readonly strokeWidth: 0;
 };
 /**
- * Props of `SharedFloatingArrow`, i.e. what this file's `.attrs()` callback reads and what
- * a call site may set. Both optional per §J.5 — every wrapper spreads `{...props}` onto its
- * styled root, and a required transient prop manufactures TS2769 there.
+ * Props of `SharedFloatingArrow`. data-arrow-surface reaches DOM (rules select on it); theme is declared for .attrs() callback.
  */
 interface FloatingArrowStyleProps {
-    /**
-     * styled-components' theme. Declared for the same reason `Popover.styled.ts` declares
-     * it — this is `styled(ThirdPartyComponent)`, so the outer props are
-     * `FloatingArrowProps extends React.ComponentPropsWithRef<'svg'>` and nothing in there
-     * is `theme`. `.attrs(applyDefaultTheme)` fills it in for the interpolations below.
-     */
     theme?: NtbTheme;
-    /**
-     * Which colour pair to use. NOT `$`-prefixed on purpose: it has to REACH THE DOM,
-     * because the rules below select on it. `shouldForwardProp` forwards it precisely
-     * because it does not start with `$`.
-     *
-     * Hyphenated, so a call site could pass it without this declaration — TypeScript does
-     * not excess-property-check JSX attribute names that are not valid identifiers. It is
-     * declared anyway because the `.attrs()` callback READS it, and a read does need the
-     * declaration.
-     */
     'data-arrow-surface'?: FloatingArrowSurface;
 }
-/**
- * The themed arrow. Render it inside the floating element with `context`, `ref` and the
- * geometry from `POPOVER_ARROW` / `TOOLTIP_ARROW`:
- *
- * ```tsx
- * <S.SharedFloatingArrow ref={arrowRef} context={context} {...POPOVER_ARROW} />
- * ```
- *
- * `ref` IS REQUIRED BY `FloatingArrow` ITSELF — it warns in development without one and
- * the `arrow()` middleware has nothing to measure. `useFloatingPopover` returns the
- * matching `arrowRef`.
- *
- * ================== THE THREE-PATH STRUCTURE, WHICH THE CSS DEPENDS ON ==================
- *
- * `FloatingArrow` renders, in order (measured in
- * `@floating-ui/react/dist/floating-ui.react.esm.js`):
- *
- *   1. an OUTLINE `<path>`, ONLY when `strokeWidth > 0`, with `fill="none"` and
- *      `stroke-width: strokeWidth * 2 + 1`;
- *   2. the FILL `<path>`, whose `stroke` attribute it sets to the value of the `fill`
- *      PROP — its way of covering the inner half of (1)'s stroke so a `strokeWidth: 1`
- *      renders as a 1px border rather than 1.5px;
- *   3. a `<clipPath>`, which is not a `<path>`.
- *
- * We colour by CSS rather than by the `fill`/`stroke` PROPS because the theme is chosen by
- * a `body` class at runtime and a prop would have to be computed in JS, which cannot see
- * which class is set. That leaves (2)'s `stroke` attribute unset, so the rules below set it
- * explicitly — `& > path:last-of-type`, which is (2) whether or not (1) is present.
- * Without that rule (2) would INHERIT the CSS `stroke` and the border would read ~1.5px
- * instead of the 1px it replaces.
- */
 export declare const SharedFloatingArrow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<Omit<import("@floating-ui/react").FloatingArrowProps, "ref"> & import("react").RefAttributes<SVGSVGElement>, Omit<import("@floating-ui/react").FloatingArrowProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>, FloatingArrowStyleProps>, never>> & string & Omit<import("react").ForwardRefExoticComponent<Omit<import("@floating-ui/react").FloatingArrowProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>, keyof import("react").Component<any, {}, any>>;
 export default SharedFloatingArrow;

package/types/components/inputs/ActionButton/ActionButton.styled.d.ts

@@ -1,27 +1,9 @@
 /**
- * Props of the one styled component in this file. Value types from
- * `ActionButton.tsx`'s propTypes; all optional per §J.5 — and here that is not
- * theoretical, `ActionButton.tsx` spreads `{...props}` onto this root, which is the
- * measured TS2769 case.
- *
- * `disabled` is deliberately ABSENT: it is a real `ButtonHTMLAttributes` member, the
- * component passes it, and the template only uses the `&:disabled` CSS pseudo-class
- * rather than reading the prop. Nothing to declare. §J.9, first row.
+ * Props of the styled ActionButton. `disabled` is absent: it's a real ButtonHTMLAttributes member.
  */
 export interface ActionButtonStyleProps {
     /**
-     * `actionWidthHeight` — `PropTypes.array`, `[width, height]` in px, defaulted to
-     * `[40, 40]` BY THE COMPONENT (which is not a default here, so still optional).
-     * `number[]` rather than `[number, number]`: the propTypes accept any array and the
-     * template only ever indexes `[0]` and `[1]`.
-     *
-     * NOTE FOR THE `strictNullChecks` FLIP: these seven reads are UNGUARDED
-     * (`props.$actionWidthHeight[0]`, not `props.$actionWidthHeight?.[0]`), unlike every
-     * other transient prop in the converted files. They compile today because
-     * `strictNullChecks` is off; when it is turned on at the end of the migration this
-     * is the site that needs either `?.` plus a fallback or a required prop, and either
-     * is a behaviour question rather than a typing one — so it is recorded, not changed
-     * here. (`$backgroundColors` below is already read with `?.`.)
+     * Width and height `[width, height]` in px. Unguarded array access—needs `?.` when strictNullChecks flips.
      */
     $actionWidthHeight?: number[];
     /** `backgroundColors` — `PropTypes.arrayOf(PropTypes.string)`, `[dark, light]`. */

package/types/components/inputs/Button/Button.styled.d.ts

@@ -1,57 +1,15 @@
 import type { ReactNode } from 'react';
-/**
- * `size` — `PropTypes.oneOf(['x-small', 'small', 'normal', 'large'])`, component default
- * `'normal'`. Closed on purpose (§J.6): `Button` and `ButtonContent` compare against
- * three of the four members, so a mistyped size is TS2367 rather than a dead branch.
- *
- * IT HAS NO `$`, AND THAT IS A DEFECT. `size` is not a member of
- * `ButtonHTMLAttributes` (it is an `<input>`/`<select>` attribute), which is why the
- * five reads of it were TS2339, and `shouldForwardProp` forwards every non-`$` prop —
- * so `size="normal"` is on every rendered `<button>` and every `ButtonContent`
- * `<div>` today, and both are in the recorded render baseline. Fix = rename `$size` at
- * both ends; removes a DOM attribute → C10 with its re-record. §E.4 third case.
- */
 type ButtonSize = 'x-small' | 'small' | 'normal' | 'large';
-/**
- * `dropdownItems` — `PropTypes.node`, an array of `ContextMenuItem`s.
- *
- * `ReactNode` and not `boolean`: the templates only ever test it for truthiness, but
- * what is passed is the node itself, and recording what the code does is the rule
- * (§J.6). It is transient, so it never reaches the DOM.
- */
 type DropdownItems = ReactNode;
-/**
- * `Button`'s props — nine of them, which is why they are a named interface here rather
- * than inline. All optional per §J.5, and here that is load-bearing twice over:
- * `Button.tsx` spreads `{...props}` onto this root, and it renders `S.Button` at three
- * sites that pass different subsets (only the two dropdown sites pass
- * `$singleactiongap`).
- *
- * `disabled` is deliberately ABSENT: on a `styled.button` it is a genuine
- * `ButtonHTMLAttributes` member, so the read at `props.disabled &&` already typechecks
- * and the attribute belongs on the element (§J.9, first row).
- */
 export interface ButtonStyleProps {
-    /** `border` — `PropTypes.number`, default `2`. Interpolated as `${…}px`, so a string
-     *  here would already render `border: 2pxpx solid`. */
     $border?: number;
-    /** `secondary` — `PropTypes.bool`. */
     $secondary?: boolean;
-    /** `outlined` — `PropTypes.bool`. */
     $outlined?: boolean;
-    /** `dropdownItems` — see `DropdownItems`. */
     $dropdownItems?: DropdownItems;
-    /** `block` — `PropTypes.bool`, default `false`. Full-width. */
     $block?: boolean;
-    /** `size` — see `ButtonSize`. Leaks to the DOM; see there. */
     size?: ButtonSize;
-    /** `singleAction` — `PropTypes.bool`, default `false`. */
     $singleaction?: boolean;
-    /** `singleActionGap` — `PropTypes.number`, default `34`. Interpolated as `${…}px`.
-     *  Passed only at the two dropdown `S.Button` sites, which is one of the reasons
-     *  every member here is optional. */
     $singleactiongap?: number;
-    /** `width` — `PropTypes.number`, the custom `min-width`, interpolated as `${…}px`. */
     $width?: number;
 }
 export declare const Button: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>>, ButtonStyleProps>, never>> & string;

package/types/components/inputs/Checkbox/Checkbox.d.ts

@@ -26,15 +26,6 @@ type Props = {
     name?: string;
     /**
      * The checkbox' value
-     *
-     * `string | number`, not the `PropTypes.string` this replaces. `MultiLevelCheckbox`
-     * renders `<Checkbox value={node.value} …>` and a node's value is
-     * `MultiLevelCheckboxNodeValue = string | number`, so a numeric value reaches this
-     * prop through a public API today and `oneOf`-style validation never noticed because
-     * the two components' propTypes were never compared. The value is forwarded
-     * unchanged onto `<input type="checkbox">`, whose own React type is
-     * `string | number | readonly string[]`, so this widening records reality and emits
-     * identical markup.
      */
     value?: string | number;
     /**

package/types/components/inputs/Checkbox/Checkbox.styled.d.ts

@@ -1,6 +1,6 @@
 /**
  * `variant` — `PropTypes.oneOf(['green', 'black'])`, carried as `$variant` by both
- * `Checkbox` and `CheckboxLabel`. Closed on purpose (§J.6): both templates compare
+ * `Checkbox` and `CheckboxLabel`. Closed on purpose: both templates compare
  * `=== 'black'`, and with a closed union a mistyped variant name is TS2367 rather
  * than a branch that silently never fires.
  */
@@ -11,23 +11,19 @@ export declare const Checkbox: import("styled-components/dist/types").IStyledCom
 export declare const CheckIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
 export declare const IndeterminateCheckIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
 interface CheckboxLabelStyleProps {
-    /** `muted` — `PropTypes.bool`. Fades the `&::before` box only. Leaks to the DOM. */
+    /** `muted` — fades the checkbox box. Leaks to DOM. */
     muted?: boolean;
-    /** `readOnly` — `PropTypes.bool`. Leaks to the DOM. */
+    /** `readOnly` — leaks to DOM. */
     readOnly?: boolean;
-    /** `disabled` — `PropTypes.bool`. Leaks to the DOM. */
+    /** `disabled` — leaks to DOM. */
     disabled?: boolean;
-    /** `variant` — see `CheckboxVariant`. Properly transient. */
+    /** `variant` — closed union, properly transient. */
     $variant?: CheckboxVariant;
 }
 export declare const CheckboxLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>>, CheckboxLabelStyleProps>, never>> & string;
 export declare const CheckboxVisualLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
 export declare const Description: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>>, {
-    /**
-     * `error` — the component derives `hasError` (`isBoolean(error) ? error :
-     * !isEmpty(error)`) and passes that, so `boolean` and not the
-     * `bool | string` that `error`'s own propTypes allow.
-     */
+    /** `error` — narrowed to `boolean` after `hasError` derivation. */
     $error?: boolean;
 }>, never>> & string;
 export {};

package/types/components/inputs/CompactAutocompleteSelect/CompactAutocompleteSelect.styled.d.ts

@@ -9,9 +9,9 @@ import type { PartialNtbTheme } from '../../../utils/defaultTheme';
  * carried WITHOUT a `$` to `Control`, `ValueContainer` and `Placeholder` — see
  * `ControlStyleProps` for why that is not a DOM leak here.
  *
- * Closed on purpose (§J.6): the templates below compare against this value 14 times, so a
+ * Closed on purpose: the templates below compare against this value 14 times, so a
  * mistyped state name is TS2367 rather than a branch that silently never fires. `''` is a
- * member because the component defaults `type = ''` (tsx line 172).
+ * member because the component defaults `type = ''`.
  */
 type CompactAutocompleteSelectType = '' | 'error' | 'warning' | 'instructions-warning' | 'loading' | 'success';
 /**
@@ -43,38 +43,16 @@ interface SelectThemeProp {
     theme?: PartialNtbTheme;
 }
 declare const AsyncCreatableSelectPaginate: import("react-select-async-paginate").WithAsyncPaginateType;
-/**
- * The WRITTEN type of the four `styled(<react-select component>)` exports below. Same
- * mechanism, same wording and the same audit as `SelectWrapper` in
- * `src/components/inputs/MultiSelect/MultiSelect.styled.ts` — read that one; it is the
- * canonical note. §G.4.
- *
- * Short version: the INFERRED type is correct and unprintable. Under `--declaration` its
- * printed form expands to react-select's `PublicBaseSelectProps` and
- * `StateManagerAdditionalProps`, which `react-select`'s `exports` map does not serve, so
- * tsc reported 8 x TS2883 here and — because `noEmitOnError` is false — silently declined
- * to write this file's `.d.ts` at all. That in turn erased the props of the PUBLISHED
- * `CompactAutocompleteSelect` declaration down to
- * `ForwardRefExoticComponent<RefAttributes<unknown>>`, a closed props type with zero
- * members: the exact §G.4 poison, arriving from react-select rather than from `allowJs`.
- *
- * tsc prints a generic alias APPLICATION by reference, so `SelectWrapper<typeof Select>`
- * is writeable where the expansion is not. `Omit<ComponentProps<C>, keyof P> & P` is
- * styled-components' own `Substitute<OuterProps, P>`, so no prop is widened or narrowed.
- */
 type SelectWrapper<C extends React.ComponentType<any>> = React.ComponentType<Omit<React.ComponentProps<C>, keyof SelectWrapperStyleProps> & SelectWrapperStyleProps>;
 type AsyncCreatablePaginateWrapper = SelectWrapper<typeof AsyncCreatableSelectPaginate>;
-/**
- * The four select wrappers share this: `$hasLabel` for `sharedStyle`'s sake, `theme` for
- * react-select's sake, and `disabled` — which is a deferred defect, see below.
- */
 export interface SelectWrapperStyleProps extends SelectThemeProp {
     /** `!isEmpty(label)` — narrows the control to 66.66% so the label gets the other third. */
     $hasLabel?: boolean;
+    /** `disabled` — unused; fix (repoint to `isDisabled`) changes rendered CSS. */
     disabled?: boolean;
 }
 interface DisabledStyleProps {
-    /** `disabled` — dims and blocks the pointer. Also reaches the DOM; see above. */
+    /** `disabled` — dims and blocks the pointer. Leaks to DOM. */
     disabled?: boolean;
 }
 export declare const CompactAutocompleteSelect: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, DisabledStyleProps>, never>> & string;
@@ -85,37 +63,6 @@ export declare const AsyncCreatableAutocompleteSelect: AsyncCreatablePaginateWra
 export declare const AsyncAutocompleteSelect: SelectWrapper<typeof AsyncPaginate>;
 export declare const AutocompletSelect: SelectWrapper<typeof Select>;
 export declare const AutocompletCreatableSelect: SelectWrapper<typeof CreatableSelect>;
-/**
- * Props of `Control`, the react-select control wrapper.
- *
- * `edit` and `type` HAVE NO `$` AND STILL DO NOT LEAK TO THE DOM, which makes this the one
- * benign member of §E.4's non-`$` list in this file and worth stating so nobody "fixes" it
- * blind. There is no `withConfig`/`shouldForwardProp` on a `styled(<component>)` — there is
- * no DOM element to filter for — and react-select's `Control` renders only its
- * `innerProps` onto the `<div>`, ignoring props it does not know. So
- * `<S.Control edit={edit} type={type} …>` (tsx line 193) reaches the template and stops
- * there. Prefixing them would be tidier but is not a bug fix, and it still touches two
- * files for no type benefit.
- *
- * `isFocused` is deliberately ABSENT: it is a real `ControlProps` member, so the template's
- * seven reads of it already typecheck. §J.9's first case.
- *
- * ================== DEFERRED DEFECT in this component's template =====================
- * `!props.type === 'instructions-warning'` (the `isFocused` border-color rule, ~40 lines
- * down; the note has to live here because backticks cannot appear inside the styled
- * template) NEGATES FIRST AND THEN COMPARES A BOOLEAN TO A STRING. It is always false, so
- * that whole `border-color` rule is dead — a FOCUSED control has never received the
- * gray-600 border.
- *
- * That is the 5th and last remaining error in this file, TS2367 "This comparison appears
- * to be unintentional because the types 'boolean' and 'string' have no overlap", and NO
- * ANNOTATION CAN REMOVE IT: `!props.type` is `boolean` whatever `type` is declared as,
- * `any` included. It is a defect in the expression, and §E.1 rule 3 says fix the code, not
- * the type. The fix is `props.type !== 'instructions-warning'`, which ACTIVATES a rule that
- * has never fired on the most visible state of the component — C9 for the fix, C10 for the
- * re-record, not this commit. §J.8.
- * ====================================================================================
- */
 interface ControlStyleProps extends SelectThemeProp {
     /** `edit` (`PropTypes.bool`) — grey "this is editable" background. */
     edit?: boolean;

package/types/components/inputs/CompactStarRating/CompactStarRating.styled.d.ts

@@ -1,12 +1,3 @@
-/**
- * `CompactStarRating.tsx`'s `type` prop, from its
- * `PropTypes.oneOf(['', 'error', 'warning', 'loading', 'success'])`. The component
- * defaults it to `''`, so `''` is a member — this is the propTypes verbatim.
- *
- * Carried WITHOUT a `$` by `starsWidth`, which is a defect in its own right (see
- * there). `Star` / `StarFill` / `CheckIconContainer` also branch on a `type`, but
- * theirs is not this one — see the notes at those three.
- */
 type CompactStarRatingType = '' | 'error' | 'warning' | 'loading' | 'success';
 export declare const CompactStarRating: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, {
     /** `readOnly` — `PropTypes.bool`. Leaks to the DOM; see above. */
@@ -21,61 +12,18 @@ export declare const SuccessContainer: import("styled-components/dist/types").IS
 interface StarsWidthStyleProps {
     /** `edit` — `PropTypes.bool`. Shows the editable-affordance background. */
     $edit?: boolean;
-    /**
-     * `type` — see `CompactStarRatingType`. HAS NO `$`, AND THAT IS A DEFECT: this is a
-     * `styled.div`, `type` is not a member of `HTMLAttributes<HTMLDivElement>`, and
-     * `shouldForwardProp` forwards it — so `type="error"` / `type="loading"` etc. is on
-     * this `<div>` in the render baseline whenever the prop is non-empty. Fix = rename
-     * `$type`; removes a DOM attribute → C10 with its re-record. §E.4 third case.
-     */
+    /** `type` — see `CompactStarRatingType`. Leaks to DOM; defect not fixed. */
     type?: CompactStarRatingType;
     /** `readOnly` — `PropTypes.bool`. Leaks to the DOM the same way. */
     readOnly?: boolean;
-    /**
-     * `success` IS DECLARED BECAUSE THE NESTED `css<{ success?: boolean }>` BLOCK BELOW
-     * READS IT, NOT BECAUSE ANYTHING PASSES IT. Nothing does — `CompactStarRating.tsx`
-     * renders `<S.starsWidth $edit={edit} type={type} readOnly={readOnly}>` and there is
-     * no other importer — so `props.success` is always `undefined` and that block's
-     * animation is unconditionally `fadeOut`. The success-fade-IN state of this component
-     * is unimplemented. A DIFFERENT DEFECT from the `fadeIn` branch removed from
-     * `SuccessContainer` above, and left alone deliberately: `fadeIn` was a mistyped
-     * identifier that never existed as a prop, whereas `success` WAS a real
-     * `PropTypes.bool` (added by `4ed910a`) that `b5d59e7`/`7e46b9d` deleted from the
-     * component while leaving this read behind. Deciding between restoring the prop and
-     * deleting the block is its own call, on its own commit.
-     *
-     * Without this member the interpolation is TS2345, and the reason is the WEAK-TYPE
-     * RULE (§J.7): `{ success?: boolean }` is all-optional, assignability to a weak type
-     * requires at least one member in common, and the host had none — measured verbatim as
-     * "…has no properties in common with type '{ success?: boolean; }'". Same shape as
-     * `CompactTextInput`'s `StyledLink` / `linkColor`.
-     *
-     * It also has no `$`, but since nothing passes it, it does not currently leak.
-     */
+    /** `success` — unused prop, declared for weak-type assignment compatibility. */
     success?: boolean;
 }
 export declare const starsWidth: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, StarsWidthStyleProps>, never>> & string;
-/**
- * The props `Star` and `StarFill` share — they are byte-identical templates apart from
- * one `type === 'error'` block, and the JSX passes them the same set.
- *
- * `disabled` is deliberately ABSENT: on a `styled.button` it is a genuine
- * `ButtonHTMLAttributes` member, so the read already typechecks and the attribute
- * belongs on the element (§J.9 first row).
- *
- * `type` IS ALSO DELIBERATELY ABSENT, AND THAT IS WHY FOUR TS2367 ERRORS SURVIVE IN
- * THIS FILE. See the note above `StarFill`.
- */
 interface StarStyleProps {
     /** `hover && key + 1 <= tempRating` — derived in the component, so `boolean`. */
     $hover?: boolean;
-    /**
-     * `readOnly` — `PropTypes.bool`. HAS NO `$`, AND THAT IS A DEFECT: `readOnly` is NOT a
-     * member of `ButtonHTMLAttributes` (unlike `disabled`), and `shouldForwardProp`
-     * forwards it, so `readonly=""` is on every rendered star `<button>` today and is in
-     * the recorded render baseline. Fix = rename `$readOnly`; removes a DOM attribute →
-     * C10 with its re-record. §E.4 third case.
-     */
+    /** `readOnly` — `PropTypes.bool`. Leaks to DOM; defect not fixed. */
     readOnly?: boolean;
 }
 export declare const Star: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>>, StarStyleProps>, never>> & string;

package/types/components/inputs/CompactTextInput/CompactTextInput.styled.d.ts

@@ -1,14 +1,4 @@
-/**
- * `CompactTextInput.tsx`'s `type` prop, from its
- * `PropTypes.oneOf(['', 'error', 'warning', 'loading', 'success'])`, carried across
- * the `shouldForwardProp` boundary as `$type` by both `Input` and
- * `InputIconContainer`.
- *
- * Closed on purpose, not widened to `string`. The templates below branch on this
- * value 20 times; with a closed union a mistyped state name is TS2367 rather than a
- * branch that silently never fires. `''` is a member because the component defaults
- * `type = ''` — this union is the propTypes verbatim, not a tidied version of it.
- */
+/** Closed union: branches 20 times below, so mistyped state names are TS2367 not silent no-ops. */
 type CompactTextInputType = '' | 'error' | 'warning' | 'loading' | 'success';
 export declare const CompactTextInput: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
 export declare const Label: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>>, {
@@ -23,27 +13,9 @@ export declare const InputIconContainer: import("styled-components/dist/types").
     $type?: CompactTextInputType;
 }>, never>> & string;
 /**
- * Props of `Input`.
- *
- * Every member is transient, so `shouldForwardProp` filters all of them out of the DOM.
- * `$haslink` is lower-case by existing convention at both ends; renaming it would be a
- * two-file change for no type benefit.
- *
- * `$inputType` WAS `inputtype`, WITH NO `$`, AND THAT WAS A DOM LEAK — now fixed.
- * It is a style/behaviour input (the `.attrs()` callback turns it into the real `type`
- * attribute), but without the `$` prefix `shouldForwardProp` forwarded it verbatim too,
- * so `inputtype="text"` was on every rendered `<input>` — visible in seven entries of the
- * recorded render baseline (`inputs/CompactTextInput` and its five variants, plus
- * `layout/InputGroup`). §E.4's third case, and the fix is the `$` prefix.
- *
- * The PUBLIC prop is unaffected: `CompactTextInput.tsx` still takes `inputType` and maps
- * it to this transient prop internally, so no consumer has to react. (Grepped: neither
- * `mb-main-client/src` nor `ntb-dam/client/src` mentions `inputtype` or `inputType` at
- * all, and no stylesheet in `src` selects on `[inputtype]`.)
- *
- * `readOnly` and `disabled` are read by the template too and are deliberately ABSENT
- * from this interface: both are real `InputHTMLAttributes` members, so those reads
- * already typecheck and declaring them would add nothing. §J.9.
+ * Props of `Input`. All members transient (filtered by shouldForwardProp).
+ * DOM leak fixed: `$inputType` (was `inputtype` without $, on every rendered input).
+ * `readOnly` and `disabled` absent intentionally: they're real InputHTMLAttributes members.
  */
 interface InputStyleProps {
     /** `type` — see `CompactTextInputType`. Branched on 20 times below. */

package/types/components/inputs/MultiLevelCheckbox/MultiLevelCheckbox.styled.d.ts

@@ -1,14 +1,6 @@
-/**
- * Props of the two components that take the expand/collapse state across the
- * `shouldForwardProp` boundary.
- *
- * `MultiLevelCheckbox.tsx` passes `$expanded={expanded || expandedBySearch}` at both
- * sites (lines 263 and 302) — two `useState<boolean>` values OR'd together, hence
- * `boolean`. Optional, per §J.5: nothing supplies a default and the templates are
- * written for its absence (`props.$expanded && css`…``).
- */
+/** Transient prop for two styled components; optional (templates handle absence). */
 interface ExpandedStyleProps {
-    /** `expanded || expandedBySearch` — opens the `grid-template-rows` / rotates the caret. */
+    /** `expanded || expandedBySearch` — opens the grid-template-rows / rotates the caret. */
     $expanded?: boolean;
 }
 export declare const MultiLevelCheckbox: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>, import("react").DetailedHTMLProps<import("react").FieldsetHTMLAttributes<HTMLFieldSetElement>, HTMLFieldSetElement>>, never>, never>> & string;

package/types/components/inputs/MultiLevelCheckbox/types.d.ts

@@ -1,42 +1,10 @@
 import PropTypes from 'prop-types';
-/**
- * The option tree `MultiLevelCheckbox` and `MultiLevelCheckboxSelect` render.
- *
- * TWO THINGS IN HERE, DESPITE THE FILE NAME: the types, and `findChildValues` —
- * a runtime helper both components call. The helper predates the file's name;
- * moving it is a separate commit.
- */
-/**
- * A node's identity.
- *
- * `string | number` RATHER THAN THE `PropTypes.any` IT REPLACES, because three
- * runtime uses constrain it and none of them accepts an arbitrary value: it is
- * the React `key` of every rendered `CheckboxTree`, it is the `value` of the
- * underlying `<input type="checkbox">`, and it is compared with `===` and
- * `Array.prototype.includes` against the `checked` array the consumer owns.
- * An object here already renders as `[object Object]` and breaks reconciliation,
- * so `any` was permission for a bug rather than a description of the API.
- *
- * Every value in the stories is a string.
- */
+/** Node identity: React key, checkbox value, and included() target; objects would break reconciliation. */
 export type MultiLevelCheckboxNodeValue = string | number;
 /**
  * One option, with any number of levels of children under it.
  *
- * GENUINELY RECURSIVE, WHICH THE propTypes AT THE BOTTOM ARE NOT — and the
- * recursion is the accurate description, not an improvement invented here:
- *
- * - `NodeType` validates exactly two levels and then gives up (`children:
- *   PropTypes.array`), because a self-referential `PropTypes.shape` is not
- *   expressible without a lazy indirection. Its own comment says so.
- * - `findChildValues` below, `hasChildrenSelected`, `hasAllChildrenSelected`,
- *   `getLabelByValue` and `CheckboxTree` itself all recurse without a depth
- *   limit, and the stories ship four-level trees
- *   (`sport → idrettsgren → golf → minigolf`).
- *
- * So the propTypes silently accepted anything below level two while the
- * components happily walked it. This interface is what the code has always
- * meant.
+ * Genuinely recursive (propTypes truncate at two levels); code recurses without depth limit.
  */
 export interface MultiLevelCheckboxNode {
     /** Shown next to the checkbox, and what the `search` prop matches against. */
@@ -48,18 +16,7 @@ export interface MultiLevelCheckboxNode {
      */
     children?: MultiLevelCheckboxNode[];
 }
-/**
- * Every descendant value under `node`, depth-first, excluding `node` itself.
- *
- * Callers pass `[node.value, ...findChildValues(node)]` when they want the node
- * included, which is why it is excluded here.
- *
- * Guards on `Array.isArray(node.children)`, so a node whose `children` is
- * `undefined` — or something the type says it cannot be — yields `[]` rather
- * than throwing. There is no cycle protection: a node reachable from its own
- * subtree recurses until the stack runs out. That is pre-existing, and the tree
- * comes from the consumer.
- */
+/** Every descendant value under node, depth-first, excluding node itself (callers add node back). */
 export declare function findChildValues(node: MultiLevelCheckboxNode): MultiLevelCheckboxNodeValue[];
 export declare const NodeType: PropTypes.Requireable<PropTypes.InferProps<{
     label: PropTypes.Validator<string>;