@proyecto-viviana/solidaria-components 0.3.1 → 0.4.0

package/dist/utils.js

@@ -0,0 +1,285 @@
+import { createComponent, isServer, memo } from "solid-js/web";
+import { Show, createComponent as createComponent$1, createContext, createMemo, createSignal, onMount, sharedConfig, untrack, useContext } from "solid-js";
+import { mergeProps as mergeProps$2 } from "@proyecto-viviana/solidaria";
+//#region src/utils.tsx
+/**
+* Utility functions for solidaria-components
+* Port of react-aria-components/src/utils.tsx
+*/
+const DEFAULT_SLOT = "default";
+/**
+* Resolves render props (children, class, style) based on component state.
+*
+* For SSR compatibility, children are NOT evaluated eagerly. Instead:
+* - Use `renderChildren()` to render children with current values
+* - Or access `children` directly if you need the raw prop
+*
+* This avoids the getter pattern that causes SSR hydration mismatches.
+*/
+function useRenderProps(props, values) {
+	const { class: className, style, defaultClassName = "" } = props;
+	return {
+		class: createMemo(() => {
+			const currentValues = values();
+			return typeof className === "function" ? className(currentValues) : className ?? defaultClassName;
+		}),
+		style: createMemo(() => {
+			const currentValues = values();
+			return typeof style === "function" ? style(currentValues) : style;
+		}),
+		renderChildren: () => {
+			const children = props.children;
+			return typeof children === "function" && children.length > 0 ? children(values()) : children;
+		},
+		renderChildrenStable: () => {
+			const children = props.children;
+			if (typeof children !== "function" || children.length === 0) return children;
+			return untrack(() => {
+				const snapshot = values();
+				const view = {};
+				for (const key of Object.keys(snapshot)) Object.defineProperty(view, key, {
+					enumerable: true,
+					configurable: true,
+					get: () => values()[key]
+				});
+				return children(view);
+			});
+		},
+		get children() {
+			return props.children;
+		},
+		values
+	};
+}
+function composeRenderProps(base, override) {
+	if (!base) return override ?? {};
+	if (!override) return base;
+	return {
+		children: override.children ?? base.children,
+		class: override.class ?? base.class,
+		style: override.style ?? base.style
+	};
+}
+/**
+* Creates a context that can carry either a bare value or a `slots` record.
+*/
+function createSlottedContext() {
+	return createContext(null);
+}
+/** Assigns an element to a Solid ref (callback or mutable `{ current }` object). */
+function assignRef(ref, el) {
+	if (!ref) return;
+	if (typeof ref === "function") ref(el);
+	else if (typeof ref === "object" && "current" in ref) ref.current = el;
+}
+/** Merges multiple Solid refs into one callback that forwards to each, once. */
+function mergeRefs(...refs) {
+	return (el) => {
+		const seen = /* @__PURE__ */ new Set();
+		for (const ref of refs) {
+			if (!ref || seen.has(ref)) continue;
+			seen.add(ref);
+			assignRef(ref, el);
+		}
+	};
+}
+/**
+* Resolves a (possibly slotted) context value for the given slot name. Port of
+* react-aria-components' `useSlottedContext`:
+* - `slot === null` opts out of the context entirely (returns `null`);
+* - if the context carries a `slots` record, the entry for `slot` (or
+*   {@link DEFAULT_SLOT}) is returned, throwing on an unknown slot name;
+* - otherwise the bare context value is returned.
+*/
+function useSlottedContext(context, slot) {
+	const ctx = useContext(context);
+	if (slot === null) return null;
+	if (ctx && typeof ctx === "object" && "slots" in ctx && ctx.slots) {
+		const slots = ctx.slots;
+		const slotValue = slots[slot || "default"];
+		if (!slotValue) {
+			const validSlots = Object.keys(slots).map((name) => `"${name}"`).join(", ");
+			throw new Error(slot ? `Invalid slot "${slot}". Valid slot names are ${validSlots}.` : `A slot prop is required. Valid slot names are ${validSlots}.`);
+		}
+		return slotValue;
+	}
+	return ctx;
+}
+/**
+* Merges context-provided props and a context ref into a component's own props
+* and ref. Port of react-aria-components' `useContextProps`:
+* - the context is resolved for `props.slot` via {@link useSlottedContext};
+* - props win over context props (handler props are chained by `mergeProps`);
+* - the component's own ref and the context's ref merge into one callback.
+*
+* The prop merge stays reactive (Solid `mergeProps` preserves getters), so prop
+* changes keep flowing; the context value is read once at setup, matching a single
+* upstream render.
+*/
+function useContextProps(props, ref, context) {
+	const { ref: contextRef, ...contextProps } = useSlottedContext(context, props.slot) ?? {};
+	const mergedRef = mergeRefs(ref, contextRef);
+	return [mergeProps$2(contextProps, props), mergedRef];
+}
+/**
+* Detects whether slotted content was rendered into a placeholder, for the
+* aria-label fallback pattern. Port of react-aria-components' `useSlot`: returns a
+* ref callback to attach to the placeholder and an accessor that is `true` while
+* an element is mounted there. The accessor flips to `false` after mount if the
+* ref never ran (no slotted content was provided).
+*/
+function useSlot(initialState = true) {
+	const [hasSlot, setHasSlot] = createSignal(initialState);
+	let hasRun = false;
+	const ref = (el) => {
+		hasRun = true;
+		setHasSlot(!!el);
+	};
+	onMount(() => {
+		if (!hasRun) setHasSlot(false);
+	});
+	return [ref, hasSlot];
+}
+/**
+* Nests a set of context providers around `children`. Port of
+* react-aria-components' `Provider`: each `[Context, value]` pair wraps the
+* previous result, so the LAST pair is the outermost provider — matching upstream's
+* wrap-in-iteration-order.
+*
+* `children` is read through a lazy getter inside the innermost provider so child
+* components are *created* within every provider's owner; Solid binds `useContext`
+* at component-execution time, so eager children would miss these providers.
+*/
+function Provider(props) {
+	const build = (index) => {
+		if (index < 0) return props.children;
+		const [context, value] = props.values[index];
+		return createComponent$1(context.Provider, {
+			value,
+			get children() {
+				return build(index - 1);
+			}
+		});
+	};
+	return build(props.values.length - 1);
+}
+/**
+* Converts boolean state values to data attributes
+*/
+function dataAttr(value) {
+	return value ? "" : void 0;
+}
+/**
+* Creates data attributes from render props
+*/
+function createDataAttributes(values) {
+	const result = {};
+	for (const [key, value] of Object.entries(values)) if (typeof value === "boolean") result[`data-${camelToKebab(key)}`] = value ? "" : void 0;
+	else if (value !== void 0) result[`data-${camelToKebab(key)}`] = value;
+	return result;
+}
+function camelToKebab(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+* Remove data attributes from props (for internal use)
+*/
+function removeDataAttributes(props) {
+	const result = {};
+	for (const [key, value] of Object.entries(props)) if (!key.startsWith("data-")) result[key] = value;
+	return result;
+}
+/**
+* Filter DOM props - keep only valid DOM attributes.
+*
+* @param props - Component props to filter
+* @param options - Options for filtering (global: include global attrs)
+* @returns Object containing only valid DOM props. Use type parameter R to specify return type.
+*/
+function filterDOMProps(props, options = {}) {
+	const { global = false } = options;
+	const result = {};
+	const globalAttrs = new Set([
+		"id",
+		"class",
+		"style",
+		"tabIndex",
+		"role",
+		"title",
+		"lang",
+		"dir",
+		"hidden",
+		"draggable",
+		"accessKey",
+		"contentEditable",
+		"spellcheck"
+	]);
+	const ariaAttrs = /^aria-/;
+	const dataAttrs = /^data-/;
+	const eventHandlers = /^on[A-Z]/;
+	for (const key in props) if (Object.prototype.hasOwnProperty.call(props, key) && (global && globalAttrs.has(key) || ariaAttrs.test(key) || dataAttrs.test(key) || eventHandlers.test(key))) result[key] = props[key];
+	return result;
+}
+/**
+* ClientOnly component - renders children only on the client side.
+*
+* During SSR, renders the fallback (or nothing).
+* During hydration, renders the same fallback to match SSR.
+* After hydration completes, switches to render children.
+*
+* This is useful for components that rely on browser APIs or
+* have different server/client output.
+*
+* @example
+* ```tsx
+* <ClientOnly fallback={<div>Loading...</div>}>
+*   <Calendar />
+* </ClientOnly>
+* ```
+*/
+const ClientOnly = (props) => {
+	if (isServer) return memo(() => props.fallback);
+	if (!sharedConfig.context) return memo(() => props.children);
+	const [isHydrated, setIsHydrated] = createSignal(false);
+	onMount(() => {
+		setIsHydrated(true);
+	});
+	return createComponent(Show, {
+		get when() {
+			return isHydrated();
+		},
+		get fallback() {
+			return props.fallback;
+		},
+		get children() {
+			return props.children;
+		}
+	});
+};
+/**
+* Returns true only on the client after hydration is complete.
+* Can be used to conditionally render client-only content.
+*
+* @example
+* ```tsx
+* const hydrated = useIsHydrated();
+* return (
+*   <Show when={hydrated()} fallback={<Placeholder />}>
+*     <ClientOnlyComponent />
+*   </Show>
+* );
+* ```
+*/
+function useIsHydrated() {
+	if (isServer) return () => false;
+	if (!sharedConfig.context) return () => true;
+	const [isHydrated, setIsHydrated] = createSignal(false);
+	onMount(() => {
+		setIsHydrated(true);
+	});
+	return isHydrated;
+}
+//#endregion
+export { ClientOnly, DEFAULT_SLOT, Provider, assignRef, composeRenderProps, createDataAttributes, createSlottedContext, dataAttr, filterDOMProps, mergeRefs, removeDataAttributes, useContextProps, useIsHydrated, useRenderProps, useSlot, useSlottedContext };
+
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["JSX","Accessor","Context","FlowComponent","createComponent","createContext","useContext","createMemo","createSignal","onMount","sharedConfig","untrack","Show","isServer","mergeProps","RenderChildren","Element","renderProps","T","ClassNameOrFunction","StyleOrFunction","CSSProperties","RenderPropsBase","children","class","style","SlotProps","slot","DEFAULT_SLOT","RenderPropsResult","renderChildren","renderChildrenStable","values","useRenderProps","props","defaultClassName","className","computedClass","currentValues","computedStyle","length","snapshot","view","key","Object","keys","Array","defineProperty","enumerable","configurable","get","composeRenderProps","base","override","RefLike","el","current","WithRef","ref","E","SlottedValue","slots","Record","SlottedContextValue","ContextValue","HTMLElement","createSlottedContext","assignRef","mergeRefs","refs","seen","Set","has","add","useSlottedContext","context","ctx","slotName","slotValue","validSlots","map","name","join","Error","useContextProps","TProps","TRef","Partial","contextRef","contextProps","mergedRef","mergedProps","useSlot","initialState","hasSlot","setHasSlot","hasRun","Provider","build","index","value","dataAttr","undefined","createDataAttributes","result","entries","camelToKebab","str","replace","toLowerCase","removeDataAttributes","startsWith","filterDOMProps","options","global","R","globalAttrs","ariaAttrs","dataAttrs","eventHandlers","prototype","hasOwnProperty","call","test","ClientOnlyProps","fallback","ClientOnly","_$memo","isHydrated","setIsHydrated","_$createComponent","when","useIsHydrated"],"sources":["../src/utils.tsx"],"sourcesContent":["/**\n * Utility functions for solidaria-components\n * Port of react-aria-components/src/utils.tsx\n */\n\nimport {\n  type JSX,\n  type Accessor,\n  type Context,\n  type FlowComponent,\n  createComponent,\n  createContext,\n  useContext,\n  createMemo,\n  createSignal,\n  onMount,\n  sharedConfig,\n  untrack,\n  Show,\n} from \"solid-js\";\nimport { isServer } from \"solid-js/web\";\nimport { mergeProps } from \"@proyecto-viviana/solidaria\";\n\n/**\n * Render props pattern - children can be a function that receives state\n */\nexport type RenderChildren<T> = JSX.Element | ((renderProps: T) => JSX.Element);\n\n/**\n * Class name can be a string or a function that computes based on state\n */\nexport type ClassNameOrFunction<T> = string | ((renderProps: T) => string);\n\n/**\n * Style can be an object or a function that computes based on state\n */\nexport type StyleOrFunction<T> = JSX.CSSProperties | ((renderProps: T) => JSX.CSSProperties);\n\n/**\n * Common render props interface\n */\nexport interface RenderPropsBase<T> {\n  /** The children of the component. A function may be provided to receive render props. */\n  children?: RenderChildren<T>;\n  /** The CSS className for the element. A function may be provided to compute the class based on state. */\n  class?: ClassNameOrFunction<T>;\n  /** The inline style for the element. A function may be provided to compute the style based on state. */\n  style?: StyleOrFunction<T>;\n}\n\n/**\n * Slot props for named slots\n */\nexport interface SlotProps {\n  /** A slot name for the component. */\n  slot?: string;\n}\n\nexport const DEFAULT_SLOT = \"default\";\n\n/**\n * Return type for useRenderProps\n */\nexport interface RenderPropsResult<T> {\n  /** Accessor for class - safe to call anytime */\n  class: Accessor<string>;\n  /** Accessor for style - safe to call anytime */\n  style: Accessor<JSX.CSSProperties | undefined>;\n  /**\n   * Render the children. This is a function that returns JSX, NOT a getter.\n   * For SSR compatibility, this should be called within the JSX tree.\n   *\n   * Usage in components:\n   *   {renderProps.renderChildren()}\n   *\n   * Or if you need the raw children/function:\n   *   {renderProps.renderChildren()}\n   */\n  renderChildren: () => JSX.Element;\n  /**\n   * Render a render-prop child ONCE over a reactive view of the values,\n   * mirroring how React reconciles a render prop's returned tree in place.\n   *\n   * Prefer this over `renderChildren()` for interactive leaf components (a\n   * Tab, a toggle segment) whose child wraps the pressable element: re-invoking\n   * the render function on every values() change recreates that DOM subtree,\n   * which detaches the pointer/press target mid-gesture and makes the browser\n   * suppress the native `click` (createPress then has to synthesize an\n   * untrusted fallback click — a visible parity break vs React). Static (non\n   * function) children are returned untouched, exactly like `renderChildren`.\n   */\n  renderChildrenStable: () => JSX.Element;\n  /** The raw children prop (function or JSX) - use renderChildren() in most cases */\n  children: RenderChildren<T> | undefined;\n  /** The render props values accessor */\n  values: Accessor<T>;\n}\n\n/**\n * Resolves render props (children, class, style) based on component state.\n *\n * For SSR compatibility, children are NOT evaluated eagerly. Instead:\n * - Use `renderChildren()` to render children with current values\n * - Or access `children` directly if you need the raw prop\n *\n * This avoids the getter pattern that causes SSR hydration mismatches.\n */\nexport function useRenderProps<T extends object>(\n  props: RenderPropsBase<T> & { defaultClassName?: string },\n  values: Accessor<T>,\n): RenderPropsResult<T> {\n  // Don't destructure children — access lazily to avoid eager evaluation\n  // that would trigger child component creation before context providers mount.\n  const { class: className, style, defaultClassName = \"\" } = props;\n\n  // Compute class and style eagerly (they don't depend on context)\n  const computedClass = createMemo(() => {\n    const currentValues = values();\n    return typeof className === \"function\"\n      ? className(currentValues)\n      : (className ?? defaultClassName);\n  });\n\n  const computedStyle = createMemo(() => {\n    const currentValues = values();\n    return typeof style === \"function\" ? style(currentValues) : style;\n  });\n\n  // Return object with explicit function for rendering children\n  // Children are accessed lazily during render (inside context providers)\n  return {\n    class: computedClass,\n    style: computedStyle,\n    renderChildren: () => {\n      const children = props.children;\n      // Only read values() for render-prop children. Static JSX children must\n      // not track the render-state memo: re-running the insertion effect\n      // recreates real DOM nodes on every hover/press/focus flip (React keeps\n      // them stable via vdom diffing), which detaches the pressed node\n      // mid-press and suppresses the browser's native click.\n      //\n      // A render prop takes the values argument, so classify by arity — the\n      // same convention `solid-js/h` uses for dynamic props. A zero-arg\n      // function child is an accessor (a compiled `{expression}` child, a\n      // solid-refresh dev wrapper, a one-shot `solid-js/h` element thunk):\n      // return it untouched so the insert machinery unwraps it in its own\n      // nested effect. Calling it here would track its reads in the shared\n      // insertion effect, and every re-run disposes the child computations\n      // that effect owns — a one-shot h thunk then hands back the same\n      // disposed node, leaving connected DOM whose reactivity is dead.\n      return typeof children === \"function\" && children.length > 0\n        ? children(values())\n        : (children as JSX.Element);\n    },\n    renderChildrenStable: () => {\n      const children = props.children;\n      if (typeof children !== \"function\" || children.length === 0) {\n        return children as JSX.Element;\n      }\n      // Invoke the render function exactly once, over a getter view of the\n      // values, so the returned DOM is created a single time and only the\n      // reactive reads inside it (JSX bindings, component props) re-run on a\n      // values() change — React's reconciliation, not Solid's recreation.\n      //\n      // `untrack` keeps the enclosing insert from tracking values() (so it\n      // never re-runs and never recreates), but does NOT change the owner:\n      // this still executes inside the caller's insert scope, so any slotted\n      // context the render prop reads binds against the surrounding provider.\n      //\n      // The value keys are read once here (untracked). Render-state memos in\n      // this codebase return a fixed-shape object, so the key set is stable.\n      return untrack(() => {\n        const snapshot = values();\n        const view = {} as T;\n        for (const key of Object.keys(snapshot) as Array<keyof T & string>) {\n          Object.defineProperty(view, key, {\n            enumerable: true,\n            configurable: true,\n            get: () => values()[key],\n          });\n        }\n        return (children as (renderProps: T) => JSX.Element)(view);\n      });\n    },\n    get children() {\n      return props.children;\n    },\n    values,\n  };\n}\n\nexport function composeRenderProps<T extends object>(\n  base: RenderPropsBase<T> | undefined,\n  override: RenderPropsBase<T> | undefined,\n): RenderPropsBase<T> {\n  if (!base) return override ?? {};\n  if (!override) return base;\n  return {\n    children: override.children ?? base.children,\n    class: override.class ?? base.class,\n    style: override.style ?? base.style,\n  };\n}\n\n/** A Solid ref target: a callback, a mutable `{ current }` object, or undefined. */\nexport type RefLike<T> = T | ((el: T) => void) | { current?: T | null } | undefined;\n\n/** A value paired with an optional ref to merge onto the consuming element. */\nexport type WithRef<T, E> = T & { ref?: RefLike<E> };\n\n/**\n * A context value carrying named slots (mirrors react-aria-components'\n * `SlottedValue`). Each entry under `slots` is the props object delivered to the\n * component rendered with the matching `slot` name.\n */\nexport interface SlottedValue<T> {\n  slots?: Record<string, T>;\n}\n\n/** A slotted context value: a slots record, a bare value, or null/undefined. */\nexport type SlottedContextValue<T> = SlottedValue<T> | T | null | undefined;\n\n/**\n * The value type for a context consumed via {@link useContextProps}. Mirrors\n * upstream `ContextValue<T, E>`: it may carry `slots` and an optional `ref` to\n * merge onto the consuming element.\n */\nexport type ContextValue<T, E = HTMLElement> = SlottedContextValue<WithRef<T, E>>;\n\n/**\n * Creates a context that can carry either a bare value or a `slots` record.\n */\nexport function createSlottedContext<T>() {\n  return createContext<SlottedContextValue<T>>(null);\n}\n\n/** Assigns an element to a Solid ref (callback or mutable `{ current }` object). */\nexport function assignRef<T>(ref: RefLike<T>, el: T): void {\n  if (!ref) {\n    return;\n  }\n\n  if (typeof ref === \"function\") {\n    (ref as (el: T) => void)(el);\n  } else if (typeof ref === \"object\" && \"current\" in ref) {\n    (ref as { current?: T | null }).current = el;\n  }\n}\n\n/** Merges multiple Solid refs into one callback that forwards to each, once. */\nexport function mergeRefs<T>(...refs: Array<RefLike<T>>): (el: T) => void {\n  return (el: T) => {\n    const seen = new Set<RefLike<T>>();\n    for (const ref of refs) {\n      if (!ref || seen.has(ref)) {\n        continue;\n      }\n\n      seen.add(ref);\n      assignRef(ref, el);\n    }\n  };\n}\n\n/**\n * Resolves a (possibly slotted) context value for the given slot name. Port of\n * react-aria-components' `useSlottedContext`:\n * - `slot === null` opts out of the context entirely (returns `null`);\n * - if the context carries a `slots` record, the entry for `slot` (or\n *   {@link DEFAULT_SLOT}) is returned, throwing on an unknown slot name;\n * - otherwise the bare context value is returned.\n */\nexport function useSlottedContext<T>(\n  context: Context<SlottedContextValue<T>>,\n  slot?: string | null,\n): T | null | undefined {\n  const ctx = useContext(context);\n  if (slot === null) {\n    // An explicit `null` slot means: ignore this context.\n    return null;\n  }\n\n  if (ctx && typeof ctx === \"object\" && \"slots\" in ctx && ctx.slots) {\n    const slots = ctx.slots as Record<string, T>;\n    const slotName = slot || DEFAULT_SLOT;\n    const slotValue = slots[slotName];\n    if (!slotValue) {\n      const validSlots = Object.keys(slots)\n        .map((name) => `\"${name}\"`)\n        .join(\", \");\n      throw new Error(\n        slot\n          ? `Invalid slot \"${slot}\". Valid slot names are ${validSlots}.`\n          : `A slot prop is required. Valid slot names are ${validSlots}.`,\n      );\n    }\n    return slotValue;\n  }\n\n  return ctx as T | null | undefined;\n}\n\n/**\n * Merges context-provided props and a context ref into a component's own props\n * and ref. Port of react-aria-components' `useContextProps`:\n * - the context is resolved for `props.slot` via {@link useSlottedContext};\n * - props win over context props (handler props are chained by `mergeProps`);\n * - the component's own ref and the context's ref merge into one callback.\n *\n * The prop merge stays reactive (Solid `mergeProps` preserves getters), so prop\n * changes keep flowing; the context value is read once at setup, matching a single\n * upstream render.\n */\nexport function useContextProps<TProps extends SlotProps, TRef>(\n  props: TProps,\n  ref: RefLike<TRef>,\n  context: Context<ContextValue<TProps, TRef>>,\n): [TProps, (el: TRef) => void] {\n  const ctx = (useSlottedContext(context, props.slot) ?? {}) as WithRef<Partial<TProps>, TRef>;\n  const { ref: contextRef, ...contextProps } = ctx;\n  const mergedRef = mergeRefs(ref, contextRef);\n  const mergedProps = mergeProps(contextProps as object, props as object) as unknown as TProps;\n  return [mergedProps, mergedRef];\n}\n\n/**\n * Detects whether slotted content was rendered into a placeholder, for the\n * aria-label fallback pattern. Port of react-aria-components' `useSlot`: returns a\n * ref callback to attach to the placeholder and an accessor that is `true` while\n * an element is mounted there. The accessor flips to `false` after mount if the\n * ref never ran (no slotted content was provided).\n */\nexport function useSlot(initialState = true): [(el: Element | null) => void, Accessor<boolean>] {\n  const [hasSlot, setHasSlot] = createSignal(initialState);\n  let hasRun = false;\n  const ref = (el: Element | null) => {\n    hasRun = true;\n    setHasSlot(!!el);\n  };\n  onMount(() => {\n    if (!hasRun) {\n      setHasSlot(false);\n    }\n  });\n  return [ref, hasSlot];\n}\n\n/**\n * Nests a set of context providers around `children`. Port of\n * react-aria-components' `Provider`: each `[Context, value]` pair wraps the\n * previous result, so the LAST pair is the outermost provider — matching upstream's\n * wrap-in-iteration-order.\n *\n * `children` is read through a lazy getter inside the innermost provider so child\n * components are *created* within every provider's owner; Solid binds `useContext`\n * at component-execution time, so eager children would miss these providers.\n */\nexport function Provider(props: {\n  values: Array<[Context<unknown>, unknown]>;\n  children: JSX.Element;\n}): JSX.Element {\n  const build = (index: number): JSX.Element => {\n    if (index < 0) {\n      return props.children;\n    }\n    const [context, value] = props.values[index];\n    return createComponent(context.Provider, {\n      value,\n      get children() {\n        return build(index - 1);\n      },\n    });\n  };\n  return build(props.values.length - 1);\n}\n\n/**\n * Converts boolean state values to data attributes\n */\nexport function dataAttr(value: boolean | undefined): \"\" | undefined {\n  return value ? \"\" : undefined;\n}\n\n/**\n * Creates data attributes from render props\n */\nexport function createDataAttributes<T extends Record<string, boolean | string | undefined>>(\n  values: T,\n): Record<string, string | undefined> {\n  const result: Record<string, string | undefined> = {};\n\n  for (const [key, value] of Object.entries(values)) {\n    if (typeof value === \"boolean\") {\n      result[`data-${camelToKebab(key)}`] = value ? \"\" : undefined;\n    } else if (value !== undefined) {\n      result[`data-${camelToKebab(key)}`] = value;\n    }\n  }\n\n  return result;\n}\n\nfunction camelToKebab(str: string): string {\n  return str.replace(/([a-z])([A-Z])/g, \"$1-$2\").toLowerCase();\n}\n\n/**\n * Remove data attributes from props (for internal use)\n */\nexport function removeDataAttributes<T extends Record<string, unknown>>(props: T): T {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(props)) {\n    if (!key.startsWith(\"data-\")) {\n      result[key] = value;\n    }\n  }\n\n  return result as T;\n}\n\n/**\n * Filter DOM props - keep only valid DOM attributes.\n *\n * @param props - Component props to filter\n * @param options - Options for filtering (global: include global attrs)\n * @returns Object containing only valid DOM props. Use type parameter R to specify return type.\n */\nexport function filterDOMProps<R extends object = Record<string, unknown>>(\n  props: object,\n  options: { global?: boolean } = {},\n): R {\n  const { global = false } = options;\n  const result: Record<string, unknown> = {};\n\n  const globalAttrs = new Set([\n    \"id\",\n    \"class\",\n    \"style\",\n    \"tabIndex\",\n    \"role\",\n    \"title\",\n    \"lang\",\n    \"dir\",\n    \"hidden\",\n    \"draggable\",\n    \"accessKey\",\n    \"contentEditable\",\n    \"spellcheck\",\n  ]);\n\n  const ariaAttrs = /^aria-/;\n  const dataAttrs = /^data-/;\n  const eventHandlers = /^on[A-Z]/;\n\n  for (const key in props) {\n    if (\n      Object.prototype.hasOwnProperty.call(props, key) &&\n      ((global && globalAttrs.has(key)) ||\n        ariaAttrs.test(key) ||\n        dataAttrs.test(key) ||\n        eventHandlers.test(key))\n    ) {\n      result[key] = (props as Record<string, unknown>)[key];\n    }\n  }\n\n  return result as R;\n}\n\nexport interface ClientOnlyProps {\n  /** The children to render only on the client */\n  children: JSX.Element;\n  /** Optional fallback to render during SSR and initial hydration */\n  fallback?: JSX.Element;\n}\n\n/**\n * ClientOnly component - renders children only on the client side.\n *\n * During SSR, renders the fallback (or nothing).\n * During hydration, renders the same fallback to match SSR.\n * After hydration completes, switches to render children.\n *\n * This is useful for components that rely on browser APIs or\n * have different server/client output.\n *\n * @example\n * ```tsx\n * <ClientOnly fallback={<div>Loading...</div>}>\n *   <Calendar />\n * </ClientOnly>\n * ```\n */\nexport const ClientOnly: FlowComponent<ClientOnlyProps> = (props) => {\n  // On server, always render fallback\n  if (isServer) {\n    return <>{props.fallback}</>;\n  }\n\n  // Outside a hydration walk there is nothing to defer (see useIsHydrated).\n  if (!sharedConfig.context) {\n    return <>{props.children}</>;\n  }\n\n  // Hydrating: render the fallback until the walk completes.\n  const [isHydrated, setIsHydrated] = createSignal(false);\n\n  // onMount runs after hydration is complete\n  onMount(() => {\n    setIsHydrated(true);\n  });\n\n  return (\n    <Show when={isHydrated()} fallback={props.fallback}>\n      {props.children}\n    </Show>\n  );\n};\n\n/**\n * Returns true only on the client after hydration is complete.\n * Can be used to conditionally render client-only content.\n *\n * @example\n * ```tsx\n * const hydrated = useIsHydrated();\n * return (\n *   <Show when={hydrated()} fallback={<Placeholder />}>\n *     <ClientOnlyComponent />\n *   </Show>\n * );\n * ```\n */\nexport function useIsHydrated(): Accessor<boolean> {\n  // On server, always return false\n  if (isServer) {\n    return () => false;\n  }\n\n  // Outside a hydration walk (pure CSR, or a remount created after hydration\n  // finished) the caller is already \"hydrated\" — report true immediately.\n  // Solid sets `sharedConfig.context` only while synchronously walking\n  // server-rendered DOM, so this is exactly the window the false→true flip\n  // exists for. A fresh per-instance false→true flip on every remount is not\n  // just wasted work: ancestor `children()`/`Context.Provider` resolution\n  // unwraps and tracks the <Show> accessor this hook gates, so the post-mount\n  // flip re-resolves those children, recreates the subtree (with another fresh\n  // signal), and loops forever — a stack overflow with no overlay rendered.\n  if (!sharedConfig.context) {\n    return () => true;\n  }\n\n  // Hydrating: start false (so the first render matches the server, which\n  // emitted nothing for hydrated-gated content) and flip to true after mount.\n  const [isHydrated, setIsHydrated] = createSignal(false);\n\n  // onMount runs in the effect phase — *after* the synchronous hydration pass\n  // has finished walking the server DOM — so flipping here renders the gated\n  // content as a fresh client-side update (Portal: no getNextElement walk, no\n  // mismatch). This mirrors the component gate above and is strictly earlier\n  // than a rAF tick.\n  onMount(() => {\n    setIsHydrated(true);\n  });\n\n  return isHydrated;\n}\n"],"mappings":"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"}

package/dist/utils.jsx

@@ -0,0 +1,277 @@
+import { Show, createComponent, createContext, createMemo, createSignal, onMount, sharedConfig, untrack, useContext } from "solid-js";
+import { isServer } from "solid-js/web";
+import { mergeProps as mergeProps$1 } from "@proyecto-viviana/solidaria";
+//#region src/utils.tsx
+/**
+* Utility functions for solidaria-components
+* Port of react-aria-components/src/utils.tsx
+*/
+const DEFAULT_SLOT = "default";
+/**
+* Resolves render props (children, class, style) based on component state.
+*
+* For SSR compatibility, children are NOT evaluated eagerly. Instead:
+* - Use `renderChildren()` to render children with current values
+* - Or access `children` directly if you need the raw prop
+*
+* This avoids the getter pattern that causes SSR hydration mismatches.
+*/
+function useRenderProps(props, values) {
+	const { class: className, style, defaultClassName = "" } = props;
+	return {
+		class: createMemo(() => {
+			const currentValues = values();
+			return typeof className === "function" ? className(currentValues) : className ?? defaultClassName;
+		}),
+		style: createMemo(() => {
+			const currentValues = values();
+			return typeof style === "function" ? style(currentValues) : style;
+		}),
+		renderChildren: () => {
+			const children = props.children;
+			return typeof children === "function" && children.length > 0 ? children(values()) : children;
+		},
+		renderChildrenStable: () => {
+			const children = props.children;
+			if (typeof children !== "function" || children.length === 0) return children;
+			return untrack(() => {
+				const snapshot = values();
+				const view = {};
+				for (const key of Object.keys(snapshot)) Object.defineProperty(view, key, {
+					enumerable: true,
+					configurable: true,
+					get: () => values()[key]
+				});
+				return children(view);
+			});
+		},
+		get children() {
+			return props.children;
+		},
+		values
+	};
+}
+function composeRenderProps(base, override) {
+	if (!base) return override ?? {};
+	if (!override) return base;
+	return {
+		children: override.children ?? base.children,
+		class: override.class ?? base.class,
+		style: override.style ?? base.style
+	};
+}
+/**
+* Creates a context that can carry either a bare value or a `slots` record.
+*/
+function createSlottedContext() {
+	return createContext(null);
+}
+/** Assigns an element to a Solid ref (callback or mutable `{ current }` object). */
+function assignRef(ref, el) {
+	if (!ref) return;
+	if (typeof ref === "function") ref(el);
+	else if (typeof ref === "object" && "current" in ref) ref.current = el;
+}
+/** Merges multiple Solid refs into one callback that forwards to each, once. */
+function mergeRefs(...refs) {
+	return (el) => {
+		const seen = /* @__PURE__ */ new Set();
+		for (const ref of refs) {
+			if (!ref || seen.has(ref)) continue;
+			seen.add(ref);
+			assignRef(ref, el);
+		}
+	};
+}
+/**
+* Resolves a (possibly slotted) context value for the given slot name. Port of
+* react-aria-components' `useSlottedContext`:
+* - `slot === null` opts out of the context entirely (returns `null`);
+* - if the context carries a `slots` record, the entry for `slot` (or
+*   {@link DEFAULT_SLOT}) is returned, throwing on an unknown slot name;
+* - otherwise the bare context value is returned.
+*/
+function useSlottedContext(context, slot) {
+	const ctx = useContext(context);
+	if (slot === null) return null;
+	if (ctx && typeof ctx === "object" && "slots" in ctx && ctx.slots) {
+		const slots = ctx.slots;
+		const slotValue = slots[slot || "default"];
+		if (!slotValue) {
+			const validSlots = Object.keys(slots).map((name) => `"${name}"`).join(", ");
+			throw new Error(slot ? `Invalid slot "${slot}". Valid slot names are ${validSlots}.` : `A slot prop is required. Valid slot names are ${validSlots}.`);
+		}
+		return slotValue;
+	}
+	return ctx;
+}
+/**
+* Merges context-provided props and a context ref into a component's own props
+* and ref. Port of react-aria-components' `useContextProps`:
+* - the context is resolved for `props.slot` via {@link useSlottedContext};
+* - props win over context props (handler props are chained by `mergeProps`);
+* - the component's own ref and the context's ref merge into one callback.
+*
+* The prop merge stays reactive (Solid `mergeProps` preserves getters), so prop
+* changes keep flowing; the context value is read once at setup, matching a single
+* upstream render.
+*/
+function useContextProps(props, ref, context) {
+	const { ref: contextRef, ...contextProps } = useSlottedContext(context, props.slot) ?? {};
+	const mergedRef = mergeRefs(ref, contextRef);
+	return [mergeProps$1(contextProps, props), mergedRef];
+}
+/**
+* Detects whether slotted content was rendered into a placeholder, for the
+* aria-label fallback pattern. Port of react-aria-components' `useSlot`: returns a
+* ref callback to attach to the placeholder and an accessor that is `true` while
+* an element is mounted there. The accessor flips to `false` after mount if the
+* ref never ran (no slotted content was provided).
+*/
+function useSlot(initialState = true) {
+	const [hasSlot, setHasSlot] = createSignal(initialState);
+	let hasRun = false;
+	const ref = (el) => {
+		hasRun = true;
+		setHasSlot(!!el);
+	};
+	onMount(() => {
+		if (!hasRun) setHasSlot(false);
+	});
+	return [ref, hasSlot];
+}
+/**
+* Nests a set of context providers around `children`. Port of
+* react-aria-components' `Provider`: each `[Context, value]` pair wraps the
+* previous result, so the LAST pair is the outermost provider — matching upstream's
+* wrap-in-iteration-order.
+*
+* `children` is read through a lazy getter inside the innermost provider so child
+* components are *created* within every provider's owner; Solid binds `useContext`
+* at component-execution time, so eager children would miss these providers.
+*/
+function Provider(props) {
+	const build = (index) => {
+		if (index < 0) return props.children;
+		const [context, value] = props.values[index];
+		return createComponent(context.Provider, {
+			value,
+			get children() {
+				return build(index - 1);
+			}
+		});
+	};
+	return build(props.values.length - 1);
+}
+/**
+* Converts boolean state values to data attributes
+*/
+function dataAttr(value) {
+	return value ? "" : void 0;
+}
+/**
+* Creates data attributes from render props
+*/
+function createDataAttributes(values) {
+	const result = {};
+	for (const [key, value] of Object.entries(values)) if (typeof value === "boolean") result[`data-${camelToKebab(key)}`] = value ? "" : void 0;
+	else if (value !== void 0) result[`data-${camelToKebab(key)}`] = value;
+	return result;
+}
+function camelToKebab(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+* Remove data attributes from props (for internal use)
+*/
+function removeDataAttributes(props) {
+	const result = {};
+	for (const [key, value] of Object.entries(props)) if (!key.startsWith("data-")) result[key] = value;
+	return result;
+}
+/**
+* Filter DOM props - keep only valid DOM attributes.
+*
+* @param props - Component props to filter
+* @param options - Options for filtering (global: include global attrs)
+* @returns Object containing only valid DOM props. Use type parameter R to specify return type.
+*/
+function filterDOMProps(props, options = {}) {
+	const { global = false } = options;
+	const result = {};
+	const globalAttrs = new Set([
+		"id",
+		"class",
+		"style",
+		"tabIndex",
+		"role",
+		"title",
+		"lang",
+		"dir",
+		"hidden",
+		"draggable",
+		"accessKey",
+		"contentEditable",
+		"spellcheck"
+	]);
+	const ariaAttrs = /^aria-/;
+	const dataAttrs = /^data-/;
+	const eventHandlers = /^on[A-Z]/;
+	for (const key in props) if (Object.prototype.hasOwnProperty.call(props, key) && (global && globalAttrs.has(key) || ariaAttrs.test(key) || dataAttrs.test(key) || eventHandlers.test(key))) result[key] = props[key];
+	return result;
+}
+/**
+* ClientOnly component - renders children only on the client side.
+*
+* During SSR, renders the fallback (or nothing).
+* During hydration, renders the same fallback to match SSR.
+* After hydration completes, switches to render children.
+*
+* This is useful for components that rely on browser APIs or
+* have different server/client output.
+*
+* @example
+* ```tsx
+* <ClientOnly fallback={<div>Loading...</div>}>
+*   <Calendar />
+* </ClientOnly>
+* ```
+*/
+const ClientOnly = (props) => {
+	if (isServer) return <>{props.fallback}</>;
+	if (!sharedConfig.context) return <>{props.children}</>;
+	const [isHydrated, setIsHydrated] = createSignal(false);
+	onMount(() => {
+		setIsHydrated(true);
+	});
+	return <Show when={isHydrated()} fallback={props.fallback}>
+      {props.children}
+    </Show>;
+};
+/**
+* Returns true only on the client after hydration is complete.
+* Can be used to conditionally render client-only content.
+*
+* @example
+* ```tsx
+* const hydrated = useIsHydrated();
+* return (
+*   <Show when={hydrated()} fallback={<Placeholder />}>
+*     <ClientOnlyComponent />
+*   </Show>
+* );
+* ```
+*/
+function useIsHydrated() {
+	if (isServer) return () => false;
+	if (!sharedConfig.context) return () => true;
+	const [isHydrated, setIsHydrated] = createSignal(false);
+	onMount(() => {
+		setIsHydrated(true);
+	});
+	return isHydrated;
+}
+//#endregion
+export { ClientOnly, DEFAULT_SLOT, Provider, assignRef, composeRenderProps, createDataAttributes, createSlottedContext, dataAttr, filterDOMProps, mergeRefs, removeDataAttributes, useContextProps, useIsHydrated, useRenderProps, useSlot, useSlottedContext };
+
+//# sourceMappingURL=utils.jsx.map