praxis-kit 4.1.2 → 5.0.0

package/dist/solid/index.js

@@ -1856,17 +1856,22 @@ var RuleValidator = class _RuleValidator extends InvariantBase {
 };
 
 // ../../lib/contract/src/children/children-evaluator.ts
+var isTextLike = (child) => isString(child) || isNumber(child);
 var ChildrenEvaluator = class extends InvariantBase {
   #context;
   #rules;
   #ruleNames;
   #matcher;
   #ruleValidator;
-  constructor(rules, diagnostics, context = "Component") {
+  #exclusiveChildren;
+  #allowText;
+  constructor(rules, diagnostics, context = "Component", options = {}) {
     super(diagnostics);
     this.#context = context;
     this.#rules = rules.map((r) => normalizeChildRule(r));
     this.#ruleNames = this.#rules.map((r) => r.name);
+    this.#exclusiveChildren = options.exclusiveChildren ?? false;
+    this.#allowText = options.allowText ?? true;
     iterate.forEach(this.#rules, (rule) => {
       const { name, position, cardinality } = rule;
       if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
@@ -1880,8 +1885,17 @@ var ChildrenEvaluator = class extends InvariantBase {
   }
   evaluate(children) {
     if (!this.active) return;
-    const { matrix, unexpectedIndices, ambiguousIndices } = this.#matcher.match(children);
+    const {
+      matrix,
+      unexpectedIndices: rawUnexpectedIndices,
+      ambiguousIndices
+    } = this.#matcher.match(children);
     this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    const unexpectedIndices = new Set(
+      [...rawUnexpectedIndices].filter(
+        (ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren
+      )
+    );
     if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
     const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
     iterate.forEach(violating, (ci) => {
@@ -2003,8 +2017,11 @@ function metadata(name = "metadata") {
 function firstOptional(name, tag) {
   return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
 }
-function contract(children) {
-  return { diagnostics: warnDiagnostics, children };
+function contract(children, options) {
+  return { diagnostics: warnDiagnostics, children, ...options };
+}
+function closedContract(children) {
+  return contract(children, { exclusiveChildren: true });
 }
 function ariaContract(aria) {
   return { diagnostics: warnDiagnostics, aria };
@@ -2030,8 +2047,10 @@ var VOID_TAGS = [
 ];
 var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
 var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
-var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
-var tableContract = contract([
+var listContract = closedContract([
+  { name: "list-item", match: isTag("li", ...METADATA_TAGS) }
+]);
+var tableContract = closedContract([
   firstOptional("caption", "caption"),
   { name: "colgroup", match: isTag("colgroup") },
   { name: "thead", match: isTag("thead"), cardinality: { max: 1 } },
@@ -2039,29 +2058,31 @@ var tableContract = contract([
   { name: "tfoot", match: isTag("tfoot"), cardinality: { max: 1 } },
   { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
 ]);
-var tableBodyContract = contract([
+var tableBodyContract = closedContract([
   { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
 ]);
-var tableRowContract = contract([
+var tableRowContract = closedContract([
   { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
 ]);
-var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
-var dlContract = contract([
+var colgroupContract = closedContract([
+  { name: "column", match: isTag("col", "template") }
+]);
+var dlContract = closedContract([
   { name: "term", match: isTag("dt") },
   { name: "description", match: isTag("dd") },
   { name: "group", match: isTag("div") },
   metadata()
 ]);
-var selectContract = contract([
+var selectContract = closedContract([
   { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
 ]);
-var optgroupContract = contract([
+var optgroupContract = closedContract([
   { name: "option", match: isTag("option", ...METADATA_TAGS) }
 ]);
-var datalistContract = contract([
+var datalistContract = closedContract([
   { name: "option", match: isTag("option", ...METADATA_TAGS) }
 ]);
-var pictureContract = contract([
+var pictureContract = closedContract([
   { name: "source", match: isTag("source", ...METADATA_TAGS) },
   { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
 ]);
@@ -2077,23 +2098,18 @@ var mediaContract = contract([
   metadata(),
   { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
 ]);
-var headContract = contract([
+var headContract = closedContract([
   {
     name: "metadata",
     match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
   }
 ]);
-var htmlContract = contract([
+var htmlContract = closedContract([
   { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
   { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
 ]);
-var voidContract = contract([]);
-var textOnlyContract = contract([
-  {
-    name: "text",
-    match: (child) => isString(child) || isNumber(child)
-  }
-]);
+var voidContract = contract([], { exclusiveChildren: true, allowText: false });
+var textOnlyContract = contract([], { exclusiveChildren: true });
 var landmarkContract = ariaContract([landmarkRoleRule, landmarkNameAdvisory]);
 var dialogContract = ariaContract([requireAccessibleName]);
 var menuContract = ariaContract([requireAccessibleName]);
@@ -2138,9 +2154,15 @@ var htmlContracts = {
 var htmlDiagnostics = warnDiagnostics2;
 function buildEvaluatorMap() {
   const map2 = /* @__PURE__ */ new Map();
-  iterate.forEachEntry(htmlContracts, (tag, { children }) => {
-    if (children?.length) {
-      map2.set(tag, new ChildrenEvaluator(children, htmlDiagnostics, `<${tag}>`));
+  iterate.forEachEntry(htmlContracts, (tag, { children, exclusiveChildren, allowText }) => {
+    if (children?.length || exclusiveChildren || allowText === false) {
+      map2.set(
+        tag,
+        new ChildrenEvaluator(children ?? [], htmlDiagnostics, `<${tag}>`, {
+          exclusiveChildren,
+          allowText
+        })
+      );
     }
   });
   return map2;
@@ -2351,7 +2373,7 @@ function definePipeline(factory) {
 }
 
 // ../core/src/options/resolve-factory-options.ts
-import { silentDiagnostics } from "../_shared/diagnostics.js";
+import { resolveDiagnostics, silentDiagnostics } from "../_shared/diagnostics.js";
 var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
 function composeNormalizers(normalizers, fn) {
   if (!normalizers?.length) return fn;
@@ -2372,7 +2394,7 @@ function resolveFactoryOptions(options = {}) {
   const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
   return Object.freeze({
     defaultTag: options.tag ?? "div",
-    diagnostics: enforcement?.diagnostics ?? silentDiagnostics,
+    diagnostics: resolveDiagnostics(enforcement?.diagnostics, silentDiagnostics),
     variantKeys,
     ...whenDefined("displayName", options.name),
     ...whenDefined("defaultProps", options.defaults),
@@ -2385,6 +2407,8 @@ function resolveFactoryOptions(options = {}) {
     ...whenDefined("normalizeFn", composedNormalizeFn),
     ...whenDefined("ariaRules", enforcement?.aria),
     ...whenDefined("childRules", enforcement?.children),
+    ...whenDefined("exclusiveChildren", enforcement?.exclusiveChildren),
+    ...whenDefined("allowText", enforcement?.allowText),
     ...whenDefined("allowedAs", enforcement?.allowedAs),
     ...whenDefined("precomputedClasses", styling?.precomputedClasses)
   });
@@ -2569,16 +2593,22 @@ function buildCoreRuntime(normalized) {
 }
 
 // ../../lib/adapter-utils/src/runtime/build-engines.ts
-function buildEngines(diagnostics, childRules, context) {
-  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
+function buildEngines(diagnostics, childRules, context, childrenOptions) {
+  const { exclusiveChildren, allowText } = childrenOptions ?? {};
+  return childRules?.length || exclusiveChildren || allowText === false ? {
+    childrenEvaluator: new ChildrenEvaluator(childRules ?? [], diagnostics, context, {
+      exclusiveChildren,
+      allowText
+    })
+  } : {};
 }
 
 // ../../lib/adapter-utils/src/runtime/resolve-adapter-common-options.ts
-import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics3 } from "../_shared/diagnostics.js";
+import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics3, resolveDiagnostics as resolveDiagnostics2 } from "../_shared/diagnostics.js";
 function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics2) {
   return {
     name: options.name ?? defaultName,
-    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
+    diagnostics: resolveDiagnostics2(options.enforcement?.diagnostics, defaultDiagnostics)
   };
 }
 
@@ -2633,7 +2663,11 @@ function buildRuntime(options) {
   const { childrenEvaluator } = buildEngines(
     normalized.diagnostics,
     normalized.enforcement?.children,
-    normalized.name
+    normalized.name,
+    {
+      exclusiveChildren: normalized.enforcement?.exclusiveChildren,
+      allowText: normalized.enforcement?.allowText
+    }
   );
   const filterProps = composeFilter(ownedKeys, normalized.filterProps);
   const slotValidator = new SlotValidator(normalized.name, normalized.diagnostics);
@@ -2646,9 +2680,10 @@ function buildRuntime(options) {
 }
 
 // ../../adapters/solid/src/render.tsx
+import { createComponent as _$createComponent } from "solid-js/web";
+import { mergeProps as _$mergeProps } from "solid-js/web";
 import { createEffect, createMemo, splitProps } from "solid-js";
 import { Dynamic } from "solid-js/web";
-import { jsx } from "solid-js/jsx-runtime";
 var SPLIT_KEYS = ["as", "asChild", "children", "class", "recipe", "ref"];
 function toChildArray(children) {
   if (children === void 0 || children === null) return [];
@@ -2656,22 +2691,38 @@ function toChildArray(children) {
   return [children];
 }
 function buildElementProps(props, classStr, ref, children) {
-  const { role, ...rest } = props;
+  const {
+    role,
+    ...rest
+  } = props;
   return {
     ...rest,
     class: classStr,
-    ...ref !== void 0 && { ref },
-    ...children !== void 0 && { children },
-    ...isKnownAriaRole(role) && { role }
+    ...ref !== void 0 && {
+      ref
+    },
+    ...children !== void 0 && {
+      children
+    },
+    ...isKnownAriaRole(role) && {
+      role
+    }
   };
 }
 function buildSlotProps(props, classStr, ref) {
-  const { role, ...rest } = props;
+  const {
+    role,
+    ...rest
+  } = props;
   return {
     ...rest,
     class: classStr,
-    ...ref !== void 0 && { ref },
-    ...isKnownAriaRole(role) && { role }
+    ...ref !== void 0 && {
+      ref
+    },
+    ...isKnownAriaRole(role) && {
+      role
+    }
   };
 }
 function resolveTag2(runtime, as) {
@@ -2688,9 +2739,7 @@ function tryRenderAsChild(known, filteredProps, resolvedClass, slotValidator) {
   }
   if (!slotValidator.assertRenderFn(known.children)) return null;
   const renderFn = known.children;
-  return createMemo(
-    () => renderFn(buildSlotProps(filteredProps(), resolvedClass(), known.ref))
-  );
+  return createMemo(() => renderFn(buildSlotProps(filteredProps(), resolvedClass(), known.ref)));
 }
 function render({
   runtime,
@@ -2706,32 +2755,24 @@ function render({
   const normalizedProps = createMemo(() => {
     const base = runtime.options.normalizeFn ? runtime.options.normalizeFn(mergedProps()) : mergedProps();
     const htmlNormalizers = runtime.options.htmlPropNormalizersFn?.(tag());
-    return htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), base) : base;
+    return htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({
+      ...acc,
+      ...fn(acc)
+    }), base) : base;
   });
-  const resolvedClass = createMemo(
-    () => runtime.resolveClasses(
-      tag(),
-      normalizedProps(),
-      known.class,
-      known.recipe
-    )
-  );
-  const filteredProps = createMemo(
-    () => applyFilter(normalizedProps(), filterProps, runtime.options.variantKeys)
-  );
-  const { allowedAs } = runtime.options;
+  const resolvedClass = createMemo(() => runtime.resolveClasses(tag(), normalizedProps(), known.class, known.recipe));
+  const filteredProps = createMemo(() => applyFilter(normalizedProps(), filterProps, runtime.options.variantKeys));
+  const {
+    allowedAs
+  } = runtime.options;
   if (allowedAs !== void 0) {
-    createEffect(
-      () => enforceAllowedAs(tag(), allowedAs, runtime.options.diagnostics, runtime.options.displayName)
-    );
+    createEffect(() => enforceAllowedAs(tag(), allowedAs, runtime.options.diagnostics, runtime.options.displayName));
   }
   if (process.env.NODE_ENV !== "production" && childrenEvaluator) {
     createEffect(() => childrenEvaluator.evaluate(toChildArray(known.children)));
   }
   if (process.env.NODE_ENV !== "production") {
-    createEffect(
-      () => runtime.options.htmlChildrenEvaluatorFn?.(tag())?.evaluate(toChildArray(known.children))
-    );
+    createEffect(() => runtime.options.htmlChildrenEvaluatorFn?.(tag())?.evaluate(toChildArray(known.children)));
   }
   const slotResult = tryRenderAsChild(known, filteredProps, resolvedClass, slotValidator);
   if (slotResult !== null) return slotResult;
@@ -2739,7 +2780,11 @@ function render({
     const ep = buildElementProps(filteredProps(), resolvedClass(), known.ref, known.children);
     return resolveDomProps(tag(), ep, runtime);
   });
-  return /* @__PURE__ */ jsx(Dynamic, { component: tag(), ...domProps() });
+  return _$createComponent(Dynamic, _$mergeProps({
+    get component() {
+      return tag();
+    }
+  }, () => domProps()));
 }
 
 // ../../adapters/solid/src/create-contract-component.ts

package/dist/svelte/Polymorphic.svelte

@@ -0,0 +1,146 @@
+<script module lang="ts">
+  declare const process: { env: { NODE_ENV: string } }
+</script>
+
+<script lang="ts">
+  import { enforceAllowedAs, isKnownAriaRole } from '@praxis-kit/core'
+  import type { ElementType, IntrinsicProps } from '@praxis-kit/core'
+  import { isObject, isString } from '@praxis-kit/primitive'
+  import { applyFilter } from '@praxis-kit/adapter-utils'
+  import type { Snippet } from 'svelte'
+  import type {
+    PolymorphicComponentProps,
+    ResolvedAttributes,
+    StyleObject,
+    UnknownProps,
+  } from './types'
+
+  let {
+    bundle,
+    as: asProp,
+    asChild,
+    class: cls,
+    recipe,
+    children,
+    ...rest
+  }: PolymorphicComponentProps = $props()
+  let hostEl: Element | undefined = $state()
+
+  // Svelte 5 event delegation requires lowercase handler names (onclick, onfocus…).
+  // Normalize React-style camelCase handlers so spreads on <svelte:element> work.
+  const EVENT_RE = /^on[A-Z]/
+  function normalizeEventKeys(props: UnknownProps): UnknownProps {
+    const out: ResolvedAttributes = {}
+    for (const k in props) {
+      out[EVENT_RE.test(k) ? k.toLowerCase() : k] = (props as ResolvedAttributes)[k]
+    }
+    return out as UnknownProps
+  }
+
+  function serializeStyle(style: StyleObject): string {
+    let result = ''
+    for (const key in style) {
+      const value = style[key]
+      if (value == null) continue
+      if (result) result += ';'
+      result += `${key.replace(/([A-Z])/g, '-$1').toLowerCase()}:${value}`
+    }
+    return result
+  }
+
+  function buildDomProps(
+    props: UnknownProps,
+    classStr: string,
+    tag: ElementType,
+  ): ResolvedAttributes {
+    const { role, style, ...r } = normalizeEventKeys(props)
+    const styleStr = isObject(style, true)
+      ? serializeStyle(style as StyleObject)
+      : (style as string | undefined)
+    const ep: IntrinsicProps = {
+      ...(r as IntrinsicProps),
+      class: classStr,
+      ...(styleStr !== undefined && { style: styleStr }),
+    }
+    if (isKnownAriaRole(role)) ep.role = role
+    if (!isString(tag)) return ep as ResolvedAttributes
+    return bundle.runtime.resolveAria(tag, ep).props as ResolvedAttributes
+  }
+
+  function buildSlotProps(props: UnknownProps, classStr: string): UnknownProps {
+    const { role, ...r } = props
+    return {
+      ...r,
+      class: classStr,
+      ...(isKnownAriaRole(role) && { role }),
+    }
+  }
+
+  const tag = $derived(bundle.runtime.resolveTag(asProp as ElementType | undefined))
+  const mergedProps = $derived(bundle.runtime.resolveProps(rest as UnknownProps))
+  const normalizedProps = $derived.by(() => {
+    const { runtime: { options } } = bundle
+    // Folded into this derived (rather than a standalone one) so it's guaranteed to run on
+    // both SSR and DOM — $derived is lazy in Svelte 5 and only evaluates when read; this one
+    // is read downstream by resolvedClass/filteredProps/domProps, which the template renders.
+    if (options.allowedAs !== undefined) {
+      enforceAllowedAs(
+        tag,
+        options.allowedAs,
+        options.diagnostics,
+        options.displayName,
+      )
+    }
+    const base =
+      typeof options.normalizeFn === 'function' ? options.normalizeFn(mergedProps) : mergedProps
+
+    const htmlNormalizers = options.htmlPropNormalizersFn?.(tag)
+
+    if (!htmlNormalizers?.length) {
+      return base
+    }
+
+    return htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), base)
+  })
+  const resolvedClass = $derived(
+    bundle.runtime.resolveClasses(tag, normalizedProps, cls as string | undefined, recipe),
+  )
+  const filteredProps = $derived(
+    applyFilter(normalizedProps, bundle.filterProps, bundle.runtime.options.variantKeys),
+  )
+  const domProps = $derived(buildDomProps(filteredProps, resolvedClass, tag))
+
+  // Resolves whether to render as child slot; also enforces as+asChild mutual exclusion.
+  const useAsChild = $derived.by(() => {
+    if (!asChild) return false
+    if (asProp !== undefined) {
+      bundle.slotValidator.assertExclusive()
+      return false
+    }
+    return true
+  })
+
+  // DOM-only (like Lit skipping htmlChildrenEvaluatorFn for its SSR renderToString). Merely
+  // *registering* $effect during svelte/server's render() throws ("effect_orphan") — it's not
+  // enough to no-op inside the callback, the rune call itself must never happen during SSR.
+  // Reads real child nodes off the mounted host, same approach as Lit's Array.from(this.childNodes).
+  // Not reachable in the asChild branch — no host element there.
+  if (typeof document !== 'undefined') {
+    $effect(() => {
+      if (process.env.NODE_ENV === 'production' || !hostEl) return
+      const childArray = Array.from(hostEl.childNodes)
+      bundle.childrenEvaluator?.evaluate(childArray)
+      bundle.runtime.options.htmlChildrenEvaluatorFn?.(tag)?.evaluate(childArray)
+    })
+  }
+</script>
+
+{#if useAsChild}
+  {#if children}
+    {@render (children as Snippet<[UnknownProps]>)(buildSlotProps(filteredProps, resolvedClass))}
+  {/if}
+{:else}
+  <svelte:element this={tag as string} bind:this={hostEl} {...domProps}>
+    {@render (children as Snippet | undefined)?.()}
+  </svelte:element>
+{/if}

package/dist/svelte/index.d.ts

@@ -1,5 +1,5 @@
 import { RequireAtLeastOne, Simplify, ReadonlyDeep } from 'type-fest';
-import { Diagnostics, DiagnosticInput } from '../_shared/diagnostics.js';
+import { Diagnostics, DiagnosticInput, DiagnosticsMode } from '../_shared/diagnostics.js';
 
 type StringMap<T = unknown> = Record<string, T>;
 type AnyRecord = StringMap<unknown>;
@@ -217,9 +217,25 @@ type AriaRule<C extends AriaContext = AriaContext> = (context: C) => readonly Ar
 type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
 
 type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
-    readonly diagnostics?: Diagnostics;
+    /**
+     * Accepts a preset name (`'warn'`, `'throw'`, `'silent'`) or a full `Diagnostics`
+     * instance for custom reporting/policy. The string form needs no import from
+     * `@praxis-kit/diagnostics`.
+     */
+    readonly diagnostics?: Diagnostics | DiagnosticsMode;
     readonly aria?: readonly AriaRule[];
     readonly children?: readonly ChildRuleInput[];
+    /**
+     * When true, only children matching a `children` rule (or text, per `allowText`)
+     * are valid — anything else is rejected. Default: false (open — children not
+     * matching any rule are allowed).
+     */
+    readonly exclusiveChildren?: boolean;
+    /**
+     * When false, text/number child nodes are rejected regardless of exclusiveChildren
+     * or any listed rule. Default: true.
+     */
+    readonly allowText?: boolean;
     readonly props?: readonly PropNormalizer[];
     /** Restricts the `as` prop to this set of tags. Violations route through diagnostics. */
     readonly allowedAs?: readonly TAllowed[];
@@ -265,6 +281,8 @@ type ResolvedFactoryOptions<TDefault extends ElementType = ElementType, Props ex
     readonly htmlPropNormalizersFn?: (tag: unknown) => readonly PropNormalizer[] | undefined;
     readonly htmlChildrenEvaluatorFn?: (tag: unknown) => ChildrenEvaluator$1 | undefined;
     readonly childRules?: readonly ChildRuleInput[];
+    readonly exclusiveChildren?: boolean;
+    readonly allowText?: boolean;
     readonly ariaRules?: readonly AriaRule[];
     readonly allowedAs?: readonly ElementType[];
     readonly precomputedClasses?: Readonly<Record<string, string>>;
@@ -302,9 +320,22 @@ declare abstract class InvariantBase {
     protected invariant(condition: unknown, input: DiagnosticInput): void;
 }
 
+type ChildrenEvaluatorOptions = {
+    /**
+     * When true, only children matching a rule (or text, per `allowText`) are
+     * valid — anything else is rejected. Default: false (open — children not
+     * matching any rule are allowed).
+     */
+    readonly exclusiveChildren?: boolean | undefined;
+    /**
+     * When false, text/number child nodes are rejected regardless of
+     * exclusiveChildren or any listed rule. Default: true.
+     */
+    readonly allowText?: boolean | undefined;
+};
 declare class ChildrenEvaluator extends InvariantBase {
     #private;
-    constructor(rules: readonly ChildRuleInput[], diagnostics: Diagnostics, context?: string);
+    constructor(rules: readonly ChildRuleInput[], diagnostics: Diagnostics, context?: string, options?: ChildrenEvaluatorOptions);
     evaluate(children: unknown[]): void;
 }