praxis-kit 6.5.0 → 6.6.0

package/dist/{chunk-AM5J6PY3.js → chunk-OCG5VM4H.js}

@@ -28,6 +28,9 @@ function isNull(value) {
 function isNonNull(value) {
   return value != null;
 }
+function isNullish(value) {
+  return isNull(value) || value === void 0;
+}
 
 // ../../lib/primitive/src/utils/type-guards.ts
 function isObject(value, excludeArrays = false) {
@@ -655,20 +658,29 @@ function isAriaAttributeValidForRole(attr, role) {
 }
 
 // ../../lib/primitive/src/guards/aria/is-aria-role.ts
+function lookupImplicitRole(tag) {
+  return IMPLICIT_ROLE_RECORD[tag];
+}
 function isStrongImplicitRole(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+  const role = lookupImplicitRole(tag);
+  return !isNullish(role) && STRONG_ROLES_SET.has(role);
 }
-function isStandaloneTag(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+function hasStandaloneRole(tag) {
+  const role = lookupImplicitRole(tag);
+  return !isNullish(role) && STANDALONE_ROLES_SET.has(role);
 }
-function getInputImplicitRole(type) {
-  if (!isString(type) || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
-  return INPUT_TYPE_ROLE_MAP[type];
+var LIST_ELIGIBLE_INPUT_TYPES = /* @__PURE__ */ new Set(["text", "search", "tel", "url", "email"]);
+function getInputImplicitRole(type, list) {
+  if (!isString(type)) return void 0;
+  const role = INPUT_TYPE_ROLE_MAP[type];
+  if (!role) return void 0;
+  if (!isNullish(list) && LIST_ELIGIBLE_INPUT_TYPES.has(type)) {
+    return "combobox";
+  }
+  return role;
 }
 function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
-  const isNamed = isString(ariaLabel) || isString(ariaLabelledBy);
+  const isNamed = isString(ariaLabel) && ariaLabel.trim().length > 0 || isString(ariaLabelledBy) && ariaLabelledBy.trim().length > 0;
   if (!isNamed) return void 0;
   if (tag === "section") return "region";
   if (tag === "form") return "form";
@@ -720,7 +732,7 @@ function isTag(...args) {
 // ../../lib/contract/src/aria/aria-role-policy.ts
 function getImplicitRole(tag, props) {
   if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
-  if (tag === "input") return getInputImplicitRole(props?.type);
+  if (tag === "input") return getInputImplicitRole(props?.type, props?.list);
   if (tag === "img") return props?.alt === "" ? "none" : "img";
   if (tag === "section" || tag === "form") {
     return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
@@ -1409,7 +1421,6 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     if (!isIntrinsicTag(tag)) return { proceed: false, result: { props, violations: [] } };
     const implicitRole = getImplicitRole(tag, props);
     const hasRole2 = isNonNull(implicitRole) || isString(props.role) && props.role.length > 0;
-    if (!hasRole2) return { proceed: false, result: { props, violations: [] } };
     const normalized = _AriaPolicyEngine.#normalizeEmptyRole(tag, props);
     const workingProps = normalized.normalized ? normalized.result.props : props;
     const preExistingViolations = normalized.normalized ? normalized.result.violations : [];
@@ -1419,6 +1430,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       tag,
       implicitRole,
       effectiveRole,
+      hasRole: hasRole2,
       props: workingProps,
       preExistingViolations,
       context: { tag, props: workingProps, implicitRole, effectiveRole }
@@ -1462,6 +1474,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   static evaluate(tag, props) {
     const derived = _AriaPolicyEngine.#deriveContext(tag, props);
     if (!derived.proceed) return derived.result;
+    if (!derived.hasRole)
+      return { props: derived.props, violations: [...derived.preExistingViolations] };
     const {
       tag: narrowedTag,
       implicitRole,
@@ -1486,10 +1500,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
       props: workingProps,
       preExistingViolations
     } = derived;
-    const { violations, fixes } = _AriaPolicyEngine.#runRules(
-      [..._AriaPolicyEngine.#getRules(context), ...extraRules],
-      context
-    );
+    const rules = derived.hasRole ? [..._AriaPolicyEngine.#getRules(context), ...extraRules] : extraRules;
+    const { violations, fixes } = _AriaPolicyEngine.#runRules(rules, context);
     const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, workingProps, fixes);
     return { props: next, violations: [...preExistingViolations, ...violations] };
   }
@@ -1688,7 +1700,7 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   static #checkStandaloneRegion({ tag, props, implicitRole }) {
     const role = props.role;
     if (role !== "region") return NO_VIOLATIONS2;
-    if (!isStandaloneTag(tag)) return NO_VIOLATIONS2;
+    if (!hasStandaloneRole(tag)) return NO_VIOLATIONS2;
     const diagnostic = HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag);
     return [
       {
@@ -3178,6 +3190,11 @@ function composeNormalizers(normalizers, fn) {
 function whenDefined(key, value) {
   return value === void 0 ? {} : { [key]: value };
 }
+function mergeAriaRules(aria, rules) {
+  if (!aria?.length) return rules;
+  if (!rules?.length) return aria;
+  return [...aria, ...rules];
+}
 function resolveFactoryOptions(options = {}) {
   const { styling, enforcement } = options;
   const composedNormalizeFn = composeNormalizers(enforcement?.props, options.normalize);
@@ -3198,7 +3215,7 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("defaultVariants", styling?.defaults),
     ...whenDefined("compoundVariants", styling?.compounds),
     ...whenDefined("normalizeFn", composedNormalizeFn),
-    ...whenDefined("ariaRules", enforcement?.aria),
+    ...whenDefined("ariaRules", mergeAriaRules(enforcement?.aria, enforcement?.rules)),
     ...whenDefined("childRules", enforcement?.children),
     ...whenDefined("exclusiveChildren", enforcement?.exclusiveChildren),
     ...whenDefined("allowText", enforcement?.allowText),

package/dist/contract/index.d.ts

@@ -231,6 +231,16 @@ type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
      */
     readonly diagnostics?: Diagnostics$1 | 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`)

package/dist/contract/index.js

@@ -313,6 +313,7 @@ var selectedContract = stateContract([selectedProps]);
 function mergeContracts(...contracts) {
   const props = contracts.flatMap((c) => c.props ?? []);
   const aria = contracts.flatMap((c) => c.aria ?? []);
+  const rules = contracts.flatMap((c) => c.rules ?? []);
   const children = contracts.flatMap((c) => c.children ?? []);
   let diagnostics;
   let allowedAs;
@@ -323,6 +324,7 @@ function mergeContracts(...contracts) {
   return {
     ...props.length > 0 && { props },
     ...aria.length > 0 && { aria },
+    ...rules.length > 0 && { rules },
     ...children.length > 0 && { children },
     ...diagnostics !== void 0 && { diagnostics },
     ...allowedAs !== void 0 && { allowedAs }

package/dist/guards/index.d.ts

@@ -22,15 +22,24 @@ type TagChild = {
 };
 declare function isTag(tag: string, ...tags: readonly string[]): (child: unknown) => child is TagChild;
 declare function isTag(child: unknown, tag: string, ...tags: readonly string[]): boolean;
+/**
+ * A vnode (or text node) that qualifies as flow content: text nodes
+ * (string/number) always qualify, and elements/components qualify unless
+ * their resolved tag is blocked — see `isFlowContent`.
+ */
+type FlowContentChild = string | number | TagChild;
 /**
  * Checks whether a vnode is flow content per the HTML content model: text nodes
  * (string/number) always qualify, and elements/components qualify unless their
  * resolved tag is in the blocked set.
+ *
+ * Returns a type guard (not a plain boolean predicate) so it can be used
+ * directly as a `ChildRuleInput.match`, which requires the narrowed type.
  */
-declare function isFlowContent(...blockedTags: readonly string[]): (child: unknown) => boolean;
+declare function isFlowContent(...blockedTags: readonly string[]): (child: unknown) => child is FlowContentChild;
 
 declare function isObject(value: unknown, excludeArrays: true): value is AnyRecord;
 declare function isObject(value: unknown, excludeArrays?: false): value is object;
 declare function isString(value: unknown): value is string;
 
-export { getTag, isFlowContent, isObject, isString, isTag };
+export { type FlowContentChild, type TagChild, getTag, isFlowContent, isObject, isString, isTag };

package/dist/html/index.d.ts

@@ -0,0 +1,98 @@
+import { ReadonlyDeep } from 'type-fest';
+import { DiagnosticInput } from '../_shared/diagnostics.js';
+
+type StringMap<T = unknown> = Record<string, T>;
+type AnyRecord = StringMap<unknown>;
+
+type IntrinsicTag = keyof HTMLElementTagNameMap;
+
+declare const KNOWN_ARIA_ROLES: readonly ["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"];
+type KnownAriaRole = (typeof KNOWN_ARIA_ROLES)[number];
+
+type AriaRole = KnownAriaRole | (string & {});
+type IntrinsicProps = AnyRecord & {
+    role?: AriaRole;
+};
+
+type ValidResult = {
+    valid: true;
+};
+
+type AriaContext = {
+    readonly tag: IntrinsicTag;
+    readonly implicitRole: AriaRole | undefined;
+    readonly effectiveRole: string | undefined;
+    readonly props: ReadonlyDeep<IntrinsicProps>;
+};
+
+type RemoveAttributeFixKind = `removeAttribute:${string}`;
+type InjectLiveFixKind = `injectLive:${string}`;
+type FixKind = 'removeRole' | 'setRole' | 'normalizeRelevantAll' | RemoveAttributeFixKind | InjectLiveFixKind;
+
+type AriaFixResult = {
+    applied: false;
+    next: ReadonlyDeep<IntrinsicProps>;
+} | {
+    applied: true;
+    next: ReadonlyDeep<IntrinsicProps>;
+    previous: ReadonlyDeep<IntrinsicProps>;
+};
+type AriaFix = {
+    readonly kind: FixKind;
+    readonly priority?: number;
+    readonly source?: string;
+    readonly apply: (context: AriaContext) => AriaFixResult;
+};
+
+type Severity = 'error' | 'warning' | (string & {});
+
+type AriaInvalidBase<M extends string = string> = {
+    valid: false;
+    severity: Severity;
+    message?: M;
+    attribute?: string;
+    diagnostic?: DiagnosticInput;
+};
+type AriaInvalidWithFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: true;
+    fix: AriaFix;
+};
+type AriaInvalidWithoutFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: false;
+};
+type AriaInvalidResult<M extends string = string> = AriaInvalidWithFix<M> | AriaInvalidWithoutFix<M>;
+type AriaResult = ValidResult | AriaInvalidResult;
+
+type AriaRule<C extends AriaContext = AriaContext> = ((context: C) => readonly AriaResult[]) & {
+    readonly readsProps?: readonly string[];
+    readonly tags?: readonly string[];
+};
+
+declare const landmarkRoleRule: AriaRule;
+declare function requireAccessibleName({ tag, props }: AriaContext): readonly AriaResult[];
+declare const landmarkNameAdvisory: AriaRule;
+declare const HTML_ARIA_RULES: readonly AriaRule[];
+
+declare const roleNotPermittedRule: AriaRule;
+
+declare const supportedInputTypeRule: AriaRule;
+declare const checkedRequiresCheckableTypeRule: AriaRule;
+declare const multipleRequiresSupportedTypeRule: AriaRule;
+declare const maxLengthRequiresTextTypeRule: AriaRule;
+declare const minLengthRequiresTextTypeRule: AriaRule;
+declare const patternRequiresTextTypeRule: AriaRule;
+declare const minRequiresNumericTypeRule: AriaRule;
+declare const maxRequiresNumericTypeRule: AriaRule;
+declare const stepRequiresNumericTypeRule: AriaRule;
+declare const acceptRequiresFileTypeRule: AriaRule;
+declare const captureRequiresFileTypeRule: AriaRule;
+declare const sizeRequiresTextTypeRule: AriaRule;
+declare const altRequiresImageTypeRule: AriaRule;
+declare const heightRequiresImageTypeRule: AriaRule;
+declare const widthRequiresImageTypeRule: AriaRule;
+declare const inputAccessibleNameRule: AriaRule;
+declare const passwordAutocompleteRule: AriaRule;
+declare const requiredReadOnlyConflictRule: AriaRule;
+declare const INPUT_RULES: readonly AriaRule[];
+
+export { HTML_ARIA_RULES, INPUT_RULES, acceptRequiresFileTypeRule, altRequiresImageTypeRule, captureRequiresFileTypeRule, checkedRequiresCheckableTypeRule, heightRequiresImageTypeRule, inputAccessibleNameRule, landmarkNameAdvisory, landmarkRoleRule, maxLengthRequiresTextTypeRule, maxRequiresNumericTypeRule, minLengthRequiresTextTypeRule, minRequiresNumericTypeRule, multipleRequiresSupportedTypeRule, passwordAutocompleteRule, patternRequiresTextTypeRule, requireAccessibleName, requiredReadOnlyConflictRule, roleNotPermittedRule, sizeRequiresTextTypeRule, stepRequiresNumericTypeRule, supportedInputTypeRule, widthRequiresImageTypeRule };