praxis-kit 6.2.3 → 6.6.0

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
-import { U as UnknownProps, E as ElementType, a as EmptyRecord, V as VariantMap, R as RecipeMap, A as AnyClassPluginFactory, b as ReactFactoryOptions, P as PolymorphicComponent, c as PolymorphicGenerics, d as ExtractPluginProps } from '../react-options-DQTX4YS_.js';
-export { e as AnyFactoryOptions, f as ElementRef, F as FactoryOptions, g as PolymorphicProps, h as PolymorphicWithAsChild, i as PolymorphicWithRender, j as RenderCallbackProps, S as Slottable, k as SlottableProps, m as composeRefs, l as defineContractComponent, m as mergeRefs } from '../react-options-DQTX4YS_.js';
+import { U as UnknownProps, E as ElementType, a as EmptyRecord, V as VariantMap, R as RecipeMap, A as AnyClassPluginFactory, b as ReactFactoryOptions, P as PolymorphicComponent, c as PolymorphicGenerics, d as ExtractPluginProps } from '../react-options-BUBVohU6.js';
+export { e as AnyFactoryOptions, f as ElementRef, F as FactoryOptions, g as PolymorphicProps, h as PolymorphicWithAsChild, i as PolymorphicWithRender, j as RenderCallbackProps, S as Slottable, k as SlottableProps, m as composeRefs, l as defineContractComponent, m as mergeRefs } from '../react-options-BUBVohU6.js';
 import * as react from 'react';
 import { ReactElement, Ref } from 'react';
 import 'type-fest';

package/dist/react/index.js

@@ -12,7 +12,7 @@ import {
   makeCloneSlotChild,
   mergeRefs,
   render
-} from "../chunk-H3D2JA3J.js";
+} from "../chunk-OCG5VM4H.js";
 
 // ../../adapters/react/src/current/slot/composeRefs.ts
 function getChildRef(element) {

package/dist/react/legacy.d.ts

@@ -1,5 +1,5 @@
-import { E as ElementType, U as UnknownProps, a as EmptyRecord, V as VariantMap, R as RecipeMap, A as AnyClassPluginFactory, b as ReactFactoryOptions, P as PolymorphicComponent, c as PolymorphicGenerics, d as ExtractPluginProps } from '../react-options-DQTX4YS_.js';
-export { e as AnyFactoryOptions, f as ElementRef, F as FactoryOptions, g as PolymorphicProps, h as PolymorphicWithAsChild, i as PolymorphicWithRender, j as RenderCallbackProps, S as Slottable, k as SlottableProps, l as defineContractComponent, m as mergeRefs } from '../react-options-DQTX4YS_.js';
+import { E as ElementType, U as UnknownProps, a as EmptyRecord, V as VariantMap, R as RecipeMap, A as AnyClassPluginFactory, b as ReactFactoryOptions, P as PolymorphicComponent, c as PolymorphicGenerics, d as ExtractPluginProps } from '../react-options-BUBVohU6.js';
+export { e as AnyFactoryOptions, f as ElementRef, F as FactoryOptions, g as PolymorphicProps, h as PolymorphicWithAsChild, i as PolymorphicWithRender, j as RenderCallbackProps, S as Slottable, k as SlottableProps, l as defineContractComponent, m as mergeRefs } from '../react-options-BUBVohU6.js';
 import * as react from 'react';
 import 'type-fest';
 import '../_shared/diagnostics.js';

package/dist/react/legacy.js

@@ -13,7 +13,7 @@ import {
   makeCloneSlotChild,
   mergeRefs,
   render
-} from "../chunk-H3D2JA3J.js";
+} from "../chunk-OCG5VM4H.js";
 
 // ../../adapters/react/src/legacy/create-contract-component.ts
 import { forwardRef as forwardRef2 } from "react";

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

@@ -237,6 +237,7 @@ type AriaResult = ValidResult | AriaInvalidResult;
 
 type AriaRule<C extends AriaContext = AriaContext> = ((context: C) => readonly AriaResult[]) & {
     readonly readsProps?: readonly string[];
+    readonly tags?: readonly string[];
 };
 
 type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
@@ -249,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`)
@@ -338,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];
@@ -366,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> = {
     /**
@@ -397,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). */
@@ -432,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;
@@ -463,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

@@ -236,6 +236,7 @@ type AriaResult = ValidResult | AriaInvalidResult;
 
 type AriaRule<C extends AriaContext = AriaContext> = ((context: C) => readonly AriaResult[]) & {
     readonly readsProps?: readonly string[];
+    readonly tags?: readonly string[];
 };
 
 type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
@@ -248,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`)
@@ -331,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;
 };