@masaraxui/react 1.0.0

package/dist/components/toggle-button/toggle-button.js

@@ -0,0 +1,36 @@
+"use client";
+import { toggleButtonVariants } from '@masaraxui/styles';
+import { useContext } from 'react';
+import { ToggleButton } from 'react-aria-components';
+import { jsx } from 'react/jsx-runtime';
+import { ToggleButtonGroupContext } from '../toggle-button-group/toggle-button-group.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+
+const ToggleButtonRoot = ({
+  children,
+  className,
+  isIconOnly,
+  size,
+  style,
+  variant,
+  ...rest
+}) => {
+  const groupContext = useContext(ToggleButtonGroupContext);
+
+  // Merge props with precedence: direct props > context props
+  const finalSize = size ?? groupContext?.size;
+  const styles = toggleButtonVariants({
+    isIconOnly,
+    size: finalSize,
+    variant
+  });
+  return /*#__PURE__*/jsx(ToggleButton, {
+    className: composeTwRenderProps(className, styles),
+    "data-slot": "toggle-button",
+    style: style,
+    ...rest,
+    children: renderProps => typeof children === "function" ? children(renderProps) : children
+  });
+};
+
+export { ToggleButtonRoot };

package/dist/components/toggle-button-group/index.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentProps } from "react";
+import { ToggleButtonGroupRoot, ToggleButtonGroupSeparator } from "./toggle-button-group";
+export declare const ToggleButtonGroup: (({ children, className, fullWidth, isDetached, isDisabled, orientation: orientationProp, size, ...rest }: import("./toggle-button-group").ToggleButtonGroupRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, fullWidth, isDetached, isDisabled, orientation: orientationProp, size, ...rest }: import("./toggle-button-group").ToggleButtonGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+    Separator: ({ className, ...props }: import("./toggle-button-group").ToggleButtonGroupSeparatorProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ToggleButtonGroup = {
+    Props: ComponentProps<typeof ToggleButtonGroupRoot>;
+    RootProps: ComponentProps<typeof ToggleButtonGroupRoot>;
+    SeparatorProps: ComponentProps<typeof ToggleButtonGroupSeparator>;
+};
+export { ToggleButtonGroupRoot, ToggleButtonGroupSeparator };
+export type { ToggleButtonGroupRootProps, ToggleButtonGroupRootProps as ToggleButtonGroupProps, ToggleButtonGroupSeparatorProps, } from "./toggle-button-group";
+export { ToggleButtonGroupContext, TOGGLE_BUTTON_GROUP_CHILD } from "./toggle-button-group";
+export { toggleButtonGroupVariants } from "@masaraxui/styles";
+export type { ToggleButtonGroupVariants } from "@masaraxui/styles";

package/dist/components/toggle-button-group/index.js

@@ -0,0 +1,14 @@
+"use strict";
+import { ToggleButtonGroupRoot, ToggleButtonGroupSeparator } from './toggle-button-group.js';
+export { TOGGLE_BUTTON_GROUP_CHILD, ToggleButtonGroupContext } from './toggle-button-group.js';
+export { toggleButtonGroupVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ToggleButtonGroup = Object.assign(ToggleButtonGroupRoot, {
+  Root: ToggleButtonGroupRoot,
+  Separator: ToggleButtonGroupSeparator
+});
+
+export { ToggleButtonGroup, ToggleButtonGroupRoot, ToggleButtonGroupSeparator };

package/dist/components/toggle-button-group/toggle-button-group.d.ts

@@ -0,0 +1,25 @@
+import type { ToggleButtonGroupVariants, ToggleButtonVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import { toggleButtonGroupVariants } from "@masaraxui/styles";
+import React from "react";
+import { ToggleButtonGroup as ToggleButtonGroupPrimitive } from "react-aria-components";
+type ToggleButtonGroupContext = {
+    slots?: ReturnType<typeof toggleButtonGroupVariants>;
+    size?: ToggleButtonVariants["size"];
+    isDisabled?: boolean;
+};
+declare const ToggleButtonGroupContext: React.Context<ToggleButtonGroupContext>;
+export declare const TOGGLE_BUTTON_GROUP_CHILD = "__toggle_button_group_child";
+interface ToggleButtonGroupRootProps extends ComponentPropsWithRef<typeof ToggleButtonGroupPrimitive>, ToggleButtonGroupVariants {
+    /** Size to propagate to all child ToggleButtons */
+    size?: ToggleButtonVariants["size"];
+    /** Whether the group buttons are visually separated (detached) instead of connected */
+    isDetached?: boolean;
+}
+declare const ToggleButtonGroupRoot: ({ children, className, fullWidth, isDetached, isDisabled, orientation: orientationProp, size, ...rest }: ToggleButtonGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+interface ToggleButtonGroupSeparatorProps extends ComponentPropsWithRef<"span"> {
+    className?: string;
+}
+declare const ToggleButtonGroupSeparator: ({ className, ...props }: ToggleButtonGroupSeparatorProps) => import("react/jsx-runtime").JSX.Element;
+export { ToggleButtonGroupRoot, ToggleButtonGroupSeparator, ToggleButtonGroupContext };
+export type { ToggleButtonGroupRootProps, ToggleButtonGroupSeparatorProps };

package/dist/components/toggle-button-group/toggle-button-group.js

@@ -0,0 +1,70 @@
+"use client";
+import { toggleButtonGroupVariants } from '@masaraxui/styles';
+import React__default, { createContext, useContext } from 'react';
+import { useSlottedContext, ToggleButtonGroupContext as ToggleButtonGroupContext$1, ToggleButtonGroup } from 'react-aria-components';
+import { jsx } from 'react/jsx-runtime';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+
+const ToggleButtonGroupContext = /*#__PURE__*/createContext({});
+
+// Property name to mark direct children of ToggleButtonGroup
+const TOGGLE_BUTTON_GROUP_CHILD = "__toggle_button_group_child";
+
+/* -------------------------------------------------------------------------------------------------
+ * ToggleButtonGroup Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const ToggleButtonGroupRoot = ({
+  children,
+  className,
+  fullWidth,
+  isDetached = false,
+  isDisabled,
+  orientation: orientationProp,
+  size,
+  ...rest
+}) => {
+  const racContext = useSlottedContext(ToggleButtonGroupContext$1);
+  const orientation = orientationProp ?? racContext?.orientation ?? "horizontal";
+  const slots = React__default.useMemo(() => toggleButtonGroupVariants({
+    fullWidth,
+    isDetached,
+    orientation
+  }), [fullWidth, isDetached, orientation]);
+  return /*#__PURE__*/jsx(ToggleButtonGroupContext, {
+    value: {
+      slots,
+      size,
+      isDisabled
+    },
+    children: /*#__PURE__*/jsx(ToggleButtonGroup, {
+      className: composeTwRenderProps(className, slots.base()),
+      "data-slot": "toggle-button-group",
+      isDisabled: isDisabled,
+      orientation: orientation,
+      ...rest,
+      children: children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * ToggleButtonGroup Separator
+ * -----------------------------------------------------------------------------------------------*/
+
+const ToggleButtonGroupSeparator = ({
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(ToggleButtonGroupContext);
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.separator, className),
+    "data-slot": "toggle-button-group-separator",
+    ...props
+  });
+};
+
+export { TOGGLE_BUTTON_GROUP_CHILD, ToggleButtonGroupContext, ToggleButtonGroupRoot, ToggleButtonGroupSeparator };

package/dist/components/toolbar/index.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import { ToolbarRoot } from "./toolbar";
+export declare const Toolbar: {
+    ({ children, className, isAttached, orientation, ...props }: import("./toolbar").ToolbarRootProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} & {
+    Root: {
+        ({ children, className, isAttached, orientation, ...props }: import("./toolbar").ToolbarRootProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export type Toolbar = {
+    Props: ComponentProps<typeof ToolbarRoot>;
+    RootProps: ComponentProps<typeof ToolbarRoot>;
+};
+export { ToolbarRoot } from "./toolbar";
+export type { ToolbarRootProps, ToolbarRootProps as ToolbarProps } from "./toolbar";
+export { toolbarVariants } from "@masaraxui/styles";
+export type { ToolbarVariants } from "@masaraxui/styles";

package/dist/components/toolbar/index.js

@@ -0,0 +1,12 @@
+"use strict";
+import { ToolbarRoot } from './toolbar.js';
+export { toolbarVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Toolbar = Object.assign(ToolbarRoot, {
+  Root: ToolbarRoot
+});
+
+export { Toolbar, ToolbarRoot };

package/dist/components/toolbar/toolbar.d.ts

@@ -0,0 +1,11 @@
+import type { ToolbarVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import { Toolbar as ToolbarPrimitive } from "react-aria-components";
+interface ToolbarRootProps extends ComponentPropsWithRef<typeof ToolbarPrimitive>, ToolbarVariants {
+}
+declare const ToolbarRoot: {
+    ({ children, className, isAttached, orientation, ...props }: ToolbarRootProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { ToolbarRoot };
+export type { ToolbarRootProps };

package/dist/components/toolbar/toolbar.js

@@ -0,0 +1,39 @@
+"use client";
+import { toolbarVariants } from '@masaraxui/styles';
+import React__default from 'react';
+import { ToggleButtonGroupContext, SeparatorContext, Toolbar } from 'react-aria-components';
+import { jsx } from 'react/jsx-runtime';
+import { composeTwRenderProps } from '../../utils/compose.js';
+
+const ToolbarRoot = ({
+  children,
+  className,
+  isAttached,
+  orientation = "horizontal",
+  ...props
+}) => {
+  const styles = React__default.useMemo(() => toolbarVariants({
+    isAttached,
+    orientation
+  }), [isAttached, orientation]);
+  return /*#__PURE__*/jsx(ToggleButtonGroupContext.Provider, {
+    value: {
+      orientation
+    },
+    children: /*#__PURE__*/jsx(SeparatorContext.Provider, {
+      value: {
+        orientation: orientation === "horizontal" ? "vertical" : "horizontal"
+      },
+      children: /*#__PURE__*/jsx(Toolbar, {
+        className: composeTwRenderProps(className, styles),
+        "data-slot": "toolbar",
+        orientation: orientation,
+        ...props,
+        children: children
+      })
+    })
+  });
+};
+ToolbarRoot.displayName = "MasaraxUI.Toolbar";
+
+export { ToolbarRoot };

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import { TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger } from "./tooltip";
+export declare const Tooltip: (({ children, ...props }: import("react").ComponentPropsWithRef<typeof import("react-aria-components").TooltipTrigger>) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, ...props }: import("react").ComponentPropsWithRef<typeof import("react-aria-components").TooltipTrigger>) => import("react/jsx-runtime").JSX.Element;
+    Trigger: ({ children, className, ...props }: import("./tooltip").TooltipTriggerProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ children, className, offset: offsetProp, showArrow, ...props }: import("./tooltip").TooltipContentProps) => import("react/jsx-runtime").JSX.Element;
+    Arrow: ({ children, className, ...props }: import("./tooltip").TooltipArrowProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Tooltip = {
+    Props: ComponentProps<typeof TooltipRoot>;
+    RootProps: ComponentProps<typeof TooltipRoot>;
+    TriggerProps: ComponentProps<typeof TooltipTrigger>;
+    ContentProps: ComponentProps<typeof TooltipContent>;
+    ArrowProps: ComponentProps<typeof TooltipArrow>;
+};
+export { TooltipRoot, TooltipTrigger, TooltipContent, TooltipArrow };
+export type { TooltipRootProps, TooltipRootProps as TooltipProps, TooltipArrowProps, TooltipContentProps, TooltipTriggerProps, } from "./tooltip";
+export { tooltipVariants } from "@masaraxui/styles";
+export type { TooltipVariants } from "@masaraxui/styles";

package/dist/components/tooltip/index.js

@@ -0,0 +1,15 @@
+"use strict";
+import { TooltipRoot, TooltipArrow, TooltipContent, TooltipTrigger } from './tooltip.js';
+export { tooltipVariants } from '@masaraxui/styles';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Tooltip = Object.assign(TooltipRoot, {
+  Root: TooltipRoot,
+  Trigger: TooltipTrigger,
+  Content: TooltipContent,
+  Arrow: TooltipArrow
+});
+
+export { Tooltip, TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger };

package/dist/components/tooltip/tooltip.d.ts

@@ -0,0 +1,20 @@
+import type { TooltipVariants } from "@masaraxui/styles";
+import type { ComponentPropsWithRef } from "react";
+import React from "react";
+import { OverlayArrow, Tooltip as TooltipPrimitive, TooltipTrigger as TooltipTriggerPrimitive } from "react-aria-components";
+type TooltipRootProps = ComponentPropsWithRef<typeof TooltipTriggerPrimitive>;
+declare const TooltipRoot: ({ children, ...props }: ComponentPropsWithRef<typeof TooltipTriggerPrimitive>) => import("react/jsx-runtime").JSX.Element;
+interface TooltipContentProps extends Omit<ComponentPropsWithRef<typeof TooltipPrimitive>, "children">, TooltipVariants {
+    showArrow?: boolean;
+    children: React.ReactNode;
+}
+declare const TooltipContent: ({ children, className, offset: offsetProp, showArrow, ...props }: TooltipContentProps) => import("react/jsx-runtime").JSX.Element;
+type TooltipArrowProps = Omit<ComponentPropsWithRef<typeof OverlayArrow>, "children"> & {
+    children?: React.ReactNode;
+};
+declare const TooltipArrow: ({ children, className, ...props }: TooltipArrowProps) => import("react/jsx-runtime").JSX.Element;
+interface TooltipTriggerProps extends ComponentPropsWithRef<"div"> {
+}
+declare const TooltipTrigger: ({ children, className, ...props }: TooltipTriggerProps) => import("react/jsx-runtime").JSX.Element;
+export { TooltipRoot, TooltipTrigger, TooltipContent, TooltipArrow };
+export type { TooltipRootProps, TooltipArrowProps, TooltipContentProps, TooltipTriggerProps };

package/dist/components/tooltip/tooltip.js

@@ -0,0 +1,106 @@
+"use client";
+import { tooltipVariants } from '@masaraxui/styles';
+import React__default, { createContext, useContext } from 'react';
+import { TooltipTrigger as TooltipTrigger$1, OverlayArrow, Tooltip, Focusable } from 'react-aria-components';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { jsx } from 'react/jsx-runtime';
+
+const TooltipContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * Tooltip Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const TooltipRoot = ({
+  children,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => tooltipVariants(), []);
+  return /*#__PURE__*/jsx(TooltipContext, {
+    value: {
+      slots
+    },
+    children: /*#__PURE__*/jsx(TooltipTrigger$1, {
+      "data-slot": "tooltip-root",
+      ...props,
+      children: children
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Tooltip Content
+ * -----------------------------------------------------------------------------------------------*/
+
+const TooltipContent = ({
+  children,
+  className,
+  offset: offsetProp,
+  showArrow = false,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(TooltipContext);
+  const offset = offsetProp ? offsetProp : showArrow ? 7 : 3;
+  return /*#__PURE__*/jsx(Tooltip, {
+    ...props,
+    className: composeTwRenderProps(className, slots?.base()),
+    offset: offset,
+    children: children
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Tooltip Arrow
+ * -----------------------------------------------------------------------------------------------*/
+
+const TooltipArrow = ({
+  children,
+  className,
+  ...props
+}) => {
+  const defaultArrow = /*#__PURE__*/jsx("svg", {
+    "data-slot": "overlay-arrow",
+    height: 12,
+    viewBox: "0 0 12 12",
+    width: 12,
+    children: /*#__PURE__*/jsx("path", {
+      d: "M0 0 Q6 9 12 0"
+    })
+  });
+  const arrow = /*#__PURE__*/React__default.isValidElement(children) ? /*#__PURE__*/React__default.cloneElement(children, {
+    "data-slot": "overlay-arrow"
+  }) : defaultArrow;
+  return /*#__PURE__*/jsx(OverlayArrow, {
+    "data-slot": "tooltip-arrow",
+    ...props,
+    className: className,
+    children: arrow
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * Tooltip Trigger
+ * -----------------------------------------------------------------------------------------------*/
+
+const TooltipTrigger = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(TooltipContext);
+  return /*#__PURE__*/jsx(Focusable, {
+    children: /*#__PURE__*/jsx("div", {
+      className: composeSlotClassName(slots?.trigger, className),
+      "data-slot": "tooltip-trigger",
+      role: "button",
+      ...props,
+      children: children
+    })
+  });
+};
+
+export { TooltipArrow, TooltipContent, TooltipRoot, TooltipTrigger };

package/dist/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./use-css-variable";
+export * from "./use-is-hydrated";
+export * from "./use-list-data";
+export * from "./use-measured-height";
+export * from "./use-mounted";
+export * from "./use-overlay-state";
+export * from "./use-safe-layout-effect";
+export * from "./use-isomorphic-layout-effect";
+export * from "./use-media-query";

package/dist/hooks/use-css-variable.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A hook that safely retrieves CSS custom property values from the document element
+ * with SSR support, automatic fallback handling, and optional caching.
+ *
+ * @example
+ * ```jsx
+ * function Component() {
+ *   const animationType = useCSSVariable('--skeleton-animation')
+ *   // Returns the CSS variable value or undefined (cached by default)
+ * }
+ * ```
+ *
+ * @example
+ * ```jsx
+ * function Component({ color }) {
+ *   // Override with prop if provided
+ *   const themeColor = useCSSVariable('--theme-color', color)
+ *   // Returns color prop if defined, otherwise CSS variable value
+ * }
+ * ```
+ *
+ * @example
+ * ```jsx
+ * function Component() {
+ *   // Disable caching for dynamic CSS variables
+ *   const dynamicValue = useCSSVariable('--dynamic-value', undefined, false)
+ *   // Will always query the DOM for fresh value
+ * }
+ * ```
+ *
+ * @param variableName - The CSS custom property name (e.g., '--my-variable')
+ * @param override - Optional override value that takes precedence over CSS variable
+ * @param cache - Whether to cache the CSS variable value (default: true)
+ * @returns The CSS variable value, override value, or undefined
+ */
+export declare function useCSSVariable(variableName: string, override?: string, cache?: boolean): string | undefined;

package/dist/hooks/use-css-variable.js

@@ -0,0 +1,72 @@
+"use strict";
+import { useIsSSR } from '@react-aria/ssr';
+import * as React from 'react';
+
+// Cache for CSS variable values to avoid repeated DOM queries
+const cssVariableCache = new Map();
+
+/**
+ * A hook that safely retrieves CSS custom property values from the document element
+ * with SSR support, automatic fallback handling, and optional caching.
+ *
+ * @example
+ * ```jsx
+ * function Component() {
+ *   const animationType = useCSSVariable('--skeleton-animation')
+ *   // Returns the CSS variable value or undefined (cached by default)
+ * }
+ * ```
+ *
+ * @example
+ * ```jsx
+ * function Component({ color }) {
+ *   // Override with prop if provided
+ *   const themeColor = useCSSVariable('--theme-color', color)
+ *   // Returns color prop if defined, otherwise CSS variable value
+ * }
+ * ```
+ *
+ * @example
+ * ```jsx
+ * function Component() {
+ *   // Disable caching for dynamic CSS variables
+ *   const dynamicValue = useCSSVariable('--dynamic-value', undefined, false)
+ *   // Will always query the DOM for fresh value
+ * }
+ * ```
+ *
+ * @param variableName - The CSS custom property name (e.g., '--my-variable')
+ * @param override - Optional override value that takes precedence over CSS variable
+ * @param cache - Whether to cache the CSS variable value (default: true)
+ * @returns The CSS variable value, override value, or undefined
+ */
+function useCSSVariable(variableName, override, cache = true) {
+  const isSSR = useIsSSR();
+  return React.useMemo(() => {
+    // Return override if provided
+    if (override !== undefined) return override;
+
+    // Return undefined during SSR
+    if (isSSR) return undefined;
+
+    // Check cache first if caching is enabled
+    if (cache && cssVariableCache.has(variableName)) {
+      return cssVariableCache.get(variableName);
+    }
+    try {
+      const root = document.documentElement;
+      const value = getComputedStyle(root).getPropertyValue(variableName).trim() || undefined;
+
+      // Cache the value if caching is enabled
+      if (cache) {
+        cssVariableCache.set(variableName, value);
+      }
+      return value;
+    } catch {
+      // Return undefined if any error occurs (e.g., document not available)
+      return undefined;
+    }
+  }, [variableName, override, isSSR, cache]);
+}
+
+export { useCSSVariable };

package/dist/hooks/use-is-hydrated.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A hook that returns true if the component is mounted on the client (hydrated)
+ * and false when rendering on the server.
+ *
+ * @example
+ * ```jsx
+ * function Component() {
+ *   const isHydrated = useIsHydrated()
+ *
+ *   if (!isHydrated) {
+ *     return <div>Loading...</div>
+ *   }
+ *
+ *   return <div>Client rendered content</div>
+ * }
+ * ```
+ * @returns boolean indicating if the component is hydrated
+ */
+export declare function useIsHydrated(): boolean;

package/dist/hooks/use-is-hydrated.js

@@ -0,0 +1,28 @@
+"use strict";
+import * as React from 'react';
+
+/**
+ * A hook that returns true if the component is mounted on the client (hydrated)
+ * and false when rendering on the server.
+ *
+ * @example
+ * ```jsx
+ * function Component() {
+ *   const isHydrated = useIsHydrated()
+ *
+ *   if (!isHydrated) {
+ *     return <div>Loading...</div>
+ *   }
+ *
+ *   return <div>Client rendered content</div>
+ * }
+ * ```
+ * @returns boolean indicating if the component is hydrated
+ */
+
+function useIsHydrated() {
+  const subscribe = () => () => {};
+  return React.useSyncExternalStore(subscribe, () => true, () => false);
+}
+
+export { useIsHydrated };

package/dist/hooks/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/hooks/use-isomorphic-layout-effect.js

@@ -0,0 +1,6 @@
+"use strict";
+import { useLayoutEffect, useEffect } from 'react';
+
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+
+export { useIsomorphicLayoutEffect };