@aurora-ds/lib-test 0.0.1-dev.1

package/dist/components/overlay/dropdown-menu/components/sub/dropdown-menu-sub-content/types/DropdownMenuSubContent.props.d.ts

@@ -0,0 +1,16 @@
+import type * as React from 'react';
+import type * as RadixDropdownMenu from '@radix-ui/react-dropdown-menu';
+export type DropdownMenuSubContentProps = React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.SubContent> & {
+    /**
+     * Distance in pixels from the viewport edges used for collision detection.
+     * The sub-menu shifts inward by exactly the overflowing amount to always
+     * stay fully visible — without flipping to the opposite side.
+     * @default 8
+     */
+    collisionPadding?: number | {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+};

package/dist/components/overlay/dropdown-menu/components/sub/dropdown-menu-sub-trigger/DropdownMenuSubTrigger.css.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The item that opens a nested sub-menu on hover / focus.
+ * Stays visually "active" while the sub-menu is open (data-state="open").
+ */
+export declare const dropdownMenuSubTriggerClass: string;
+/**
+ * Trailing chevron icon. Rotates when the sub-menu is open.
+ */
+export declare const dropdownMenuSubTriggerChevronClass: string;

package/dist/components/overlay/dropdown-menu/components/sub/dropdown-menu-sub-trigger/DropdownMenuSubTrigger.d.ts

@@ -0,0 +1,10 @@
+import { DropdownMenuSubTriggerProps } from './types/DropdownMenuSubTrigger.props.ts';
+/**
+ * The item that opens the nested sub-menu on hover/focus.
+ * A chevron icon is automatically appended on the right.
+ */
+declare const DropdownMenuSubTrigger: {
+    ({ className, startIcon, label, ...props }: DropdownMenuSubTriggerProps): import("react").JSX.Element;
+    displayName: string;
+};
+export default DropdownMenuSubTrigger;

package/dist/components/overlay/dropdown-menu/components/sub/dropdown-menu-sub-trigger/types/DropdownMenuSubTrigger.props.d.ts

@@ -0,0 +1,8 @@
+import type * as React from 'react';
+import type * as RadixDropdownMenu from '@radix-ui/react-dropdown-menu';
+export type DropdownMenuSubTriggerProps = Omit<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.SubTrigger>, 'children'> & {
+    /** Text label of the trigger. */
+    label: string;
+    /** Iconify icon identifier rendered on the left side. */
+    startIcon?: string;
+};

package/dist/components/overlay/dropdown-menu/components/trigger/dropdown-menu-trigger/DropdownMenuTrigger.d.ts

@@ -0,0 +1,10 @@
+import { DropdownMenuTriggerProps } from './types/DropdownMenuTrigger.props.ts';
+/**
+ * The element that opens the dropdown.
+ * Use `asChild` to forward the trigger behaviour to your own element.
+ */
+declare const DropdownMenuTrigger: {
+    (props: DropdownMenuTriggerProps): import("react").JSX.Element;
+    displayName: string;
+};
+export default DropdownMenuTrigger;

package/dist/components/overlay/dropdown-menu/components/trigger/dropdown-menu-trigger/types/DropdownMenuTrigger.props.d.ts

@@ -0,0 +1,2 @@
+import type * as RadixDropdownMenu from '@radix-ui/react-dropdown-menu';
+export type DropdownMenuTriggerProps = React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.Trigger>;

package/dist/components/overlay/dropdown-menu/index.d.ts

@@ -0,0 +1,6 @@
+export { default as DropdownMenu } from './DropdownMenu.tsx';
+export * from './components';
+/** Re-export Radix Portal for advanced use-cases. */
+export { Portal as DropdownMenuPortal } from '@radix-ui/react-dropdown-menu';
+export type { DropdownMenuProps } from './types/DropdownMenu.props.ts';
+export type { DropdownMenuAlign, DropdownMenuSide } from './types/DropdownMenu.types.ts';

package/dist/components/overlay/dropdown-menu/types/DropdownMenu.props.d.ts

@@ -0,0 +1,4 @@
+import type * as React from 'react';
+import type * as RadixDropdownMenu from '@radix-ui/react-dropdown-menu';
+/** Props for the root `DropdownMenu` wrapper. */
+export type DropdownMenuProps = React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.Root>;

package/dist/components/overlay/dropdown-menu/types/DropdownMenu.types.d.ts

@@ -0,0 +1,4 @@
+/** Alignment of the dropdown content relative to the trigger. */
+export type DropdownMenuAlign = 'start' | 'center' | 'end';
+/** Side the dropdown content opens on. */
+export type DropdownMenuSide = 'top' | 'right' | 'bottom' | 'left';

package/dist/components/overlay/tooltip/Tooltip.css.d.ts

@@ -0,0 +1,2 @@
+export declare const tooltipContentClass: string;
+export declare const tooltipArrowClass: string;

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

@@ -0,0 +1,4 @@
+import { TooltipProps } from './types/Tooltip.props.ts';
+import { FC } from 'react';
+declare const Tooltip: FC<TooltipProps>;
+export default Tooltip;

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

@@ -0,0 +1,5 @@
+export { default as Tooltip } from './Tooltip.tsx';
+export { tooltipContentClass } from './Tooltip.css.ts';
+export type { TooltipProps } from './types/Tooltip.props.ts';
+export type { TooltipSide, TooltipAlign, TooltipPosition } from './types/Tooltip.types.ts';
+export { parsePosition } from './types/Tooltip.types.ts';

package/dist/components/overlay/tooltip/types/Tooltip.props.d.ts

@@ -0,0 +1,28 @@
+import { TooltipSide, TooltipAlign, TooltipPosition } from './Tooltip.types.ts';
+import type * as React from 'react';
+export type TooltipProps = {
+    /** The element that triggers the tooltip (must be a single React element that can receive a ref). */
+    children: React.ReactNode;
+    /** Content rendered inside the tooltip bubble. */
+    content: React.ReactNode;
+    /**
+     * Shorthand position combining side and alignment in a single value.
+     * Takes precedence over `side` and `align` when provided.
+     * @example 'top-start' | 'right' | 'bottom-end' | 'left-start'
+     */
+    position?: TooltipPosition;
+    /** Side of the trigger on which the tooltip appears. @default 'top' */
+    side?: TooltipSide;
+    /** Alignment of the tooltip along the trigger's axis. @default 'center' */
+    align?: TooltipAlign;
+    /** Delay in milliseconds before the tooltip opens. @default 300 */
+    delayDuration?: number;
+    /** Whether the tooltip is disabled. */
+    disabled?: boolean;
+    /** Additional class names to apply to the tooltip content. */
+    className?: string;
+    /** Controls the open state when used as a controlled component. */
+    open?: boolean;
+    /** Callback called when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+};

package/dist/components/overlay/tooltip/types/Tooltip.types.d.ts

@@ -0,0 +1,29 @@
+/** Side position of the tooltip relative to its trigger. */
+export type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+/** Alignment of the tooltip relative to its trigger. */
+export type TooltipAlign = 'start' | 'center' | 'end';
+/**
+ * Combined position of the tooltip — shorthand that sets both `side` and `align`
+ * in a single prop. Twelve values are available (4 sides × 3 alignments).
+ *
+ * | Value           | side     | align    |
+ * |-----------------|----------|----------|
+ * | `top-start`     | top      | start    |
+ * | `top`           | top      | center   |
+ * | `top-end`       | top      | end      |
+ * | `right-start`   | right    | start    |
+ * | `right`         | right    | center   |
+ * | `right-end`     | right    | end      |
+ * | `bottom-start`  | bottom   | start    |
+ * | `bottom`        | bottom   | center   |
+ * | `bottom-end`    | bottom   | end      |
+ * | `left-start`    | left     | start    |
+ * | `left`          | left     | center   |
+ * | `left-end`      | left     | end      |
+ */
+export type TooltipPosition = 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end';
+/** Parses a `TooltipPosition` string into its `side` and `align` parts. */
+export declare const parsePosition: (position: TooltipPosition) => {
+    side: TooltipSide;
+    align: TooltipAlign;
+};

package/dist/components/theme-provider/ThemeProvider.context.d.ts

@@ -0,0 +1,30 @@
+import { ThemeMode } from './types/ThemeProvider.props.ts';
+import { Context } from 'react';
+export interface ThemeContextValue {
+    /** Currently active mode. `'system'` means "follow the OS preference". */
+    theme: ThemeMode;
+    /**
+     * The concrete resolved mode — always `'light'` or `'dark'`, never
+     * `'system'`.  Useful for conditional rendering that depends on the actual
+     * visual state (e.g. swapping an icon).
+     */
+    resolvedTheme: 'light' | 'dark';
+    /**
+     * Change the active mode.
+     * - In **uncontrolled** mode this updates internal state.
+     * - In **controlled** mode (`theme` prop is provided) it only fires
+     *   `onThemeChange`; the parent is responsible for updating `theme`.
+     */
+    setTheme: (theme: ThemeMode) => void;
+}
+export declare const ThemeContext: Context<ThemeContextValue>;
+/**
+ * Returns the nearest `ThemeProvider` context.
+ *
+ * Safe to call outside a provider — returns `{ theme: 'system', resolvedTheme:
+ * 'light', setTheme: noop }` as a fallback.
+ *
+ * @example
+ * const { resolvedTheme, setTheme } = useTheme()
+ */
+export declare const useTheme: () => ThemeContextValue;

package/dist/components/theme-provider/ThemeProvider.d.ts

@@ -0,0 +1,36 @@
+import { FC } from 'react';
+import { ThemeProviderProps } from './types/ThemeProvider.props.ts';
+/**
+ * `ThemeProvider` wraps a subtree and manages the active color-scheme.
+ *
+ * ### What it does
+ * - Sets `data-theme="light"` or `data-theme="dark"` on its wrapper `<div>` so
+ *   the kit's CSS-variable scoping works out of the box.
+ * - In `'system'` mode it follows `prefers-color-scheme` and reactively updates
+ *   when the OS preference changes.
+ * - Accepts a `tokens` map to inject runtime CSS-variable overrides directly
+ *   on the wrapper element — no `.css.ts` file required.
+ * - Exposes `{ theme, resolvedTheme, setTheme }` via React context so any child
+ *   can read or change the active mode with the `useTheme` hook.
+ *
+ * ### Controlled vs uncontrolled
+ * - **Uncontrolled** (default): omit the `theme` prop.  The component manages
+ *   its own state; use `defaultTheme` to set the initial value.
+ * - **Controlled**: pass `theme` and handle `onThemeChange` in the parent.
+ *
+ * ### Placing in your app
+ * Wrap your whole application to enable global theming:
+ * ```tsx
+ * <ThemeProvider defaultTheme="system">
+ *   <App />
+ * </ThemeProvider>
+ * ```
+ * Or scope it to a single subtree:
+ * ```tsx
+ * <ThemeProvider theme="dark" tokens={{ primary: 'oklch(0.70 0.16 185)' }}>
+ *   <DarkWidget />
+ * </ThemeProvider>
+ * ```
+ */
+declare const ThemeProvider: FC<ThemeProviderProps>;
+export default ThemeProvider;

package/dist/components/theme-provider/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ThemeProvider } from './ThemeProvider.tsx';
+export { useTheme } from './ThemeProvider.context.ts';
+export type { ThemeContextValue } from './ThemeProvider.context.ts';
+export type { ThemeMode, ThemeProviderProps } from './types/ThemeProvider.props.ts';

package/dist/components/theme-provider/types/ThemeProvider.props.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { ThemeColor } from '../../../theme';
+/** The three mode values understood by ThemeProvider. */
+export type ThemeMode = 'light' | 'dark' | 'system';
+export interface ThemeProviderProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Controlled theme mode.
+     * When provided the component is fully controlled — pair it with
+     * `onThemeChange` to react to programmatic changes triggered by child
+     * components calling `setTheme` from `useTheme`.
+     */
+    theme?: ThemeMode;
+    /**
+     * Initial theme mode when the component is uncontrolled.
+     * @default 'system'
+     */
+    defaultTheme?: ThemeMode;
+    /**
+     * Called whenever the internal mode changes (uncontrolled) or whenever a
+     * child calls `setTheme` (both modes).
+     */
+    onThemeChange?: (theme: ThemeMode) => void;
+    /**
+     * Runtime color-token overrides injected as CSS custom properties on the
+     * wrapper element.  Every key is a semantic color token name (e.g.
+     * `primary`, `ring`) and every value is any valid CSS color.
+     *
+     * @example
+     * tokens={{ primary: 'oklch(0.55 0.2 180)', ring: 'oklch(0.55 0.2 180)' }}
+     */
+    tokens?: Partial<Record<ThemeColor, string>>;
+}

package/dist/components/theme-provider/utils/getSystemTheme.utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reads the OS color-scheme preference.  Returns `'light'` in SSR / non-browser
+ * environments to avoid hydration mismatches.
+ */
+export declare const getSystemTheme: () => "light" | "dark";

package/dist/components/theme-provider/utils/resolveTheme.utils.d.ts

@@ -0,0 +1,2 @@
+import { ThemeMode } from '../..';
+export declare const resolveTheme: (mode: ThemeMode, systemTheme: "light" | "dark") => "light" | "dark";

package/dist/constants/animations/fade/fadeIn.css.d.ts

@@ -0,0 +1 @@
+export declare const fadeIn: string;

package/dist/constants/animations/fade/fadeOut.css.d.ts

@@ -0,0 +1 @@
+export declare const fadeOut: string;

package/dist/constants/animations/index.d.ts

@@ -0,0 +1,11 @@
+export { fadeIn } from './fade/fadeIn.css.ts';
+export { fadeOut } from './fade/fadeOut.css.ts';
+export { slideDownIn } from './slide/slideDownIn.css.ts';
+export { slideDownOut } from './slide/slideDownOut.css.ts';
+export { slideUpIn } from './slide/slideUpIn.css.ts';
+export { slideUpOut } from './slide/slideUpOut.css.ts';
+export { slideRightIn } from './slide/slideRightIn.css.ts';
+export { slideRightOut } from './slide/slideRightOut.css.ts';
+export { slideLeftIn } from './slide/slideLeftIn.css.ts';
+export { slideLeftOut } from './slide/slideLeftOut.css.ts';
+export { spinAnimation } from './spin/spinAnimation.css.ts';

package/dist/constants/animations/slide/slideDownIn.css.d.ts

@@ -0,0 +1 @@
+export declare const slideDownIn: string;

package/dist/constants/animations/slide/slideDownOut.css.d.ts

@@ -0,0 +1 @@
+export declare const slideDownOut: string;

package/dist/constants/animations/slide/slideLeftIn.css.d.ts

@@ -0,0 +1 @@
+export declare const slideLeftIn: string;

package/dist/constants/animations/slide/slideLeftOut.css.d.ts

@@ -0,0 +1 @@
+export declare const slideLeftOut: string;

package/dist/constants/animations/slide/slideRightIn.css.d.ts

@@ -0,0 +1 @@
+export declare const slideRightIn: string;

package/dist/constants/animations/slide/slideRightOut.css.d.ts

@@ -0,0 +1 @@
+export declare const slideRightOut: string;

package/dist/constants/animations/slide/slideUpIn.css.d.ts

@@ -0,0 +1 @@
+export declare const slideUpIn: string;

package/dist/constants/animations/slide/slideUpOut.css.d.ts

@@ -0,0 +1 @@
+export declare const slideUpOut: string;

package/dist/constants/animations/spin/spinAnimation.css.d.ts

@@ -0,0 +1 @@
+export declare const spinAnimation: string;

package/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './animations';

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useViewportShift } from './use-viewport-shift/useViewportShift.hook.ts';

package/dist/hooks/use-viewport-shift/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const OFFSCREEN_SENTINEL = "-200%";

package/dist/hooks/use-viewport-shift/helpers/createCorrector.helper.d.ts

@@ -0,0 +1,11 @@
+import { NormalizedPadding } from '../types';
+/**
+ * Builds the idempotent correction pass. It **measures the wrapper** (stable
+ * final geometry, immune to the content's entrance `transform` animation) and
+ * **writes `translate` to the content** (composing with — not overriding — that
+ * animation). Reading the wrapper is unaffected by our content write, so the
+ * result is absolute and re-running never accumulates.
+ */
+export declare const createCorrector: (content: HTMLElement, wrapper: HTMLElement, padRef: {
+    current: NormalizedPadding;
+}) => () => void;

package/dist/hooks/use-viewport-shift/helpers/guardAccidentalSelection.helper.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Prevents the accidental selection caused by sliding an item under the cursor.
+ *
+ * Radix selects an item by synthesizing a click on `pointerup` when the press
+ * did **not** start on it (`@radix-ui/react-menu`: `onPointerUp` →
+ * `currentTarget.click()` while `!isPointerDownRef.current`). Once shifted, the
+ * `pointerup` releasing the *opening* click lands on an item and triggers it.
+ *
+ * We enforce the invariant *a pointer selection requires a `pointerdown` inside
+ * the panel*: a press-less `pointerup` is stopped in the capture phase, so the
+ * synthetic click never fires. It self-scopes (a `pointerup` only reaches the
+ * panel once moved under the cursor) and leaves genuine clicks and keyboard
+ * navigation untouched. Returns a cleanup that detaches the listeners.
+ */
+export declare const guardAccidentalSelection: (content: HTMLElement) => () => void;

package/dist/hooks/use-viewport-shift/helpers/normalizePadding.helper.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedPadding, Padding } from '../types';
+/** Expands a uniform number or a partial per-side object into a full padding. */
+export declare const normalizePadding: (padding: Padding) => NormalizedPadding;

package/dist/hooks/use-viewport-shift/helpers/watchRepositions.helper.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Re-runs `correct` on every event that can change the panel's box:
+ * - the wrapper's `style` mutations → floating-ui (re)positioning, incl. the
+ *   async transition from the off-screen sentinel to the final coordinates;
+ * - the content resizing (dynamic item lists) — also fires once on observe,
+ *   covering a wrapper already positioned when the ref attached;
+ * - viewport resize.
+ * Returns a cleanup that detaches everything.
+ */
+export declare const watchRepositions: (content: HTMLElement, wrapper: HTMLElement, correct: () => void) => () => void;

package/dist/hooks/use-viewport-shift/types/index.d.ts

@@ -0,0 +1,12 @@
+export type Padding = number | {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+export type NormalizedPadding = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};

package/dist/hooks/use-viewport-shift/useViewportShift.hook.d.ts

@@ -0,0 +1,13 @@
+import { Padding } from './types';
+/**
+ * Returns a React 19 **callback ref** that keeps a Radix floating panel fully
+ * visible within the viewport by applying a CSS `translate` correction.
+ *
+ * A callback ref is required because Radix `Portal` mounts content in a second
+ * render pass, so a parent `useLayoutEffect` would fire while the node is still
+ * `null`; the callback fires exactly when the DOM node attaches.
+ *
+ * @param collisionPadding - Minimum gap in px between the panel and each
+ *   viewport edge. Accepts a uniform number or a per-side object. @default 8
+ */
+export declare const useViewportShift: (collisionPadding?: Padding) => (content: HTMLDivElement | null) => (() => void) | void;