@wecode-team/we0-cms 1.1.33 → 1.1.34

package/dist/components/tiptap-ui/undo-redo-button/use-undo-redo.d.ts

@@ -0,0 +1,90 @@
+import { type Editor } from "@tiptap/react";
+export type UndoRedoAction = "undo" | "redo";
+/**
+ * Configuration for the history functionality
+ */
+export interface UseUndoRedoConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The history action to perform (undo or redo).
+     */
+    action: UndoRedoAction;
+    /**
+     * Whether the button should hide when action is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful action execution.
+     */
+    onExecuted?: () => void;
+}
+export declare const UNDO_REDO_SHORTCUT_KEYS: Record<UndoRedoAction, string>;
+export declare const historyActionLabels: Record<UndoRedoAction, string>;
+export declare const historyIcons: {
+    undo: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+    redo: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};
+/**
+ * Checks if a history action can be executed
+ */
+export declare function canExecuteUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+/**
+ * Executes a history action on the editor
+ */
+export declare function executeUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+/**
+ * Determines if the history button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    action: UndoRedoAction;
+}): boolean;
+/**
+ * Custom hook that provides history functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleUndoButton() {
+ *   const { isVisible, handleAction } = useHistory({ action: "undo" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleAction}>Undo</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedRedoButton() {
+ *   const { isVisible, handleAction, label } = useHistory({
+ *     editor: myEditor,
+ *     action: "redo",
+ *     hideWhenUnavailable: true,
+ *     onExecuted: () => console.log('Action executed!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleAction}
+ *       aria-label={label}
+ *     >
+ *       Redo
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useUndoRedo(config: UseUndoRedoConfig): {
+    isVisible: boolean;
+    handleAction: () => boolean;
+    canExecute: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element> | import("react").MemoExoticComponent<({ className, ...props }: Omit<import("react").SVGProps<SVGSVGElement>, "ref">) => import("react").JSX.Element>;
+};

package/dist/components/tiptap-ui-primitive/badge/badge.d.ts

@@ -0,0 +1,11 @@
+import "@/components/tiptap-ui-primitive/badge/badge-colors.scss";
+import "@/components/tiptap-ui-primitive/badge/badge-group.scss";
+import "@/components/tiptap-ui-primitive/badge/badge.scss";
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "ghost" | "white" | "gray" | "green" | "yellow" | "default";
+    size?: "default" | "small";
+    appearance?: "default" | "subdued" | "emphasized";
+    trimText?: boolean;
+}
+export declare const Badge: import("react").ForwardRefExoticComponent<BadgeProps & import("react").RefAttributes<HTMLDivElement>>;
+export default Badge;

package/dist/components/tiptap-ui-primitive/badge/index.d.ts

@@ -0,0 +1 @@
+export * from "./badge";

package/dist/components/tiptap-ui-primitive/button/button.d.ts

@@ -0,0 +1,16 @@
+import "@/components/tiptap-ui-primitive/button/button-colors.scss";
+import "@/components/tiptap-ui-primitive/button/button.scss";
+export type ButtonVariant = "ghost" | "primary";
+export type ButtonSize = "small" | "default" | "large";
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    showTooltip?: boolean;
+    tooltip?: React.ReactNode;
+    shortcutKeys?: string;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+}
+export declare const ShortcutDisplay: React.FC<{
+    shortcuts: string[];
+}>;
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export default Button;

package/dist/components/tiptap-ui-primitive/button/index.d.ts

@@ -0,0 +1 @@
+export * from "./button";

package/dist/components/tiptap-ui-primitive/button-group/button-group.d.ts

@@ -0,0 +1,11 @@
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Separator } from "@/components/tiptap-ui-primitive/separator";
+import "./button-group.scss";
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): import("react").JSX.Element;
+declare function ButtonGroupText({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): import("react").JSX.Element;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants, };

package/dist/components/tiptap-ui-primitive/button-group/index.d.ts

@@ -0,0 +1 @@
+export * from "./button-group";

package/dist/components/tiptap-ui-primitive/card/card.d.ts

@@ -0,0 +1,10 @@
+import "@/components/tiptap-ui-primitive/card/card.scss";
+declare const Card: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardHeader: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardBody: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardItemGroup: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardGroupLabel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const CardFooter: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardBody, CardItemGroup, CardGroupLabel };

package/dist/components/tiptap-ui-primitive/card/index.d.ts

@@ -0,0 +1 @@
+export * from "./card";

package/dist/components/tiptap-ui-primitive/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,29 @@
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import "@/components/tiptap-ui-primitive/dropdown-menu/dropdown-menu.scss";
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react").JSX.Element;
+declare function DropdownMenuContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react").JSX.Element;
+declare function DropdownMenuGroup({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/components/tiptap-ui-primitive/dropdown-menu/index.d.ts

@@ -0,0 +1 @@
+export * from "./dropdown-menu";

package/dist/components/tiptap-ui-primitive/input/index.d.ts

@@ -0,0 +1 @@
+export * from "./input";

package/dist/components/tiptap-ui-primitive/input/input.d.ts

@@ -0,0 +1,3 @@
+import "@/components/tiptap-ui-primitive/input/input.scss";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): import("react").JSX.Element;
+export { Input };

package/dist/components/tiptap-ui-primitive/popover/index.d.ts

@@ -0,0 +1 @@
+export * from "./popover";

package/dist/components/tiptap-ui-primitive/popover/popover.d.ts

@@ -0,0 +1,6 @@
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+import "@/components/tiptap-ui-primitive/popover/popover.scss";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react").JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react").JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent };

package/dist/components/tiptap-ui-primitive/separator/index.d.ts

@@ -0,0 +1 @@
+export * from "./separator";

package/dist/components/tiptap-ui-primitive/separator/separator.d.ts

@@ -0,0 +1,6 @@
+import "@/components/tiptap-ui-primitive/separator/separator.scss";
+export type Orientation = "horizontal" | "vertical";
+export declare function Separator({ decorative, orientation, className, ...props }: React.ComponentProps<"div"> & {
+    orientation?: Orientation;
+    decorative?: boolean;
+}): import("react").JSX.Element;

package/dist/components/tiptap-ui-primitive/spacer/index.d.ts

@@ -0,0 +1 @@
+export * from "./spacer";

package/dist/components/tiptap-ui-primitive/spacer/spacer.d.ts

@@ -0,0 +1,5 @@
+export type SpacerOrientation = "horizontal" | "vertical";
+export declare function Spacer({ orientation, size, style, ...props }: React.ComponentProps<"div"> & {
+    orientation?: SpacerOrientation;
+    size?: string | number;
+}): import("react").JSX.Element;

package/dist/components/tiptap-ui-primitive/toolbar/index.d.ts

@@ -0,0 +1 @@
+export * from "./toolbar";

package/dist/components/tiptap-ui-primitive/toolbar/toolbar.d.ts

@@ -0,0 +1,9 @@
+import "@/components/tiptap-ui-primitive/toolbar/toolbar.scss";
+type BaseProps = React.HTMLAttributes<HTMLDivElement>;
+interface ToolbarProps extends BaseProps {
+    variant?: "floating" | "fixed";
+}
+export declare const Toolbar: import("react").ForwardRefExoticComponent<ToolbarProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ToolbarGroup: import("react").ForwardRefExoticComponent<BaseProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ToolbarSeparator: import("react").ForwardRefExoticComponent<BaseProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/tiptap-ui-primitive/tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from "./tooltip";

package/dist/components/tiptap-ui-primitive/tooltip/tooltip.d.ts

@@ -0,0 +1,29 @@
+import { FloatingPortal, type Placement } from "@floating-ui/react";
+import "@/components/tiptap-ui-primitive/tooltip/tooltip.scss";
+interface TooltipProviderProps {
+    children: React.ReactNode;
+    initialOpen?: boolean;
+    placement?: Placement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    delay?: number;
+    closeDelay?: number;
+    timeout?: number;
+    useDelayGroup?: boolean;
+}
+interface TooltipTriggerProps extends Omit<React.HTMLProps<HTMLElement>, "ref"> {
+    asChild?: boolean;
+    children: React.ReactNode;
+}
+interface TooltipContentProps extends Omit<React.HTMLProps<HTMLDivElement>, "ref"> {
+    children?: React.ReactNode;
+    portal?: boolean;
+    portalProps?: Omit<React.ComponentProps<typeof FloatingPortal>, "children">;
+}
+export declare function Tooltip({ children, ...props }: TooltipProviderProps): import("react").JSX.Element;
+export declare namespace Tooltip {
+    var displayName: string;
+}
+export declare const TooltipTrigger: import("react").ForwardRefExoticComponent<TooltipTriggerProps & import("react").RefAttributes<HTMLElement>>;
+export declare const TooltipContent: import("react").ForwardRefExoticComponent<TooltipContentProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/hooks/use-composed-ref.d.ts

@@ -0,0 +1,3 @@
+type UserRef<T> = ((instance: T | null) => void) | React.RefObject<T | null> | null | undefined;
+export declare const useComposedRef: <T extends HTMLElement>(libRef: React.RefObject<T | null>, userRef: UserRef<T>) => (instance: T | null) => void;
+export default useComposedRef;

package/dist/hooks/use-cursor-visibility.d.ts

@@ -0,0 +1,20 @@
+import type { Editor } from "@tiptap/react";
+export interface CursorVisibilityOptions {
+    /**
+     * The Tiptap editor instance
+     */
+    editor?: Editor | null;
+    /**
+     * Reference to the toolbar element that may obscure the cursor
+     */
+    overlayHeight?: number;
+}
+/**
+ * Custom hook that ensures the cursor remains visible when typing in a Tiptap editor.
+ * Automatically scrolls the window when the cursor would be hidden by the toolbar.
+ *
+ * @param options.editor The Tiptap editor instance
+ * @param options.overlayHeight Toolbar height to account for
+ * @returns The bounding rect of the body
+ */
+export declare function useCursorVisibility({ editor, overlayHeight, }: CursorVisibilityOptions): import("@/hooks/use-element-rect").RectState;

package/dist/hooks/use-element-rect.d.ts

@@ -0,0 +1,35 @@
+export type RectState = Omit<DOMRect, "toJSON">;
+export interface ElementRectOptions {
+    /**
+     * The element to track. Can be an Element, ref, or selector string.
+     * Defaults to document.body if not provided.
+     */
+    element?: Element | React.RefObject<Element> | string | null;
+    /**
+     * Whether to enable rect tracking
+     */
+    enabled?: boolean;
+    /**
+     * Throttle delay in milliseconds for rect updates
+     */
+    throttleMs?: number;
+    /**
+     * Whether to use ResizeObserver for more accurate tracking
+     */
+    useResizeObserver?: boolean;
+}
+/**
+ * Custom hook that tracks an element's bounding rectangle and updates on resize, scroll, etc.
+ *
+ * @param options Configuration options for element rect tracking
+ * @returns The current bounding rectangle of the element
+ */
+export declare function useElementRect({ element, enabled, throttleMs, useResizeObserver, }?: ElementRectOptions): RectState;
+/**
+ * Convenience hook for tracking document.body rect
+ */
+export declare function useBodyRect(options?: Omit<ElementRectOptions, "element">): RectState;
+/**
+ * Convenience hook for tracking a ref element's rect
+ */
+export declare function useRefRect<T extends Element>(ref: React.RefObject<T>, options?: Omit<ElementRectOptions, "element">): RectState;

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

@@ -0,0 +1,9 @@
+type BreakpointMode = "min" | "max";
+/**
+ * Hook to detect whether the current viewport matches a given breakpoint rule.
+ * Example:
+ *   useIsBreakpoint("max", 768)   // true when width < 768
+ *   useIsBreakpoint("min", 1024)  // true when width >= 1024
+ */
+export declare function useIsBreakpoint(mode?: BreakpointMode, breakpoint?: number): boolean;
+export {};

package/dist/hooks/use-menu-navigation.d.ts

@@ -0,0 +1,52 @@
+import type { Editor } from "@tiptap/react";
+type Orientation = "horizontal" | "vertical" | "both";
+interface MenuNavigationOptions<T> {
+    /**
+     * The Tiptap editor instance, if using with a Tiptap editor.
+     */
+    editor?: Editor | null;
+    /**
+     * Reference to the container element for handling keyboard events.
+     */
+    containerRef?: React.RefObject<HTMLElement | null>;
+    /**
+     * Search query that affects the selected item.
+     */
+    query?: string;
+    /**
+     * Array of items to navigate through.
+     */
+    items: T[];
+    /**
+     * Callback fired when an item is selected.
+     */
+    onSelect?: (item: T) => void;
+    /**
+     * Callback fired when the menu should close.
+     */
+    onClose?: () => void;
+    /**
+     * The navigation orientation of the menu.
+     * @default "vertical"
+     */
+    orientation?: Orientation;
+    /**
+     * Whether to automatically select the first item when the menu opens.
+     * @default true
+     */
+    autoSelectFirstItem?: boolean;
+}
+/**
+ * Hook that implements keyboard navigation for dropdown menus and command palettes.
+ *
+ * Handles arrow keys, tab, home/end, enter for selection, and escape to close.
+ * Works with both Tiptap editors and regular DOM elements.
+ *
+ * @param options - Configuration options for the menu navigation
+ * @returns Object containing the selected index and a setter function
+ */
+export declare function useMenuNavigation<T>({ editor, containerRef, query, items, onSelect, onClose, orientation, autoSelectFirstItem, }: MenuNavigationOptions<T>): {
+    selectedIndex: number | undefined;
+    setSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+};
+export {};

package/dist/hooks/use-scrolling.d.ts

@@ -0,0 +1,8 @@
+import type { RefObject } from "react";
+type ScrollTarget = RefObject<HTMLElement> | Window | null | undefined;
+interface UseScrollingOptions {
+    debounce?: number;
+    fallbackToDocument?: boolean;
+}
+export declare function useScrolling(target?: ScrollTarget, options?: UseScrollingOptions): boolean;
+export {};

package/dist/hooks/use-throttled-callback.d.ts

@@ -0,0 +1,18 @@
+interface ThrottleSettings {
+    leading?: boolean | undefined;
+    trailing?: boolean | undefined;
+}
+/**
+ * A hook that returns a throttled callback function.
+ *
+ * @param fn The function to throttle
+ * @param wait The time in ms to wait before calling the function
+ * @param dependencies The dependencies to watch for changes
+ * @param options The throttle options
+ */
+export declare function useThrottledCallback<T extends (...args: any[]) => any>(fn: T, wait?: number, dependencies?: React.DependencyList, options?: ThrottleSettings): {
+    (this: ThisParameterType<T>, ...args: Parameters<T>): ReturnType<T>;
+    cancel: () => void;
+    flush: () => void;
+};
+export default useThrottledCallback;

package/dist/hooks/use-tiptap-editor.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "@tiptap/react";
+export declare function useTiptapEditor(providedEditor?: Editor | null): {
+    editor: Editor | null;
+    editorState?: Editor["state"];
+    canCommand?: Editor["can"];
+};

package/dist/hooks/use-unmount.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook that executes a callback when the component unmounts.
+ *
+ * @param callback Function to be called on component unmount
+ */
+export declare const useUnmount: (callback: (...args: Array<any>) => any) => void;
+export default useUnmount;

package/dist/hooks/use-window-size.d.ts

@@ -0,0 +1,35 @@
+export interface WindowSizeState {
+    /**
+     * The width of the window's visual viewport in pixels.
+     */
+    width: number;
+    /**
+     * The height of the window's visual viewport in pixels.
+     */
+    height: number;
+    /**
+     * The distance from the top of the visual viewport to the top of the layout viewport.
+     * Particularly useful for handling mobile keyboard appearance.
+     */
+    offsetTop: number;
+    /**
+     * The distance from the left of the visual viewport to the left of the layout viewport.
+     */
+    offsetLeft: number;
+    /**
+     * The scale factor of the visual viewport.
+     * This is useful for scaling elements based on the current zoom level.
+     */
+    scale: number;
+}
+/**
+ * Hook that tracks the window's visual viewport dimensions, position, and provides
+ * a CSS transform for positioning elements.
+ *
+ * Uses the Visual Viewport API to get accurate measurements, especially important
+ * for mobile devices where virtual keyboards can change the visible area.
+ * Only updates state when values actually change to optimize performance.
+ *
+ * @returns An object containing viewport properties and a CSS transform string
+ */
+export declare function useWindowSize(): WindowSizeState;