praxis-kit 6.5.0 → 6.6.1

package/dist/{react-options-DoFNqNdY.d.ts → react-options-BUBVohU6.d.ts}

@@ -250,6 +250,16 @@ type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
      */
     readonly diagnostics?: Diagnostics | DiagnosticsMode;
     readonly aria?: readonly AriaRule[];
+    /**
+     * Rules that need `AriaPolicyEngine`'s fix-application/caching machinery
+     * (`AriaRule`'s `readsProps`, fixable `AriaFix` results) but have no
+     * relationship to ARIA semantics — an HTML fact or a security check like a
+     * dangerous-URL-scheme guard, for example. Evaluated together with `aria`
+     * (both run through the same engine, merged into one rule set) — this is a
+     * separate bucket purely so a non-ARIA rule doesn't have to sit under the
+     * misleading `aria` name to get the machinery it needs.
+     */
+    readonly rules?: readonly AriaRule[];
     readonly children?: readonly ChildRuleInput[];
     /**
      * When true, only children matching a `children` rule (or text, per `allowText`)
@@ -339,25 +349,27 @@ type SlotComponent = ComponentType<UnknownProps>;
 type RenderCallbackProps = Readonly<AnyRecord>;
 
 /**
- * Maps a polymorphic element type to the instance type exposed through `ref`.
+ * Resolves the instance type exposed through `ref` for a polymorphic
+ * element.
  *
- * Intrinsic HTML elements resolve to their corresponding DOM element type;
- * custom React components currently fall back to `unknown`.
+ * Intrinsic HTML elements map to their corresponding DOM element type;
+ * custom React components currently resolve to `unknown`.
  */
 type ElementRef<T extends ElementType> = T extends IntrinsicTag ? HTMLElementTagNameMap[T] : unknown;
 /**
- * React's intrinsic JSX props for a given element.
+ * React's intrinsic JSX props for an element type.
  *
- * Custom components intentionally fall back to `UnknownProps`; the component's
- * own prop model defines their accepted props instead.
+ * Custom components intentionally resolve to `UnknownProps`; their own
+ * prop definitions determine the accepted props.
  */
 type IntrinsicJSXProps<T extends ElementType> = T extends IntrinsicTag ? JSX.IntrinsicElements[T] : UnknownProps;
 /**
- * Removes index signatures while preserving explicitly named properties.
+ * Removes index signatures while preserving explicitly declared
+ * properties.
  *
- * This prevents generic fallback constraints such as `Record<string, unknown>`
- * from collapsing `keyof T` to `string`, which would cause
- * `Omit<IntrinsicJSXProps<T>, keyof ...>` to remove every intrinsic prop.
+ * Prevents broad index signatures (for example `Record<string, unknown>`)
+ * from causing `keyof T` to become `string`, which would otherwise erase
+ * every intrinsic prop during `Omit`.
  */
 type StripIndexSignature<T> = {
     [K in keyof T as string extends K ? never : K]: T[K];
@@ -367,18 +379,16 @@ type ComponentProps<G extends PolymorphicGenerics> = StripIndexSignature<PropsOf
 /** Variant props generated from the component's variant definitions. */
 type ComponentVariants<G extends PolymorphicGenerics> = StripIndexSignature<VariantProps<VariantsOf<G>>>;
 /**
- * Props owned by the component itself.
+ * Props defined by the component itself.
  *
- * These take precedence over intrinsic HTML props when names overlap.
+ * These override intrinsic JSX props with the same name.
  */
 type OwnedProps<G extends PolymorphicGenerics> = ComponentProps<G> & ComponentVariants<G>;
 /**
- * Polymorphic rendering controls.
+ * Props that control how the component renders.
  *
- * These describe *how* the component renders rather than the data it owns.
- *
- * `children` and `asChild` are intentionally omitted so each render mode
- * can provide its own stricter contract.
+ * `children` and `asChild` are intentionally omitted so each render
+ * strategy can define its own contract.
  */
 type PolymorphicControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = {
     /**
@@ -398,22 +408,21 @@ type PolymorphicControlProps<G extends PolymorphicGenerics, TAs extends ElementT
     ref?: Ref<ElementRef<TAs>>;
 };
 /**
- * Complete set of props owned by the component.
+ * All props reserved by the polymorphic component.
  *
- * Used primarily as the exclusion list when inheriting intrinsic JSX props.
+ * Used primarily to exclude conflicting intrinsic JSX props.
  */
 type ControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = OwnedProps<G> & PolymorphicControlProps<G, TAs>;
 /**
- * Intrinsic JSX props after removing every prop owned by the component.
+ * Intrinsic JSX props after removing every reserved component prop.
  *
- * Component props always win over intrinsic props with the same name.
+ * Component-defined props always take precedence.
  */
 type IntrinsicPropsWithoutOwned<G extends PolymorphicGenerics, TAs extends ElementType> = Omit<IntrinsicJSXProps<TAs>, keyof ControlProps<G, TAs> | 'children'>;
 /**
- * Base props shared by every render mode.
+ * Props shared by every rendering strategy.
  *
- * Render modes contribute only their discriminants (`asChild`, `render`,
- * `children`, etc.).
+ * Each render mode contributes only its discriminating props.
  */
 type BaseProps<G extends PolymorphicGenerics, TAs extends ElementType> = IntrinsicPropsWithoutOwned<G, TAs> & ControlProps<G, TAs>;
 /** Standard rendering (`asChild` absent or false). */
@@ -433,12 +442,9 @@ type SlotRenderMode = {
     children: ReactElement | NonEmptyTuple<ReactElement>;
 };
 /**
- * Render callback.
- *
- * The callback receives fully resolved props (classes, refs, filtered props)
- * and is responsible for rendering the target element.
+ * Render callback mode.
  *
- * This provides the flexibility of `asChild` without `cloneElement`.
+ * Receives the fully resolved props and returns the rendered element.
  */
 type CallbackRenderMode = {
     render: (props: RenderCallbackProps) => ReactElement;
@@ -464,16 +470,26 @@ type PolymorphicWithRender<G extends PolymorphicGenerics, TAs extends ElementTyp
 /**
  * A polymorphic React component.
  *
- * Overloads form a discriminated union:
+ * Overloads provide three rendering strategies:
  *
- * • `render`   → render callback
- * • `asChild`  → Slot rendering
- * • otherwise  → normal rendering
+ * - `render`   — render callback
+ * - `asChild`  — slot rendering
+ * - default    — standard polymorphic rendering
  */
 type PolymorphicComponent<G extends PolymorphicGenerics> = {
     <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithRender<G, TAs>): ReactElement;
     <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithAsChild<G, TAs>): ReactElement;
     <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicProps<G, TAs>): ReactElement;
+    /**
+     * Non-generic fallback overload used for type extraction.
+     *
+     * TypeScript resolves conditional types such as
+     * `React.ComponentProps<typeof Component>` against only the final
+     * overload. Anchoring that overload to the default element preserves
+     * correct prop inference for tools such as Storybook and
+     * `React.ComponentProps`.
+     */
+    (props: PolymorphicProps<G, DefaultOf<G>>): ReactElement;
     displayName?: string;
 };
 

package/dist/solid/index.d.ts

@@ -249,6 +249,16 @@ type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
      */
     readonly diagnostics?: Diagnostics | DiagnosticsMode;
     readonly aria?: readonly AriaRule[];
+    /**
+     * Rules that need `AriaPolicyEngine`'s fix-application/caching machinery
+     * (`AriaRule`'s `readsProps`, fixable `AriaFix` results) but have no
+     * relationship to ARIA semantics — an HTML fact or a security check like a
+     * dangerous-URL-scheme guard, for example. Evaluated together with `aria`
+     * (both run through the same engine, merged into one rule set) — this is a
+     * separate bucket purely so a non-ARIA rule doesn't have to sit under the
+     * misleading `aria` name to get the machinery it needs.
+     */
+    readonly rules?: readonly AriaRule[];
     readonly children?: readonly ChildRuleInput[];
     /**
      * When true, only children matching a `children` rule (or text, per `allowText`)
@@ -332,6 +342,15 @@ type PolymorphicProps<G extends PolymorphicGenerics, TAs extends ElementType = D
 }) | AsChildProps<G>>;
 type PolymorphicComponent<G extends PolymorphicGenerics> = {
     <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicProps<G, TAs>): JSX.Element;
+    /**
+     * Non-generic fallback overload used for type extraction.
+     *
+     * TypeScript resolves conditional types such as
+     * `ComponentProps<typeof Component>` against only the final overload.
+     * Anchoring that overload to the default element preserves correct prop
+     * inference for tools such as Storybook and `ComponentProps`.
+     */
+    (props: PolymorphicProps<G, DefaultOf<G>>): JSX.Element;
     displayName?: string;
 };