@proyecto-viviana/solidaria 0.3.0 → 0.4.0

package/dist/ssr/index.d.ts

@@ -47,6 +47,23 @@ export declare const canUseDOM: boolean;
  * ```
  */
 export declare function createId(defaultId?: string): string;
+/**
+ * Generates an id, but only resolves to it once an element with that id is
+ * actually present in the DOM. Returns `undefined` otherwise.
+ *
+ * This is a 1:1 port of @react-aria/utils's `useSlotId`. It exists so that an
+ * `aria-labelledby` can point at an optional slot (e.g. a section header) and
+ * automatically fall back to `undefined` when the slot is not rendered, instead
+ * of leaving a dangling reference to a non-existent id.
+ *
+ * The initial value is the generated id so that server and first client render
+ * agree (no hydration mismatch); a client-only effect then probes the DOM and
+ * clears the value when no matching element exists.
+ *
+ * @param deps - Accessors re-probed when their values change (mirrors the
+ *   dependency array of the upstream hook).
+ */
+export declare function createSlotId(deps?: Array<Accessor<unknown>>): Accessor<string | undefined>;
 /**
  * Provides SSR context to the component tree.
  *

package/dist/ssr/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ssr/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,GAAG,EACR,KAAK,WAAW,EASjB,MAAM,UAAU,CAAC;AAGlB,MAAM,WAAW,gBAAiB,SAAQ,WAAW;CAAG;AAExD,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,KAAK,EAAE,OAAO,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB;AAOD;;;;;;GAMG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,SAAY,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAOnD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,GAAG,CAAC,OAAO,CAatF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAcxD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,CAE5C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAWvE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAY3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAK9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,IAAI,QAAQ,GAAG,SAAS,CAKlD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAErF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEjF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAK3E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ssr/index.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,GAAG,EACR,KAAK,WAAW,EASjB,MAAM,UAAU,CAAC;AAGlB,MAAM,WAAW,gBAAiB,SAAQ,WAAW;CAAG;AAExD,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,KAAK,EAAE,OAAO,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB;AAOD;;;;;;GAMG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,SAAY,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAOnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,GAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,SAAS,CAAC,CAa9F;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,GAAG,CAAC,OAAO,CAatF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAcxD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,CAE5C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAWvE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAY3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAK9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,IAAI,QAAQ,GAAG,SAAS,CAKlD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAErF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEjF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAK3E"}

package/dist/ssr/index.js

@@ -0,0 +1,299 @@
+import { createContext, createEffect, createMemo, createSignal, createUniqueId, onCleanup, onMount, useContext } from "solid-js";
+import { createComponent, isServer } from "solid-js/web";
+//#region src/ssr/index.tsx
+/**
+* SSR utilities for Solidaria
+*
+* SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.
+* These utilities provide a consistent API matching React-Aria's patterns
+* with additional features for hydration management.
+*/
+const SSRContext = createContext({
+	isSSR: isServer,
+	prefix: ""
+});
+/**
+* Returns whether the component is currently being server side rendered.
+* Can be used to delay browser-specific rendering until after hydration.
+*
+* Note: This returns a static boolean. For reactive hydration detection,
+* use `createHydrationState()`.
+*/
+function createIsSSR() {
+	return isServer;
+}
+/**
+* Check if we can use DOM APIs.
+* This is useful for code that needs to run only in the browser.
+*/
+const canUseDOM = !isServer;
+/**
+* Generate a unique ID that is stable across server and client.
+* Uses SolidJS's built-in createUniqueId which handles SSR correctly.
+*
+* @param defaultId - Optional default ID to use instead of generating one.
+*
+* @example
+* ```tsx
+* function TextField(props) {
+*   const inputId = createId(props.id);
+*   return (
+*     <>
+*       <label for={inputId}>{props.label}</label>
+*       <input id={inputId} />
+*     </>
+*   );
+* }
+* ```
+*/
+function createId(defaultId) {
+	if (defaultId) return defaultId;
+	const ctx = useContext(SSRContext);
+	const uniqueId = createUniqueId();
+	return ctx.prefix ? `solidaria-${ctx.prefix}-${uniqueId}` : `solidaria-${uniqueId}`;
+}
+/**
+* Generates an id, but only resolves to it once an element with that id is
+* actually present in the DOM. Returns `undefined` otherwise.
+*
+* This is a 1:1 port of @react-aria/utils's `useSlotId`. It exists so that an
+* `aria-labelledby` can point at an optional slot (e.g. a section header) and
+* automatically fall back to `undefined` when the slot is not rendered, instead
+* of leaving a dangling reference to a non-existent id.
+*
+* The initial value is the generated id so that server and first client render
+* agree (no hydration mismatch); a client-only effect then probes the DOM and
+* clears the value when no matching element exists.
+*
+* @param deps - Accessors re-probed when their values change (mirrors the
+*   dependency array of the upstream hook).
+*/
+function createSlotId(deps = []) {
+	const id = createId();
+	const [resolvedId, setResolvedId] = createSignal(id);
+	createEffect(() => {
+		for (const dep of deps) dep();
+		setResolvedId(document.getElementById(id) ? id : void 0);
+	});
+	return resolvedId;
+}
+/**
+* Provides SSR context to the component tree.
+*
+* While SolidJS handles most SSR scenarios automatically, this provider
+* can be useful for:
+* - Nested ID prefixes to avoid collisions in micro-frontends
+* - Explicit hydration boundary markers
+* - Testing SSR behavior
+*
+* @example
+* ```tsx
+* // Root of your app
+* <SSRProvider>
+*   <App />
+* </SSRProvider>
+*
+* // With custom prefix for micro-frontend
+* <SSRProvider prefix="widget">
+*   <Widget />
+* </SSRProvider>
+* ```
+*/
+function SSRProvider(props) {
+	const parentContext = useContext(SSRContext);
+	const value = createMemo(() => ({
+		isSSR: isServer,
+		prefix: props.prefix ? parentContext.prefix ? `${parentContext.prefix}-${props.prefix}` : props.prefix : parentContext.prefix
+	}));
+	return createComponent(SSRContext.Provider, {
+		get value() {
+			return value();
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+/**
+* Tracks whether the component is currently hydrating.
+*
+* During server-side rendering, this returns `true`. After hydration
+* completes on the client, it switches to `false`. This is useful for
+* components that need to show different content during hydration.
+*
+* @example
+* ```tsx
+* function ClientOnlyComponent() {
+*   const isHydrating = createHydrationState();
+*
+*   return (
+*     <Show when={!isHydrating()} fallback={<LoadingPlaceholder />}>
+*       <InteractiveWidget />
+*     </Show>
+*   );
+* }
+* ```
+*/
+function createHydrationState() {
+	if (isServer) return () => true;
+	const [isHydrating, setIsHydrating] = createSignal(true);
+	onMount(() => {
+		setIsHydrating(false);
+	});
+	return isHydrating;
+}
+/**
+* Hook that returns `true` during SSR and initial hydration.
+* Use this to delay browser-specific code until hydration is complete.
+*
+* Unlike `createIsSSR()` which is static, this updates reactively
+* after hydration completes.
+*
+* @example
+* ```tsx
+* function BrowserOnlyFeature() {
+*   const isSSR = useIsSSR();
+*
+*   createEffect(() => {
+*     if (!isSSR()) {
+*       // Safe to access browser APIs here
+*       window.localStorage.getItem('key');
+*     }
+*   });
+*
+*   return <Show when={!isSSR()}>...</Show>;
+* }
+* ```
+*/
+function useIsSSR() {
+	return createHydrationState();
+}
+/**
+* Creates an effect that only runs on the client after hydration.
+* This is a convenience wrapper that ensures browser-specific code
+* doesn't run during SSR.
+*
+* @param fn - The effect function to run
+*
+* @example
+* ```tsx
+* function Analytics() {
+*   createBrowserEffect(() => {
+*     // Safe to access window, document, localStorage, etc.
+*     window.analytics.track('page_view');
+*   });
+*
+*   return null;
+* }
+* ```
+*/
+function createBrowserEffect(fn) {
+	if (isServer) return;
+	createEffect(() => {
+		const cleanup = fn();
+		if (typeof cleanup === "function") onCleanup(cleanup);
+	});
+}
+/**
+* Creates a value that is computed only on the client.
+* On the server, returns the fallback value.
+*
+* @param fn - Function to compute the value on the client
+* @param fallback - Value to return during SSR
+*
+* @example
+* ```tsx
+* function WindowSize() {
+*   const width = createBrowserValue(
+*     () => window.innerWidth,
+*     0
+*   );
+*
+*   return <span>Width: {width()}</span>;
+* }
+* ```
+*/
+function createBrowserValue(fn, fallback) {
+	if (isServer) return () => fallback;
+	const [value, setValue] = createSignal(fallback);
+	onMount(() => {
+		setValue(() => fn());
+	});
+	return value;
+}
+/**
+* Returns the window object if available, or undefined during SSR.
+* Useful for accessing browser globals safely.
+*
+* @example
+* ```tsx
+* const win = getWindow();
+* if (win) {
+*   win.addEventListener('resize', handler);
+* }
+* ```
+*/
+function getWindow() {
+	if (typeof window !== "undefined") return window;
+}
+/**
+* Returns the document object if available, or undefined during SSR.
+* Useful for accessing document safely.
+*
+* @example
+* ```tsx
+* const doc = getDocument();
+* if (doc) {
+*   doc.addEventListener('keydown', handler);
+* }
+* ```
+*/
+function getDocument() {
+	if (typeof document !== "undefined") return document;
+}
+/**
+* Returns the owner document of an element, with SSR safety.
+*
+* @param el - The element to get the owner document from
+*/
+function getOwnerDocument(el) {
+	return el?.ownerDocument ?? getDocument();
+}
+/**
+* Returns the owner window of an element, with SSR safety.
+*
+* @param el - The element to get the owner window from
+*/
+function getOwnerWindow(el) {
+	return getOwnerDocument(el)?.defaultView ?? getWindow();
+}
+/**
+* Gets the appropriate container for portals, with SSR safety.
+* Returns the specified container, or document.body on the client,
+* or undefined during SSR.
+*
+* @param container - Optional custom container element
+*
+* @example
+* ```tsx
+* function Modal(props) {
+*   const container = getPortalContainer(props.container);
+*
+*   return (
+*     <Show when={container}>
+*       <Portal mount={container}>
+*         {props.children}
+*       </Portal>
+*     </Show>
+*   );
+* }
+* ```
+*/
+function getPortalContainer(container) {
+	if (container) return container;
+	return getDocument()?.body;
+}
+//#endregion
+export { SSRProvider, canUseDOM, createBrowserEffect, createBrowserValue, createHydrationState, createId, createIsSSR, createSlotId, getDocument, getOwnerDocument, getOwnerWindow, getPortalContainer, getWindow, useIsSSR };
+
+//# sourceMappingURL=index.js.map

package/dist/ssr/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["Accessor","JSX","ParentProps","createContext","createEffect","createMemo","createSignal","onCleanup","onMount","useContext","createUniqueId","isServer","SSRProviderProps","SSRContextValue","isSSR","prefix","SSRContext","createIsSSR","canUseDOM","createId","defaultId","ctx","uniqueId","createSlotId","deps","Array","id","resolvedId","setResolvedId","dep","document","getElementById","undefined","SSRProvider","props","Element","parentContext","value","_$createComponent","Provider","children","createHydrationState","isHydrating","setIsHydrating","useIsSSR","createBrowserEffect","fn","cleanup","createBrowserValue","T","fallback","setValue","getWindow","Window","window","getDocument","Document","getOwnerDocument","el","ownerDocument","getOwnerWindow","defaultView","getPortalContainer","container","body"],"sources":["../../src/ssr/index.tsx"],"sourcesContent":["/**\n * SSR utilities for Solidaria\n *\n * SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.\n * These utilities provide a consistent API matching React-Aria's patterns\n * with additional features for hydration management.\n */\n\nimport {\n  type Accessor,\n  type JSX,\n  type ParentProps,\n  createContext,\n  createEffect,\n  createMemo,\n  createSignal,\n  onCleanup,\n  onMount,\n  useContext,\n  createUniqueId,\n} from \"solid-js\";\nimport { isServer } from \"solid-js/web\";\n\nexport interface SSRProviderProps extends ParentProps {}\n\nexport interface SSRContextValue {\n  /** Whether currently rendering on the server. */\n  isSSR: boolean;\n  /** Prefix for generated IDs, allowing nested providers. */\n  prefix: string;\n}\n\nconst SSRContext = createContext<SSRContextValue>({\n  isSSR: isServer,\n  prefix: \"\",\n});\n\n/**\n * Returns whether the component is currently being server side rendered.\n * Can be used to delay browser-specific rendering until after hydration.\n *\n * Note: This returns a static boolean. For reactive hydration detection,\n * use `createHydrationState()`.\n */\nexport function createIsSSR(): boolean {\n  return isServer;\n}\n\n/**\n * Check if we can use DOM APIs.\n * This is useful for code that needs to run only in the browser.\n */\nexport const canUseDOM = !isServer;\n\n/**\n * Generate a unique ID that is stable across server and client.\n * Uses SolidJS's built-in createUniqueId which handles SSR correctly.\n *\n * @param defaultId - Optional default ID to use instead of generating one.\n *\n * @example\n * ```tsx\n * function TextField(props) {\n *   const inputId = createId(props.id);\n *   return (\n *     <>\n *       <label for={inputId}>{props.label}</label>\n *       <input id={inputId} />\n *     </>\n *   );\n * }\n * ```\n */\nexport function createId(defaultId?: string): string {\n  if (defaultId) {\n    return defaultId;\n  }\n  const ctx = useContext(SSRContext);\n  const uniqueId = createUniqueId();\n  return ctx.prefix ? `solidaria-${ctx.prefix}-${uniqueId}` : `solidaria-${uniqueId}`;\n}\n\n/**\n * Generates an id, but only resolves to it once an element with that id is\n * actually present in the DOM. Returns `undefined` otherwise.\n *\n * This is a 1:1 port of @react-aria/utils's `useSlotId`. It exists so that an\n * `aria-labelledby` can point at an optional slot (e.g. a section header) and\n * automatically fall back to `undefined` when the slot is not rendered, instead\n * of leaving a dangling reference to a non-existent id.\n *\n * The initial value is the generated id so that server and first client render\n * agree (no hydration mismatch); a client-only effect then probes the DOM and\n * clears the value when no matching element exists.\n *\n * @param deps - Accessors re-probed when their values change (mirrors the\n *   dependency array of the upstream hook).\n */\nexport function createSlotId(deps: Array<Accessor<unknown>> = []): Accessor<string | undefined> {\n  const id = createId();\n  const [resolvedId, setResolvedId] = createSignal<string | undefined>(id);\n\n  createEffect(() => {\n    // Re-probe when any explicit dependency changes.\n    for (const dep of deps) {\n      dep();\n    }\n    setResolvedId(document.getElementById(id) ? id : undefined);\n  });\n\n  return resolvedId;\n}\n\n/**\n * Provides SSR context to the component tree.\n *\n * While SolidJS handles most SSR scenarios automatically, this provider\n * can be useful for:\n * - Nested ID prefixes to avoid collisions in micro-frontends\n * - Explicit hydration boundary markers\n * - Testing SSR behavior\n *\n * @example\n * ```tsx\n * // Root of your app\n * <SSRProvider>\n *   <App />\n * </SSRProvider>\n *\n * // With custom prefix for micro-frontend\n * <SSRProvider prefix=\"widget\">\n *   <Widget />\n * </SSRProvider>\n * ```\n */\nexport function SSRProvider(props: SSRProviderProps & { prefix?: string }): JSX.Element {\n  const parentContext = useContext(SSRContext);\n\n  const value = createMemo<SSRContextValue>(() => ({\n    isSSR: isServer,\n    prefix: props.prefix\n      ? parentContext.prefix\n        ? `${parentContext.prefix}-${props.prefix}`\n        : props.prefix\n      : parentContext.prefix,\n  }));\n\n  return <SSRContext.Provider value={value()}>{props.children}</SSRContext.Provider>;\n}\n\n/**\n * Tracks whether the component is currently hydrating.\n *\n * During server-side rendering, this returns `true`. After hydration\n * completes on the client, it switches to `false`. This is useful for\n * components that need to show different content during hydration.\n *\n * @example\n * ```tsx\n * function ClientOnlyComponent() {\n *   const isHydrating = createHydrationState();\n *\n *   return (\n *     <Show when={!isHydrating()} fallback={<LoadingPlaceholder />}>\n *       <InteractiveWidget />\n *     </Show>\n *   );\n * }\n * ```\n */\nexport function createHydrationState(): Accessor<boolean> {\n  // On the server, always return true\n  if (isServer) {\n    return () => true;\n  }\n\n  // On the client, track hydration state\n  const [isHydrating, setIsHydrating] = createSignal(true);\n\n  onMount(() => {\n    setIsHydrating(false);\n  });\n\n  return isHydrating;\n}\n\n/**\n * Hook that returns `true` during SSR and initial hydration.\n * Use this to delay browser-specific code until hydration is complete.\n *\n * Unlike `createIsSSR()` which is static, this updates reactively\n * after hydration completes.\n *\n * @example\n * ```tsx\n * function BrowserOnlyFeature() {\n *   const isSSR = useIsSSR();\n *\n *   createEffect(() => {\n *     if (!isSSR()) {\n *       // Safe to access browser APIs here\n *       window.localStorage.getItem('key');\n *     }\n *   });\n *\n *   return <Show when={!isSSR()}>...</Show>;\n * }\n * ```\n */\nexport function useIsSSR(): Accessor<boolean> {\n  return createHydrationState();\n}\n\n/**\n * Creates an effect that only runs on the client after hydration.\n * This is a convenience wrapper that ensures browser-specific code\n * doesn't run during SSR.\n *\n * @param fn - The effect function to run\n *\n * @example\n * ```tsx\n * function Analytics() {\n *   createBrowserEffect(() => {\n *     // Safe to access window, document, localStorage, etc.\n *     window.analytics.track('page_view');\n *   });\n *\n *   return null;\n * }\n * ```\n */\nexport function createBrowserEffect(fn: () => void | (() => void)): void {\n  if (isServer) {\n    return;\n  }\n\n  createEffect(() => {\n    const cleanup = fn();\n    if (typeof cleanup === \"function\") {\n      onCleanup(cleanup);\n    }\n  });\n}\n\n/**\n * Creates a value that is computed only on the client.\n * On the server, returns the fallback value.\n *\n * @param fn - Function to compute the value on the client\n * @param fallback - Value to return during SSR\n *\n * @example\n * ```tsx\n * function WindowSize() {\n *   const width = createBrowserValue(\n *     () => window.innerWidth,\n *     0\n *   );\n *\n *   return <span>Width: {width()}</span>;\n * }\n * ```\n */\nexport function createBrowserValue<T>(fn: () => T, fallback: T): Accessor<T> {\n  if (isServer) {\n    return () => fallback;\n  }\n\n  const [value, setValue] = createSignal<T>(fallback);\n\n  onMount(() => {\n    setValue(() => fn());\n  });\n\n  return value;\n}\n\n/**\n * Returns the window object if available, or undefined during SSR.\n * Useful for accessing browser globals safely.\n *\n * @example\n * ```tsx\n * const win = getWindow();\n * if (win) {\n *   win.addEventListener('resize', handler);\n * }\n * ```\n */\nexport function getWindow(): Window | undefined {\n  if (typeof window !== \"undefined\") {\n    return window;\n  }\n  return undefined;\n}\n\n/**\n * Returns the document object if available, or undefined during SSR.\n * Useful for accessing document safely.\n *\n * @example\n * ```tsx\n * const doc = getDocument();\n * if (doc) {\n *   doc.addEventListener('keydown', handler);\n * }\n * ```\n */\nexport function getDocument(): Document | undefined {\n  if (typeof document !== \"undefined\") {\n    return document;\n  }\n  return undefined;\n}\n\n/**\n * Returns the owner document of an element, with SSR safety.\n *\n * @param el - The element to get the owner document from\n */\nexport function getOwnerDocument(el: Element | null | undefined): Document | undefined {\n  return el?.ownerDocument ?? getDocument();\n}\n\n/**\n * Returns the owner window of an element, with SSR safety.\n *\n * @param el - The element to get the owner window from\n */\nexport function getOwnerWindow(el: Element | null | undefined): Window | undefined {\n  return getOwnerDocument(el)?.defaultView ?? getWindow();\n}\n\n/**\n * Gets the appropriate container for portals, with SSR safety.\n * Returns the specified container, or document.body on the client,\n * or undefined during SSR.\n *\n * @param container - Optional custom container element\n *\n * @example\n * ```tsx\n * function Modal(props) {\n *   const container = getPortalContainer(props.container);\n *\n *   return (\n *     <Show when={container}>\n *       <Portal mount={container}>\n *         {props.children}\n *       </Portal>\n *     </Show>\n *   );\n * }\n * ```\n */\nexport function getPortalContainer(container?: Element): Element | undefined {\n  if (container) {\n    return container;\n  }\n  return getDocument()?.body;\n}\n"],"mappings":";;;;;;;;;;AAgCA,MAAMgB,aAAab,cAA+B;CAChDW,OAAOH;CACPI,QAAQ;AACV,CAAC;;;;;;;;AASD,SAAgBE,cAAuB;CACrC,OAAON;AACT;;;;;AAMA,MAAaO,YAAY,CAACP;;;;;;;;;;;;;;;;;;;;AAqB1B,SAAgBQ,SAASC,WAA4B;CACnD,IAAIA,WACF,OAAOA;CAET,MAAMC,MAAMZ,WAAWO,UAAU;CACjC,MAAMM,WAAWZ,eAAe;CAChC,OAAOW,IAAIN,SAAS,aAAaM,IAAIN,OAAM,GAAIO,aAAa,aAAaA;AAC3E;;;;;;;;;;;;;;;;;AAkBA,SAAgBC,aAAaC,OAAiC,CAAA,GAAkC;CAC9F,MAAME,KAAKP,SAAS;CACpB,MAAM,CAACQ,YAAYC,iBAAiBtB,aAAiCoB,EAAE;CAEvEtB,mBAAmB;EAEjB,KAAK,MAAMyB,OAAOL,MAChBK,IAAI;EAEND,cAAcE,SAASC,eAAeL,EAAE,IAAIA,KAAKM,KAAAA,CAAS;CAC5D,CAAC;CAED,OAAOL;AACT;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgBM,YAAYC,OAA4D;CACtF,MAAME,gBAAgB3B,WAAWO,UAAU;CAE3C,MAAMqB,QAAQhC,kBAAmC;EAC/CS,OAAOH;EACPI,QAAQmB,MAAMnB,SACVqB,cAAcrB,SACZ,GAAGqB,cAAcrB,OAAM,GAAImB,MAAMnB,WACjCmB,MAAMnB,SACRqB,cAAcrB;CACpB,EAAE;CAEF,OAAAuB,gBAAQtB,WAAWuB,UAAQ;EAAA,IAACF,QAAK;GAAA,OAAEA,MAAM;EAAC;EAAA,IAAAG,WAAA;GAAA,OAAGN,MAAMM;EAAQ;CAAA,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgBC,uBAA0C;CAExD,IAAI9B,UACF,aAAa;CAIf,MAAM,CAAC+B,aAAaC,kBAAkBrC,aAAa,IAAI;CAEvDE,cAAc;EACZmC,eAAe,KAAK;CACtB,CAAC;CAED,OAAOD;AACT;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgBE,WAA8B;CAC5C,OAAOH,qBAAqB;AAC9B;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgBI,oBAAoBC,IAAqC;CACvE,IAAInC,UACF;CAGFP,mBAAmB;EACjB,MAAM2C,UAAUD,GAAG;EACnB,IAAI,OAAOC,YAAY,YACrBxC,UAAUwC,OAAO;CAErB,CAAC;AACH;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgBC,mBAAsBF,IAAaI,UAA0B;CAC3E,IAAIvC,UACF,aAAauC;CAGf,MAAM,CAACb,OAAOc,YAAY7C,aAAgB4C,QAAQ;CAElD1C,cAAc;EACZ2C,eAAeL,GAAG,CAAC;CACrB,CAAC;CAED,OAAOT;AACT;;;;;;;;;;;;;AAcA,SAAgBe,YAAgC;CAC9C,IAAI,OAAOE,WAAW,aACpB,OAAOA;AAGX;;;;;;;;;;;;;AAcA,SAAgBC,cAAoC;CAClD,IAAI,OAAOzB,aAAa,aACtB,OAAOA;AAGX;;;;;;AAOA,SAAgB2B,iBAAiBC,IAAsD;CACrF,OAAOA,IAAIC,iBAAiBJ,YAAY;AAC1C;;;;;;AAOA,SAAgBK,eAAeF,IAAoD;CACjF,OAAOD,iBAAiBC,EAAE,CAAC,EAAEG,eAAeT,UAAU;AACxD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgBU,mBAAmBC,WAA0C;CAC3E,IAAIA,WACF,OAAOA;CAET,OAAOR,YAAY,CAAC,EAAES;AACxB"}

package/dist/ssr/index.jsx

@@ -0,0 +1,292 @@
+import { createContext, createEffect, createMemo, createSignal, createUniqueId, onCleanup, onMount, useContext } from "solid-js";
+import { isServer } from "solid-js/web";
+//#region src/ssr/index.tsx
+/**
+* SSR utilities for Solidaria
+*
+* SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.
+* These utilities provide a consistent API matching React-Aria's patterns
+* with additional features for hydration management.
+*/
+const SSRContext = createContext({
+	isSSR: isServer,
+	prefix: ""
+});
+/**
+* Returns whether the component is currently being server side rendered.
+* Can be used to delay browser-specific rendering until after hydration.
+*
+* Note: This returns a static boolean. For reactive hydration detection,
+* use `createHydrationState()`.
+*/
+function createIsSSR() {
+	return isServer;
+}
+/**
+* Check if we can use DOM APIs.
+* This is useful for code that needs to run only in the browser.
+*/
+const canUseDOM = !isServer;
+/**
+* Generate a unique ID that is stable across server and client.
+* Uses SolidJS's built-in createUniqueId which handles SSR correctly.
+*
+* @param defaultId - Optional default ID to use instead of generating one.
+*
+* @example
+* ```tsx
+* function TextField(props) {
+*   const inputId = createId(props.id);
+*   return (
+*     <>
+*       <label for={inputId}>{props.label}</label>
+*       <input id={inputId} />
+*     </>
+*   );
+* }
+* ```
+*/
+function createId(defaultId) {
+	if (defaultId) return defaultId;
+	const ctx = useContext(SSRContext);
+	const uniqueId = createUniqueId();
+	return ctx.prefix ? `solidaria-${ctx.prefix}-${uniqueId}` : `solidaria-${uniqueId}`;
+}
+/**
+* Generates an id, but only resolves to it once an element with that id is
+* actually present in the DOM. Returns `undefined` otherwise.
+*
+* This is a 1:1 port of @react-aria/utils's `useSlotId`. It exists so that an
+* `aria-labelledby` can point at an optional slot (e.g. a section header) and
+* automatically fall back to `undefined` when the slot is not rendered, instead
+* of leaving a dangling reference to a non-existent id.
+*
+* The initial value is the generated id so that server and first client render
+* agree (no hydration mismatch); a client-only effect then probes the DOM and
+* clears the value when no matching element exists.
+*
+* @param deps - Accessors re-probed when their values change (mirrors the
+*   dependency array of the upstream hook).
+*/
+function createSlotId(deps = []) {
+	const id = createId();
+	const [resolvedId, setResolvedId] = createSignal(id);
+	createEffect(() => {
+		for (const dep of deps) dep();
+		setResolvedId(document.getElementById(id) ? id : void 0);
+	});
+	return resolvedId;
+}
+/**
+* Provides SSR context to the component tree.
+*
+* While SolidJS handles most SSR scenarios automatically, this provider
+* can be useful for:
+* - Nested ID prefixes to avoid collisions in micro-frontends
+* - Explicit hydration boundary markers
+* - Testing SSR behavior
+*
+* @example
+* ```tsx
+* // Root of your app
+* <SSRProvider>
+*   <App />
+* </SSRProvider>
+*
+* // With custom prefix for micro-frontend
+* <SSRProvider prefix="widget">
+*   <Widget />
+* </SSRProvider>
+* ```
+*/
+function SSRProvider(props) {
+	const parentContext = useContext(SSRContext);
+	const value = createMemo(() => ({
+		isSSR: isServer,
+		prefix: props.prefix ? parentContext.prefix ? `${parentContext.prefix}-${props.prefix}` : props.prefix : parentContext.prefix
+	}));
+	return <SSRContext.Provider value={value()}>{props.children}</SSRContext.Provider>;
+}
+/**
+* Tracks whether the component is currently hydrating.
+*
+* During server-side rendering, this returns `true`. After hydration
+* completes on the client, it switches to `false`. This is useful for
+* components that need to show different content during hydration.
+*
+* @example
+* ```tsx
+* function ClientOnlyComponent() {
+*   const isHydrating = createHydrationState();
+*
+*   return (
+*     <Show when={!isHydrating()} fallback={<LoadingPlaceholder />}>
+*       <InteractiveWidget />
+*     </Show>
+*   );
+* }
+* ```
+*/
+function createHydrationState() {
+	if (isServer) return () => true;
+	const [isHydrating, setIsHydrating] = createSignal(true);
+	onMount(() => {
+		setIsHydrating(false);
+	});
+	return isHydrating;
+}
+/**
+* Hook that returns `true` during SSR and initial hydration.
+* Use this to delay browser-specific code until hydration is complete.
+*
+* Unlike `createIsSSR()` which is static, this updates reactively
+* after hydration completes.
+*
+* @example
+* ```tsx
+* function BrowserOnlyFeature() {
+*   const isSSR = useIsSSR();
+*
+*   createEffect(() => {
+*     if (!isSSR()) {
+*       // Safe to access browser APIs here
+*       window.localStorage.getItem('key');
+*     }
+*   });
+*
+*   return <Show when={!isSSR()}>...</Show>;
+* }
+* ```
+*/
+function useIsSSR() {
+	return createHydrationState();
+}
+/**
+* Creates an effect that only runs on the client after hydration.
+* This is a convenience wrapper that ensures browser-specific code
+* doesn't run during SSR.
+*
+* @param fn - The effect function to run
+*
+* @example
+* ```tsx
+* function Analytics() {
+*   createBrowserEffect(() => {
+*     // Safe to access window, document, localStorage, etc.
+*     window.analytics.track('page_view');
+*   });
+*
+*   return null;
+* }
+* ```
+*/
+function createBrowserEffect(fn) {
+	if (isServer) return;
+	createEffect(() => {
+		const cleanup = fn();
+		if (typeof cleanup === "function") onCleanup(cleanup);
+	});
+}
+/**
+* Creates a value that is computed only on the client.
+* On the server, returns the fallback value.
+*
+* @param fn - Function to compute the value on the client
+* @param fallback - Value to return during SSR
+*
+* @example
+* ```tsx
+* function WindowSize() {
+*   const width = createBrowserValue(
+*     () => window.innerWidth,
+*     0
+*   );
+*
+*   return <span>Width: {width()}</span>;
+* }
+* ```
+*/
+function createBrowserValue(fn, fallback) {
+	if (isServer) return () => fallback;
+	const [value, setValue] = createSignal(fallback);
+	onMount(() => {
+		setValue(() => fn());
+	});
+	return value;
+}
+/**
+* Returns the window object if available, or undefined during SSR.
+* Useful for accessing browser globals safely.
+*
+* @example
+* ```tsx
+* const win = getWindow();
+* if (win) {
+*   win.addEventListener('resize', handler);
+* }
+* ```
+*/
+function getWindow() {
+	if (typeof window !== "undefined") return window;
+}
+/**
+* Returns the document object if available, or undefined during SSR.
+* Useful for accessing document safely.
+*
+* @example
+* ```tsx
+* const doc = getDocument();
+* if (doc) {
+*   doc.addEventListener('keydown', handler);
+* }
+* ```
+*/
+function getDocument() {
+	if (typeof document !== "undefined") return document;
+}
+/**
+* Returns the owner document of an element, with SSR safety.
+*
+* @param el - The element to get the owner document from
+*/
+function getOwnerDocument(el) {
+	return el?.ownerDocument ?? getDocument();
+}
+/**
+* Returns the owner window of an element, with SSR safety.
+*
+* @param el - The element to get the owner window from
+*/
+function getOwnerWindow(el) {
+	return getOwnerDocument(el)?.defaultView ?? getWindow();
+}
+/**
+* Gets the appropriate container for portals, with SSR safety.
+* Returns the specified container, or document.body on the client,
+* or undefined during SSR.
+*
+* @param container - Optional custom container element
+*
+* @example
+* ```tsx
+* function Modal(props) {
+*   const container = getPortalContainer(props.container);
+*
+*   return (
+*     <Show when={container}>
+*       <Portal mount={container}>
+*         {props.children}
+*       </Portal>
+*     </Show>
+*   );
+* }
+* ```
+*/
+function getPortalContainer(container) {
+	if (container) return container;
+	return getDocument()?.body;
+}
+//#endregion
+export { SSRProvider, canUseDOM, createBrowserEffect, createBrowserValue, createHydrationState, createId, createIsSSR, createSlotId, getDocument, getOwnerDocument, getOwnerWindow, getPortalContainer, getWindow, useIsSSR };
+
+//# sourceMappingURL=index.jsx.map

package/dist/ssr/index.jsx.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.jsx","names":[],"sources":["../../src/ssr/index.tsx"],"sourcesContent":["/**\n * SSR utilities for Solidaria\n *\n * SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.\n * These utilities provide a consistent API matching React-Aria's patterns\n * with additional features for hydration management.\n */\n\nimport {\n  type Accessor,\n  type JSX,\n  type ParentProps,\n  createContext,\n  createEffect,\n  createMemo,\n  createSignal,\n  onCleanup,\n  onMount,\n  useContext,\n  createUniqueId,\n} from \"solid-js\";\nimport { isServer } from \"solid-js/web\";\n\nexport interface SSRProviderProps extends ParentProps {}\n\nexport interface SSRContextValue {\n  /** Whether currently rendering on the server. */\n  isSSR: boolean;\n  /** Prefix for generated IDs, allowing nested providers. */\n  prefix: string;\n}\n\nconst SSRContext = createContext<SSRContextValue>({\n  isSSR: isServer,\n  prefix: \"\",\n});\n\n/**\n * Returns whether the component is currently being server side rendered.\n * Can be used to delay browser-specific rendering until after hydration.\n *\n * Note: This returns a static boolean. For reactive hydration detection,\n * use `createHydrationState()`.\n */\nexport function createIsSSR(): boolean {\n  return isServer;\n}\n\n/**\n * Check if we can use DOM APIs.\n * This is useful for code that needs to run only in the browser.\n */\nexport const canUseDOM = !isServer;\n\n/**\n * Generate a unique ID that is stable across server and client.\n * Uses SolidJS's built-in createUniqueId which handles SSR correctly.\n *\n * @param defaultId - Optional default ID to use instead of generating one.\n *\n * @example\n * ```tsx\n * function TextField(props) {\n *   const inputId = createId(props.id);\n *   return (\n *     <>\n *       <label for={inputId}>{props.label}</label>\n *       <input id={inputId} />\n *     </>\n *   );\n * }\n * ```\n */\nexport function createId(defaultId?: string): string {\n  if (defaultId) {\n    return defaultId;\n  }\n  const ctx = useContext(SSRContext);\n  const uniqueId = createUniqueId();\n  return ctx.prefix ? `solidaria-${ctx.prefix}-${uniqueId}` : `solidaria-${uniqueId}`;\n}\n\n/**\n * Generates an id, but only resolves to it once an element with that id is\n * actually present in the DOM. Returns `undefined` otherwise.\n *\n * This is a 1:1 port of @react-aria/utils's `useSlotId`. It exists so that an\n * `aria-labelledby` can point at an optional slot (e.g. a section header) and\n * automatically fall back to `undefined` when the slot is not rendered, instead\n * of leaving a dangling reference to a non-existent id.\n *\n * The initial value is the generated id so that server and first client render\n * agree (no hydration mismatch); a client-only effect then probes the DOM and\n * clears the value when no matching element exists.\n *\n * @param deps - Accessors re-probed when their values change (mirrors the\n *   dependency array of the upstream hook).\n */\nexport function createSlotId(deps: Array<Accessor<unknown>> = []): Accessor<string | undefined> {\n  const id = createId();\n  const [resolvedId, setResolvedId] = createSignal<string | undefined>(id);\n\n  createEffect(() => {\n    // Re-probe when any explicit dependency changes.\n    for (const dep of deps) {\n      dep();\n    }\n    setResolvedId(document.getElementById(id) ? id : undefined);\n  });\n\n  return resolvedId;\n}\n\n/**\n * Provides SSR context to the component tree.\n *\n * While SolidJS handles most SSR scenarios automatically, this provider\n * can be useful for:\n * - Nested ID prefixes to avoid collisions in micro-frontends\n * - Explicit hydration boundary markers\n * - Testing SSR behavior\n *\n * @example\n * ```tsx\n * // Root of your app\n * <SSRProvider>\n *   <App />\n * </SSRProvider>\n *\n * // With custom prefix for micro-frontend\n * <SSRProvider prefix=\"widget\">\n *   <Widget />\n * </SSRProvider>\n * ```\n */\nexport function SSRProvider(props: SSRProviderProps & { prefix?: string }): JSX.Element {\n  const parentContext = useContext(SSRContext);\n\n  const value = createMemo<SSRContextValue>(() => ({\n    isSSR: isServer,\n    prefix: props.prefix\n      ? parentContext.prefix\n        ? `${parentContext.prefix}-${props.prefix}`\n        : props.prefix\n      : parentContext.prefix,\n  }));\n\n  return <SSRContext.Provider value={value()}>{props.children}</SSRContext.Provider>;\n}\n\n/**\n * Tracks whether the component is currently hydrating.\n *\n * During server-side rendering, this returns `true`. After hydration\n * completes on the client, it switches to `false`. This is useful for\n * components that need to show different content during hydration.\n *\n * @example\n * ```tsx\n * function ClientOnlyComponent() {\n *   const isHydrating = createHydrationState();\n *\n *   return (\n *     <Show when={!isHydrating()} fallback={<LoadingPlaceholder />}>\n *       <InteractiveWidget />\n *     </Show>\n *   );\n * }\n * ```\n */\nexport function createHydrationState(): Accessor<boolean> {\n  // On the server, always return true\n  if (isServer) {\n    return () => true;\n  }\n\n  // On the client, track hydration state\n  const [isHydrating, setIsHydrating] = createSignal(true);\n\n  onMount(() => {\n    setIsHydrating(false);\n  });\n\n  return isHydrating;\n}\n\n/**\n * Hook that returns `true` during SSR and initial hydration.\n * Use this to delay browser-specific code until hydration is complete.\n *\n * Unlike `createIsSSR()` which is static, this updates reactively\n * after hydration completes.\n *\n * @example\n * ```tsx\n * function BrowserOnlyFeature() {\n *   const isSSR = useIsSSR();\n *\n *   createEffect(() => {\n *     if (!isSSR()) {\n *       // Safe to access browser APIs here\n *       window.localStorage.getItem('key');\n *     }\n *   });\n *\n *   return <Show when={!isSSR()}>...</Show>;\n * }\n * ```\n */\nexport function useIsSSR(): Accessor<boolean> {\n  return createHydrationState();\n}\n\n/**\n * Creates an effect that only runs on the client after hydration.\n * This is a convenience wrapper that ensures browser-specific code\n * doesn't run during SSR.\n *\n * @param fn - The effect function to run\n *\n * @example\n * ```tsx\n * function Analytics() {\n *   createBrowserEffect(() => {\n *     // Safe to access window, document, localStorage, etc.\n *     window.analytics.track('page_view');\n *   });\n *\n *   return null;\n * }\n * ```\n */\nexport function createBrowserEffect(fn: () => void | (() => void)): void {\n  if (isServer) {\n    return;\n  }\n\n  createEffect(() => {\n    const cleanup = fn();\n    if (typeof cleanup === \"function\") {\n      onCleanup(cleanup);\n    }\n  });\n}\n\n/**\n * Creates a value that is computed only on the client.\n * On the server, returns the fallback value.\n *\n * @param fn - Function to compute the value on the client\n * @param fallback - Value to return during SSR\n *\n * @example\n * ```tsx\n * function WindowSize() {\n *   const width = createBrowserValue(\n *     () => window.innerWidth,\n *     0\n *   );\n *\n *   return <span>Width: {width()}</span>;\n * }\n * ```\n */\nexport function createBrowserValue<T>(fn: () => T, fallback: T): Accessor<T> {\n  if (isServer) {\n    return () => fallback;\n  }\n\n  const [value, setValue] = createSignal<T>(fallback);\n\n  onMount(() => {\n    setValue(() => fn());\n  });\n\n  return value;\n}\n\n/**\n * Returns the window object if available, or undefined during SSR.\n * Useful for accessing browser globals safely.\n *\n * @example\n * ```tsx\n * const win = getWindow();\n * if (win) {\n *   win.addEventListener('resize', handler);\n * }\n * ```\n */\nexport function getWindow(): Window | undefined {\n  if (typeof window !== \"undefined\") {\n    return window;\n  }\n  return undefined;\n}\n\n/**\n * Returns the document object if available, or undefined during SSR.\n * Useful for accessing document safely.\n *\n * @example\n * ```tsx\n * const doc = getDocument();\n * if (doc) {\n *   doc.addEventListener('keydown', handler);\n * }\n * ```\n */\nexport function getDocument(): Document | undefined {\n  if (typeof document !== \"undefined\") {\n    return document;\n  }\n  return undefined;\n}\n\n/**\n * Returns the owner document of an element, with SSR safety.\n *\n * @param el - The element to get the owner document from\n */\nexport function getOwnerDocument(el: Element | null | undefined): Document | undefined {\n  return el?.ownerDocument ?? getDocument();\n}\n\n/**\n * Returns the owner window of an element, with SSR safety.\n *\n * @param el - The element to get the owner window from\n */\nexport function getOwnerWindow(el: Element | null | undefined): Window | undefined {\n  return getOwnerDocument(el)?.defaultView ?? getWindow();\n}\n\n/**\n * Gets the appropriate container for portals, with SSR safety.\n * Returns the specified container, or document.body on the client,\n * or undefined during SSR.\n *\n * @param container - Optional custom container element\n *\n * @example\n * ```tsx\n * function Modal(props) {\n *   const container = getPortalContainer(props.container);\n *\n *   return (\n *     <Show when={container}>\n *       <Portal mount={container}>\n *         {props.children}\n *       </Portal>\n *     </Show>\n *   );\n * }\n * ```\n */\nexport function getPortalContainer(container?: Element): Element | undefined {\n  if (container) {\n    return container;\n  }\n  return getDocument()?.body;\n}\n"],"mappings":";;;;;;;;;;AAgCA,MAAM,aAAa,cAA+B;CAChD,OAAO;CACP,QAAQ;AACV,CAAC;;;;;;;;AASD,SAAgB,cAAuB;CACrC,OAAO;AACT;;;;;AAMA,MAAa,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;AAqB1B,SAAgB,SAAS,WAA4B;CACnD,IAAI,WACF,OAAO;CAET,MAAM,MAAM,WAAW,UAAU;CACjC,MAAM,WAAW,eAAe;CAChC,OAAO,IAAI,SAAS,aAAa,IAAI,OAAO,GAAG,aAAa,aAAa;AAC3E;;;;;;;;;;;;;;;;;AAkBA,SAAgB,aAAa,OAAiC,CAAC,GAAiC;CAC9F,MAAM,KAAK,SAAS;CACpB,MAAM,CAAC,YAAY,iBAAiB,aAAiC,EAAE;CAEvE,mBAAmB;EAEjB,KAAK,MAAM,OAAO,MAChB,IAAI;EAEN,cAAc,SAAS,eAAe,EAAE,IAAI,KAAK,KAAA,CAAS;CAC5D,CAAC;CAED,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,YAAY,OAA4D;CACtF,MAAM,gBAAgB,WAAW,UAAU;CAE3C,MAAM,QAAQ,kBAAmC;EAC/C,OAAO;EACP,QAAQ,MAAM,SACV,cAAc,SACZ,GAAG,cAAc,OAAO,GAAG,MAAM,WACjC,MAAM,SACR,cAAc;CACpB,EAAE;CAEF,OAAO,CAAC,WAAW,SAAS,OAAO,MAAM,IAAI,MAAM,SAAS,EAAE,WAAW;AAC3E;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,uBAA0C;CAExD,IAAI,UACF,aAAa;CAIf,MAAM,CAAC,aAAa,kBAAkB,aAAa,IAAI;CAEvD,cAAc;EACZ,eAAe,KAAK;CACtB,CAAC;CAED,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,WAA8B;CAC5C,OAAO,qBAAqB;AAC9B;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,oBAAoB,IAAqC;CACvE,IAAI,UACF;CAGF,mBAAmB;EACjB,MAAM,UAAU,GAAG;EACnB,IAAI,OAAO,YAAY,YACrB,UAAU,OAAO;CAErB,CAAC;AACH;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,mBAAsB,IAAa,UAA0B;CAC3E,IAAI,UACF,aAAa;CAGf,MAAM,CAAC,OAAO,YAAY,aAAgB,QAAQ;CAElD,cAAc;EACZ,eAAe,GAAG,CAAC;CACrB,CAAC;CAED,OAAO;AACT;;;;;;;;;;;;;AAcA,SAAgB,YAAgC;CAC9C,IAAI,OAAO,WAAW,aACpB,OAAO;AAGX;;;;;;;;;;;;;AAcA,SAAgB,cAAoC;CAClD,IAAI,OAAO,aAAa,aACtB,OAAO;AAGX;;;;;;AAOA,SAAgB,iBAAiB,IAAsD;CACrF,OAAO,IAAI,iBAAiB,YAAY;AAC1C;;;;;;AAOA,SAAgB,eAAe,IAAoD;CACjF,OAAO,iBAAiB,EAAE,CAAC,EAAE,eAAe,UAAU;AACxD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,mBAAmB,WAA0C;CAC3E,IAAI,WACF,OAAO;CAET,OAAO,YAAY,CAAC,EAAE;AACxB"}

package/dist/steplist/index.js

@@ -0,0 +1,2 @@
+import { n as createStepList, t as createStep } from "../_chunk/steplist.js";
+export { createStep, createStepList };

package/dist/steplist/index.jsx

@@ -0,0 +1,2 @@
+import { n as createStepList, t as createStep } from "../_chunk/steplist.jsx";
+export { createStep, createStepList };