@mieweb/ui 0.6.1 → 0.7.0-dev.178

package/dist/hooks/index.d.ts

@@ -1,5 +1,9 @@
 export { R as ResolvedTheme, T as Theme, u as useTheme } from '../useTheme-B9SWu6ui.js';
+import * as React from 'react';
 import { RefObject } from 'react';
+export { A as AnchoredPlacement, U as UseAnchoredPositionOptions, a as UseAnchoredPositionReturn, u as useAnchoredPosition } from '../useAnchoredPosition-nXdSFKHf.js';
+export { D as DEFAULT_FILLER_WORDS, a as DEFAULT_MIN_SILENCE_MS, b as DEFAULT_NL_SILENCE_MS, F as FillerAnalysis, S as SilenceThresholdCount, T as TranscriptClipboard, c as TranscriptEditStats, U as UseTranscriptEditsOptions, d as UseTranscriptEditsResult, e as buildPlaybackSegments, g as getSpeedAtIndex, i as initEditableWords, f as insertSilences, u as useTranscriptEdits } from '../useTranscriptEdits-CWYnjbGP.js';
+import '../transcript-oaWqY3yr.js';
 
 interface UseScrollSpyOptions {
     /** CSS selector for the elements to observe (e.g. 'h2, h3, h4') */
@@ -76,7 +80,7 @@ declare function usePrefersReducedMotion(): boolean;
  * }
  * ```
  */
-declare function useClickOutside<T extends HTMLElement>(ref: RefObject<T | null>, callback: () => void, enabled?: boolean): void;
+declare function useClickOutside<T extends HTMLElement>(ref: RefObject<T | null> | ReadonlyArray<RefObject<HTMLElement | null>>, callback: () => void, enabled?: boolean): void;
 
 /**
  * Hook that triggers a callback when the Escape key is pressed.
@@ -212,4 +216,149 @@ declare function useIsLargeDesktop(): boolean;
 /** Returns true when viewport is smaller than 1024px (mobile/tablet) */
 declare function useIsMobileOrTablet(): boolean;
 
-export { type KeyboardShortcutOptions, type UseScrollSpyOptions, type UseScrollSpyReturn, useClickOutside, useCommandK, useEscapeKey, useFocusTrap, useIsDesktop, useIsLargeDesktop, useIsMobile, useIsMobileOrTablet, useIsSmallTablet, useIsTablet, useKeyboardShortcut, useMediaQuery, usePrefersReducedMotion, useScrollSpy };
+/** Insert `draggedId` before/after `targetId` in `ids`. */
+declare function reorderIds(ids: string[], draggedId: string, targetId: string, after: boolean): string[];
+interface UseDragReorderOptions {
+    /** Current flat order of item ids (props order) */
+    ids: string[];
+    /** Called with the full new id order after a drop. Omit to disable dragging. */
+    onReorder?: (ids: string[]) => void;
+    /** Restrict drops, e.g. to the same status group */
+    canDropOn?: (draggedId: string, targetId: string) => boolean;
+}
+interface DragOverState {
+    id: string;
+    /** Drop indicator position relative to the hovered row */
+    after: boolean;
+}
+interface UseDragReorderReturn {
+    /** Whether drag reordering is active (onReorder provided) */
+    enabled: boolean;
+    /** Id currently being dragged, if any */
+    draggingId: string | null;
+    /** Row currently hovered as a drop target */
+    over: DragOverState | null;
+    /** Spread onto each row element (must be keyed by a stable id) */
+    rowProps: (id: string) => React.HTMLAttributes<HTMLElement>;
+}
+/**
+ * HTML5 drag-and-drop list reordering. Rows spread `rowProps(id)`; on drop the
+ * hook computes the full new id order and reports it via `onReorder` — the
+ * consumer persists it (e.g. on the encounter/patient object) and feeds the
+ * list back in props order.
+ *
+ * Drag-and-drop is a pointer-only affordance: pair it with a keyboard
+ * alternative (e.g. move buttons / Alt+Arrow keys) for accessibility.
+ *
+ * @example
+ * ```tsx
+ * const drag = useDragReorder({ ids: items.map((i) => i.id), onReorder });
+ * // <li {...drag.rowProps(item.id)} className={cn(dragIndicatorClasses(drag, item.id))}>
+ * ```
+ */
+declare function useDragReorder({ ids, onReorder, canDropOn, }: UseDragReorderOptions): UseDragReorderReturn;
+/** Tailwind classes for the drag state of a row: drop indicator + dragging dim. */
+declare function dragIndicatorClasses(drag: Pick<UseDragReorderReturn, 'draggingId' | 'over'>, id: string): string;
+
+/**
+ * State for an `aria-live` region that re-announces even when the same
+ * message is emitted twice in a row. Setting identical React state bails out
+ * (and identical DOM text isn't a mutation), so screen readers would stay
+ * silent for repeated actions like "moved down" — this clears the region
+ * first, then sets the message a tick later.
+ *
+ * @example
+ * ```tsx
+ * const [announcement, announce] = useLiveAnnouncement();
+ * // announce('Item moved down');
+ * // <div aria-live="polite" className="sr-only">{announcement}</div>
+ * ```
+ */
+declare function useLiveAnnouncement(): [string, (message: string) => void];
+
+type MediaTransportState = 'idle' | 'loading' | 'playing' | 'paused' | 'error';
+interface UseMediaTransportOptions {
+    /** Fired on every native `timeupdate` and on metadata load, in milliseconds. */
+    onTimeUpdate?: (currentTimeMs: number, durationMs: number) => void;
+    /** Fired whenever the derived transport state changes. */
+    onStateChange?: (state: MediaTransportState) => void;
+    /** Fired when playback reaches the end. */
+    onEnded?: () => void;
+    /** Fired on a media error, with a descriptive Error. */
+    onError?: (error: Error) => void;
+    /** Initial playback rate (default `1`). Kept in sync with the element. */
+    initialRate?: number;
+    /** Transport state to enter when playback ends (default `'paused'`). */
+    endedState?: Extract<MediaTransportState, 'idle' | 'paused'>;
+    /** Reset the position to `0` when playback ends (default `false`). */
+    resetTimeOnEnd?: boolean;
+    /** Human-readable label used in the error message (default `'media'`). */
+    errorLabel?: string;
+}
+interface UseMediaTransportReturn {
+    /**
+     * Callback ref for the `<audio>`/`<video>` element to control. Pass this to
+     * the element's `ref` (or call it imperatively). Transport listeners attach
+     * when an element mounts and detach when it unmounts.
+     */
+    setMediaElement: (element: HTMLMediaElement | null) => void;
+    /** The currently attached media element, or `null`. */
+    mediaElement: HTMLMediaElement | null;
+    /** Derived transport state. */
+    state: MediaTransportState;
+    /** Current playback position in milliseconds. */
+    currentTimeMs: number;
+    /** Media duration in milliseconds (`0` until known / non-finite). */
+    durationMs: number;
+    /** Current playback rate. */
+    playbackRate: number;
+    /** `true` while `state === 'playing'`. */
+    isPlaying: boolean;
+    /** `true` while `state === 'loading'`. */
+    isLoading: boolean;
+    /** Start playback. */
+    play: () => void;
+    /** Pause playback. */
+    pause: () => void;
+    /** Toggle between play and pause. */
+    togglePlay: () => void;
+    /** Seek to a position in milliseconds. */
+    seekToMs: (timeMs: number) => void;
+    /** Set the playback rate multiplier. */
+    setPlaybackRate: (rate: number) => void;
+    /** Read the current position in milliseconds. */
+    getCurrentTimeMs: () => number;
+    /** Read the duration in milliseconds (`0` when unknown). */
+    getDurationMs: () => number;
+    /** Whether playback is currently paused (reads the element directly). */
+    isPaused: () => boolean;
+}
+/**
+ * Headless playback transport for a native `HTMLMediaElement`.
+ *
+ * Owns the derived transport state (idle/loading/playing/paused/error),
+ * position, duration and playback rate, and exposes imperative controls — all
+ * in **milliseconds**. It never creates or renders an element: pass the
+ * returned {@link UseMediaTransportReturn.setMediaElement} callback to an
+ * `<audio>`/`<video>` `ref` and the hook wires the native listeners.
+ *
+ * Shared by `MediaPlayer` (ms API) and, at the boundary, `AudioPlayer`
+ * (seconds API — convert with `ms / 1000`). The WaveSurfer waveform variant is
+ * out of scope; this hook targets native media transport only.
+ *
+ * @example
+ * ```tsx
+ * function Player({ src }: { src: string }) {
+ *   const t = useMediaTransport({ onEnded: () => console.log('done') });
+ *   return (
+ *     <div>
+ *       <video ref={t.setMediaElement} src={src} controls />
+ *       <button onClick={t.togglePlay}>{t.isPlaying ? 'Pause' : 'Play'}</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMediaTransport(options?: UseMediaTransportOptions): UseMediaTransportReturn;
+
+export { type DragOverState, type KeyboardShortcutOptions, type MediaTransportState, type UseDragReorderOptions, type UseDragReorderReturn, type UseMediaTransportOptions, type UseMediaTransportReturn, type UseScrollSpyOptions, type UseScrollSpyReturn, dragIndicatorClasses, reorderIds, useClickOutside, useCommandK, useDragReorder, useEscapeKey, useFocusTrap, useIsDesktop, useIsLargeDesktop, useIsMobile, useIsMobileOrTablet, useIsSmallTablet, useIsTablet, useKeyboardShortcut, useLiveAnnouncement, useMediaQuery, useMediaTransport, usePrefersReducedMotion, useScrollSpy };

package/dist/hooks/index.js

@@ -1,9 +1,13 @@
-export { useCommandK, useIsDesktop, useIsLargeDesktop, useIsMobile, useIsMobileOrTablet, useIsSmallTablet, useIsTablet, useKeyboardShortcut, useMediaQuery, useScrollSpy } from '../chunk-Q7NBJFEB.js';
+export { useCommandK, useIsDesktop, useIsLargeDesktop, useIsMobile, useIsMobileOrTablet, useIsSmallTablet, useIsTablet, useKeyboardShortcut, useMediaQuery, useScrollSpy } from '../chunk-ZGSC2CB2.js';
 export { useTheme } from '../chunk-KJZNEVYM.js';
+export { DEFAULT_FILLER_WORDS, DEFAULT_MIN_SILENCE_MS, DEFAULT_NL_SILENCE_MS, buildPlaybackSegments, getSpeedAtIndex, initEditableWords, insertSilences, useTranscriptEdits } from '../chunk-NTYGCBCL.js';
+export { useMediaTransport } from '../chunk-SQHMGT4W.js';
+export { dragIndicatorClasses, reorderIds, useDragReorder, useLiveAnnouncement } from '../chunk-7ZVTLTJF.js';
 export { usePrefersReducedMotion } from '../chunk-HB7C7NB5.js';
-export { useClickOutside } from '../chunk-OKBR6PX4.js';
 export { useFocusTrap } from '../chunk-4SMSH4OY.js';
 export { useEscapeKey } from '../chunk-T4ME7QCT.js';
+export { useClickOutside } from '../chunk-62ZOA6PX.js';
+export { useAnchoredPosition } from '../chunk-QA6ZDHFP.js';
 import '../chunk-VSQF22GL.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/html-MdxqSzjD.d.cts

@@ -0,0 +1,13 @@
+/**
+ * Extracts visible text from an HTML string without using regex.
+ * Uses a simple character-by-character state machine to skip tags.
+ * This avoids CodeQL false-positives associated with regex-based tag stripping.
+ */
+declare function stripHtmlTags(html: string): string;
+/**
+ * Returns true when an HTML string has no visible text content.
+ * This is a visibility check, not a sanitizer — do NOT use for XSS prevention.
+ */
+declare function isHtmlEmpty(html: string): boolean;
+
+export { isHtmlEmpty as i, stripHtmlTags as s };

package/dist/html-MdxqSzjD.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extracts visible text from an HTML string without using regex.
+ * Uses a simple character-by-character state machine to skip tags.
+ * This avoids CodeQL false-positives associated with regex-based tag stripping.
+ */
+declare function stripHtmlTags(html: string): string;
+/**
+ * Returns true when an HTML string has no visible text content.
+ * This is a visibility check, not a sanitizer — do NOT use for XSS prevention.
+ */
+declare function isHtmlEmpty(html: string): boolean;
+
+export { isHtmlEmpty as i, stripHtmlTags as s };