@astra-kit/ui 0.0.0-stage → 1.0.0

package/dist/hooks/use-rich-link-editor.js

@@ -0,0 +1,515 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+/** Owns the state of `RichLinkEditor`: content, tracked links, popover and selection. */
+import { useLayoutEffect, useRef, useState } from "react";
+import { RICH_LINK_KIND, RICH_LINK_POPOVER_MODE, RICH_PREVIEW_LINK_SOURCE, RICH_TEXT_CLIPBOARD_DATA_TYPE, RICH_TEXT_EDITOR_INPUT_TYPE, RICH_TEXT_EDITOR_KEY, RICH_TEXT_EDITOR_KEY_LENGTH, RICH_TEXT_EDITOR_TEXT, RICH_TEXT_EDITOR_WORD_DIRECTION } from "../lib/rich-text/link-markdown-constants.js";
+import { deserializeMarkdownForEditor, getLinksAfterTextChange, getWordDeletionRange, isLinkSynchronized, normalizeMarkdownUrl, parsePreviewSegments, rangesOverlap, serializeEditorContent } from "../lib/rich-text/link-markdown.js";
+import { getEditorSelectionRange, setEditorSelectionRange } from "../lib/rich-text/rich-text-editor-dom.js";
+const EMPTY_TEXT = "";
+/**
+* Controls a rich link editor backed by a `contentEditable` element: it owns the
+* plain-text content, the tracked explicit/suppressed links, the link popover
+* state, and the selection bookkeeping, and exposes serialize/reset/snapshot
+* helpers so a feature can persist or restore the value. The DOM rendering lives
+* in `RichLinkEditor`.
+*/
+export function useRichLinkEditor(t0) {
+	const $ = _c(72);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === undefined ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else {
+		t1 = $[1];
+	}
+	const options = t1;
+	const editorRef = useRef(null);
+	let t2;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t2 = (node) => {
+			editorRef.current = node;
+		};
+		$[2] = t2;
+	} else {
+		t2 = $[2];
+	}
+	const setEditorElement = t2;
+	const pendingSelectionRef = useRef(null);
+	let t3;
+	if ($[3] !== options.initialMarkdown) {
+		t3 = () => deserializeMarkdownForEditor(options.initialMarkdown ?? EMPTY_TEXT).content;
+		$[3] = options.initialMarkdown;
+		$[4] = t3;
+	} else {
+		t3 = $[4];
+	}
+	const [content, setContent] = useState(t3);
+	let t4;
+	if ($[5] !== options.initialMarkdown) {
+		t4 = () => deserializeMarkdownForEditor(options.initialMarkdown ?? EMPTY_TEXT).links;
+		$[5] = options.initialMarkdown;
+		$[6] = t4;
+	} else {
+		t4 = $[6];
+	}
+	const [links, setLinks] = useState(t4);
+	const [activeLink, setActiveLink] = useState(null);
+	const [linkTextInput, setLinkTextInput] = useState("");
+	const [linkUrlInput, setLinkUrlInput] = useState("");
+	const [popoverMode, setPopoverMode] = useState(RICH_LINK_POPOVER_MODE.actions);
+	let t5;
+	if ($[7] !== content || $[8] !== links) {
+		t5 = parsePreviewSegments(content, links);
+		$[7] = content;
+		$[8] = links;
+		$[9] = t5;
+	} else {
+		t5 = $[9];
+	}
+	const segments = t5;
+	const hasContent = content.length > 0;
+	let t6;
+	if ($[10] !== linkUrlInput) {
+		t6 = normalizeMarkdownUrl(linkUrlInput);
+		$[10] = linkUrlInput;
+		$[11] = t6;
+	} else {
+		t6 = $[11];
+	}
+	const normalizedLinkUrlInput = t6;
+	let t7;
+	if ($[12] !== linkUrlInput || $[13] !== normalizedLinkUrlInput) {
+		t7 = linkUrlInput.trim().length > 0 && normalizedLinkUrlInput === null;
+		$[12] = linkUrlInput;
+		$[13] = normalizedLinkUrlInput;
+		$[14] = t7;
+	} else {
+		t7 = $[14];
+	}
+	const hasInvalidLinkUrl = t7;
+	let t8;
+	if ($[15] !== linkTextInput || $[16] !== normalizedLinkUrlInput) {
+		t8 = normalizedLinkUrlInput !== null && linkTextInput.trim().length > 0;
+		$[15] = linkTextInput;
+		$[16] = normalizedLinkUrlInput;
+		$[17] = t8;
+	} else {
+		t8 = $[17];
+	}
+	const isLinkEditValid = t8;
+	let t9;
+	if ($[18] === Symbol.for("react.memo_cache_sentinel")) {
+		t9 = () => {
+			const editor = editorRef.current;
+			const selectionRange = pendingSelectionRef.current;
+			if (!editor || !selectionRange || !editor.contains(document.activeElement)) {
+				return;
+			}
+			setEditorSelectionRange(editor, selectionRange);
+			pendingSelectionRef.current = null;
+		};
+		$[18] = t9;
+	} else {
+		t9 = $[18];
+	}
+	let t10;
+	if ($[19] !== content || $[20] !== links) {
+		t10 = [content, links];
+		$[19] = content;
+		$[20] = links;
+		$[21] = t10;
+	} else {
+		t10 = $[21];
+	}
+	useLayoutEffect(t9, t10);
+	let t11;
+	if ($[22] !== content || $[23] !== options) {
+		t11 = (nextContent) => {
+			setLinks((currentLinks) => getLinksAfterTextChange({
+				links: currentLinks,
+				nextText: nextContent,
+				previousText: content
+			}));
+			setContent(nextContent);
+			options.onContentChange?.();
+		};
+		$[22] = content;
+		$[23] = options;
+		$[24] = t11;
+	} else {
+		t11 = $[24];
+	}
+	const handleContentChange = t11;
+	let t12;
+	if ($[25] !== content || $[26] !== handleContentChange) {
+		t12 = (replacementText, selectionRange_0) => {
+			const nextSelectionOffset = selectionRange_0.start + replacementText.length;
+			const nextContent_0 = content.slice(0, selectionRange_0.start) + replacementText + content.slice(selectionRange_0.end);
+			pendingSelectionRef.current = {
+				end: nextSelectionOffset,
+				start: nextSelectionOffset
+			};
+			handleContentChange(nextContent_0);
+		};
+		$[25] = content;
+		$[26] = handleContentChange;
+		$[27] = t12;
+	} else {
+		t12 = $[27];
+	}
+	const replaceContentText = t12;
+	let t13;
+	if ($[28] !== content || $[29] !== options || $[30] !== replaceContentText) {
+		t13 = (event) => {
+			const pastedText = event.clipboardData.getData(RICH_TEXT_CLIPBOARD_DATA_TYPE.plainText);
+			const pastedUrl = normalizeMarkdownUrl(pastedText);
+			const selectionRange_1 = getEditorSelectionRange(event.currentTarget) ?? {
+				end: content.length,
+				start: content.length
+			};
+			const hasSelectedText = selectionRange_1.start !== selectionRange_1.end;
+			event.preventDefault();
+			if (!pastedUrl || !hasSelectedText) {
+				replaceContentText(pastedText, selectionRange_1);
+				return;
+			}
+			pendingSelectionRef.current = selectionRange_1;
+			setLinks((currentLinks_0) => [...currentLinks_0.filter((link) => !rangesOverlap(link, {
+				end: selectionRange_1.end,
+				start: selectionRange_1.start
+			})), {
+				end: selectionRange_1.end,
+				id: crypto.randomUUID(),
+				isSynced: isLinkSynchronized(content.slice(selectionRange_1.start, selectionRange_1.end), pastedUrl),
+				kind: RICH_LINK_KIND.explicit,
+				start: selectionRange_1.start,
+				url: pastedUrl
+			}]);
+			options.onContentChange?.();
+		};
+		$[28] = content;
+		$[29] = options;
+		$[30] = replaceContentText;
+		$[31] = t13;
+	} else {
+		t13 = $[31];
+	}
+	const handlePaste = t13;
+	let t14;
+	if ($[32] !== content || $[33] !== replaceContentText) {
+		t14 = (event_0) => {
+			if (event_0.altKey || event_0.metaKey) {
+				return;
+			}
+			if (event_0.ctrlKey && event_0.key !== RICH_TEXT_EDITOR_KEY.backspace && event_0.key !== RICH_TEXT_EDITOR_KEY.delete) {
+				return;
+			}
+			const selectionRange_2 = getEditorSelectionRange(event_0.currentTarget) ?? {
+				end: content.length,
+				start: content.length
+			};
+			let replacementText_0 = null;
+			let replacementRange = selectionRange_2;
+			if (event_0.key.length === RICH_TEXT_EDITOR_KEY_LENGTH.character) {
+				replacementText_0 = event_0.key;
+			}
+			if (event_0.key === RICH_TEXT_EDITOR_KEY.enter) {
+				replacementText_0 = RICH_TEXT_EDITOR_TEXT.lineBreak;
+			}
+			if (event_0.key === RICH_TEXT_EDITOR_KEY.backspace) {
+				replacementText_0 = EMPTY_TEXT;
+				replacementRange = event_0.ctrlKey ? getWordDeletionRange({
+					direction: RICH_TEXT_EDITOR_WORD_DIRECTION.backward,
+					selectionRange: selectionRange_2,
+					text: content
+				}) : selectionRange_2.start === selectionRange_2.end ? {
+					end: selectionRange_2.end,
+					start: Math.max(selectionRange_2.start - 1, 0)
+				} : selectionRange_2;
+			}
+			if (event_0.key === RICH_TEXT_EDITOR_KEY.delete) {
+				replacementText_0 = EMPTY_TEXT;
+				replacementRange = event_0.ctrlKey ? getWordDeletionRange({
+					direction: RICH_TEXT_EDITOR_WORD_DIRECTION.forward,
+					selectionRange: selectionRange_2,
+					text: content
+				}) : selectionRange_2.start === selectionRange_2.end ? {
+					end: Math.min(selectionRange_2.end + 1, content.length),
+					start: selectionRange_2.start
+				} : selectionRange_2;
+			}
+			if (replacementText_0 === null) {
+				return;
+			}
+			event_0.preventDefault();
+			replaceContentText(replacementText_0, replacementRange);
+		};
+		$[32] = content;
+		$[33] = replaceContentText;
+		$[34] = t14;
+	} else {
+		t14 = $[34];
+	}
+	const handleKeyDown = t14;
+	let t15;
+	if ($[35] !== content.length || $[36] !== replaceContentText) {
+		t15 = (event_1) => {
+			const nativeEvent = event_1.nativeEvent;
+			const selectionRange_3 = getEditorSelectionRange(event_1.currentTarget) ?? {
+				end: content.length,
+				start: content.length
+			};
+			let replacementText_1 = null;
+			let replacementRange_0 = selectionRange_3;
+			if (nativeEvent.inputType === RICH_TEXT_EDITOR_INPUT_TYPE.insertText) {
+				replacementText_1 = nativeEvent.data ?? EMPTY_TEXT;
+			}
+			if (nativeEvent.inputType === RICH_TEXT_EDITOR_INPUT_TYPE.insertParagraph || nativeEvent.inputType === RICH_TEXT_EDITOR_INPUT_TYPE.insertLineBreak) {
+				replacementText_1 = RICH_TEXT_EDITOR_TEXT.lineBreak;
+			}
+			if (nativeEvent.inputType === RICH_TEXT_EDITOR_INPUT_TYPE.deleteContentBackward) {
+				replacementText_1 = EMPTY_TEXT;
+				replacementRange_0 = selectionRange_3.start === selectionRange_3.end ? {
+					end: selectionRange_3.end,
+					start: Math.max(selectionRange_3.start - 1, 0)
+				} : selectionRange_3;
+			}
+			if (nativeEvent.inputType === RICH_TEXT_EDITOR_INPUT_TYPE.deleteContentForward) {
+				replacementText_1 = EMPTY_TEXT;
+				replacementRange_0 = selectionRange_3.start === selectionRange_3.end ? {
+					end: Math.min(selectionRange_3.end + 1, content.length),
+					start: selectionRange_3.start
+				} : selectionRange_3;
+			}
+			if (replacementText_1 === null) {
+				return;
+			}
+			event_1.preventDefault();
+			replaceContentText(replacementText_1, replacementRange_0);
+		};
+		$[35] = content.length;
+		$[36] = replaceContentText;
+		$[37] = t15;
+	} else {
+		t15 = $[37];
+	}
+	const handleBeforeInput = t15;
+	let t16;
+	if ($[38] !== handleContentChange) {
+		t16 = (event_2) => {
+			const selectionRange_4 = getEditorSelectionRange(event_2.currentTarget);
+			if (selectionRange_4) {
+				pendingSelectionRef.current = selectionRange_4;
+			}
+			handleContentChange(event_2.currentTarget.textContent ?? EMPTY_TEXT);
+		};
+		$[38] = handleContentChange;
+		$[39] = t16;
+	} else {
+		t16 = $[39];
+	}
+	const handleInput = t16;
+	let t17;
+	if ($[40] === Symbol.for("react.memo_cache_sentinel")) {
+		t17 = (segment) => {
+			setActiveLink(segment);
+			setLinkTextInput(segment.text);
+			setLinkUrlInput(segment.url);
+			setPopoverMode(RICH_LINK_POPOVER_MODE.actions);
+		};
+		$[40] = t17;
+	} else {
+		t17 = $[40];
+	}
+	const openLinkPopover = t17;
+	let t18;
+	if ($[41] === Symbol.for("react.memo_cache_sentinel")) {
+		t18 = () => {
+			setActiveLink(null);
+			setLinkTextInput(EMPTY_TEXT);
+			setLinkUrlInput(EMPTY_TEXT);
+			setPopoverMode(RICH_LINK_POPOVER_MODE.actions);
+		};
+		$[41] = t18;
+	} else {
+		t18 = $[41];
+	}
+	const closeLinkPopover = t18;
+	let t19;
+	if ($[42] === Symbol.for("react.memo_cache_sentinel")) {
+		t19 = (segment_0) => {
+			const shouldSuppressVisibleUrl = Boolean(normalizeMarkdownUrl(segment_0.text));
+			const suppressedLink = {
+				end: segment_0.end,
+				id: crypto.randomUUID(),
+				kind: RICH_LINK_KIND.suppressed,
+				start: segment_0.start
+			};
+			setLinks((currentLinks_1) => {
+				const linksWithoutRemovedExplicitLink = segment_0.source === RICH_PREVIEW_LINK_SOURCE.explicit && segment_0.id ? currentLinks_1.filter((link_0) => link_0.id !== segment_0.id) : currentLinks_1;
+				return shouldSuppressVisibleUrl || segment_0.source === RICH_PREVIEW_LINK_SOURCE.automatic ? [...linksWithoutRemovedExplicitLink, suppressedLink] : linksWithoutRemovedExplicitLink;
+			});
+			closeLinkPopover();
+		};
+		$[42] = t19;
+	} else {
+		t19 = $[42];
+	}
+	const removeLink = t19;
+	let t20;
+	if ($[43] !== content || $[44] !== linkTextInput || $[45] !== linkUrlInput) {
+		t20 = (segment_1) => {
+			const nextUrl = normalizeMarkdownUrl(linkUrlInput);
+			const nextText = linkTextInput;
+			if (!nextUrl || !nextText.trim()) {
+				return;
+			}
+			const nextContent_1 = content.slice(0, segment_1.start) + nextText + content.slice(segment_1.end);
+			const nextEnd = segment_1.start + nextText.length;
+			const nextLinkRange = {
+				end: nextEnd,
+				start: segment_1.start
+			};
+			pendingSelectionRef.current = {
+				end: nextEnd,
+				start: nextEnd
+			};
+			setContent(nextContent_1);
+			setLinks((currentLinks_2) => {
+				const adjustedLinks = getLinksAfterTextChange({
+					links: currentLinks_2,
+					nextText: nextContent_1,
+					previousText: content
+				});
+				return [...adjustedLinks.filter((link_1) => {
+					if (segment_1.id && link_1.id === segment_1.id) {
+						return false;
+					}
+					return !rangesOverlap(link_1, nextLinkRange);
+				}), {
+					end: nextEnd,
+					id: segment_1.id ?? crypto.randomUUID(),
+					isSynced: isLinkSynchronized(nextText, nextUrl),
+					kind: RICH_LINK_KIND.explicit,
+					start: segment_1.start,
+					url: nextUrl
+				}];
+			});
+			closeLinkPopover();
+		};
+		$[43] = content;
+		$[44] = linkTextInput;
+		$[45] = linkUrlInput;
+		$[46] = t20;
+	} else {
+		t20 = $[46];
+	}
+	const saveLinkEdit = t20;
+	let t21;
+	if ($[47] !== content || $[48] !== links) {
+		t21 = () => serializeEditorContent(content, links);
+		$[47] = content;
+		$[48] = links;
+		$[49] = t21;
+	} else {
+		t21 = $[49];
+	}
+	const serialize = t21;
+	let t22;
+	if ($[50] === Symbol.for("react.memo_cache_sentinel")) {
+		t22 = (markdown) => {
+			const nextState = deserializeMarkdownForEditor(markdown ?? EMPTY_TEXT);
+			pendingSelectionRef.current = null;
+			setContent(nextState.content);
+			setLinks(nextState.links);
+			closeLinkPopover();
+		};
+		$[50] = t22;
+	} else {
+		t22 = $[50];
+	}
+	const reset = t22;
+	let t23;
+	if ($[51] !== content || $[52] !== links) {
+		t23 = () => ({
+			content,
+			links: links.map(_temp)
+		});
+		$[51] = content;
+		$[52] = links;
+		$[53] = t23;
+	} else {
+		t23 = $[53];
+	}
+	const getDisplayState = t23;
+	let t24;
+	if ($[54] === Symbol.for("react.memo_cache_sentinel")) {
+		t24 = (state) => {
+			pendingSelectionRef.current = null;
+			setContent(state.content);
+			setLinks(state.links.map(_temp2));
+			closeLinkPopover();
+		};
+		$[54] = t24;
+	} else {
+		t24 = $[54];
+	}
+	const loadFromDisplay = t24;
+	let t25;
+	if ($[55] !== activeLink || $[56] !== content || $[57] !== getDisplayState || $[58] !== handleBeforeInput || $[59] !== handleInput || $[60] !== handleKeyDown || $[61] !== handlePaste || $[62] !== hasContent || $[63] !== hasInvalidLinkUrl || $[64] !== isLinkEditValid || $[65] !== linkTextInput || $[66] !== linkUrlInput || $[67] !== popoverMode || $[68] !== saveLinkEdit || $[69] !== segments || $[70] !== serialize) {
+		t25 = {
+			activeLink,
+			closeLinkPopover,
+			content,
+			getDisplayState,
+			handleBeforeInput,
+			handleInput,
+			handleKeyDown,
+			handlePaste,
+			hasContent,
+			hasInvalidLinkUrl,
+			isLinkEditValid,
+			linkTextInput,
+			linkUrlInput,
+			loadFromDisplay,
+			openLinkPopover,
+			popoverMode,
+			removeLink,
+			reset,
+			saveLinkEdit,
+			segments,
+			serialize,
+			setEditorElement,
+			setLinkTextInput,
+			setLinkUrlInput,
+			setPopoverMode
+		};
+		$[55] = activeLink;
+		$[56] = content;
+		$[57] = getDisplayState;
+		$[58] = handleBeforeInput;
+		$[59] = handleInput;
+		$[60] = handleKeyDown;
+		$[61] = handlePaste;
+		$[62] = hasContent;
+		$[63] = hasInvalidLinkUrl;
+		$[64] = isLinkEditValid;
+		$[65] = linkTextInput;
+		$[66] = linkUrlInput;
+		$[67] = popoverMode;
+		$[68] = saveLinkEdit;
+		$[69] = segments;
+		$[70] = serialize;
+		$[71] = t25;
+	} else {
+		t25 = $[71];
+	}
+	return t25;
+}
+function _temp2(link_3) {
+	return { ...link_3 };
+}
+function _temp(link_2) {
+	return { ...link_2 };
+}

package/dist/hooks/use-sidebar-persistence.d.ts

@@ -0,0 +1,6 @@
+/** Resolves opt-in persistence after hydration, without changing controlled state. */
+export declare function useSidebarPersistence(storageKey?: string): boolean | null;
+/** Stores an optional preference while retaining usable navigation in private mode. */
+export declare function saveSidebarPreference(storageKey: string | undefined, open: boolean): void;
+/** Writes the cookie that server entrypoints read to render the sidebar in its last state. */
+export declare function saveSidebarCookie(open: boolean, cookieName?: string, maxAgeSeconds?: number): void;

package/dist/hooks/use-sidebar-persistence.js

@@ -0,0 +1,52 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+/** Keeps optional browser persistence separate from the sidebar rendering contract. */
+import { useSyncExternalStore } from "react";
+import { SIDEBAR_COOKIE_COLLAPSED_VALUE, SIDEBAR_COOKIE_MAX_AGE, SIDEBAR_COOKIE_NAME, SIDEBAR_COOKIE_OPEN_VALUE } from "../constants/sidebar.js";
+/** Reads a preference without making unavailable browser storage a render failure. */
+function readSidebarPreference(storageKey) {
+	if (!storageKey || typeof window === "undefined") return null;
+	try {
+		const value = window.localStorage.getItem(storageKey);
+		if (value === SIDEBAR_COOKIE_OPEN_VALUE) return true;
+		if (value === SIDEBAR_COOKIE_COLLAPSED_VALUE) return false;
+	} catch {}
+	return null;
+}
+/** Subscribes to browser storage updates and releases the listener on unmount. */
+function subscribeToStorage(onChange) {
+	window.addEventListener("storage", onChange);
+	return () => window.removeEventListener("storage", onChange);
+}
+/** Keeps the first hydrated render identical to the server-provided preference. */
+function getServerPreference() {
+	return null;
+}
+/** Resolves opt-in persistence after hydration, without changing controlled state. */
+export function useSidebarPersistence(storageKey) {
+	const $ = _c(2);
+	let t0;
+	if ($[0] !== storageKey) {
+		t0 = () => readSidebarPreference(storageKey);
+		$[0] = storageKey;
+		$[1] = t0;
+	} else {
+		t0 = $[1];
+	}
+	const getSnapshot = t0;
+	return useSyncExternalStore(subscribeToStorage, getSnapshot, getServerPreference);
+}
+/** Stores an optional preference while retaining usable navigation in private mode. */
+export function saveSidebarPreference(storageKey, open) {
+	if (!storageKey) return;
+	try {
+		window.localStorage.setItem(storageKey, open ? SIDEBAR_COOKIE_OPEN_VALUE : SIDEBAR_COOKIE_COLLAPSED_VALUE);
+	} catch {}
+}
+/** Writes the cookie that server entrypoints read to render the sidebar in its last state. */
+export function saveSidebarCookie(open, cookieName = SIDEBAR_COOKIE_NAME, maxAgeSeconds = SIDEBAR_COOKIE_MAX_AGE) {
+	const value = open ? SIDEBAR_COOKIE_OPEN_VALUE : SIDEBAR_COOKIE_COLLAPSED_VALUE;
+	try {
+		document.cookie = `${cookieName}=${value}; path=/; max-age=${maxAgeSeconds}; SameSite=Lax`;
+	} catch {}
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Arc's `useToday`: the viewer's local date at midnight. It is `undefined` while rendering on the server and during
+ * hydration, so markup never depends on the server clock, and it moves to the next day when the viewer's midnight
+ * passes. The same `Date` instance is returned until the day changes.
+ * @returns Today at 00:00 in the viewer's time zone, or `undefined` before hydration.
+ */
+export declare function useToday(): Date | undefined;

package/dist/hooks/use-today.js

@@ -0,0 +1,50 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+/** The viewer's local date, kept out of server and hydration renders and refreshed at midnight. */
+import { useEffect, useState } from "react";
+import { useIsHydrated } from "./use-is-hydrated.js";
+/**
+* Midnight that starts the viewer's current local day.
+* @returns Today at 00:00 in the viewer's time zone.
+*/
+function startOfLocalToday() {
+	const now = new Date();
+	return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+}
+/**
+* Milliseconds until the next local midnight, measured from now.
+* @param today - Start of the current local day.
+* @returns The delay before the day changes.
+*/
+function getDelayUntilNextDay(today) {
+	const nextDay = new Date(today.getFullYear(), today.getMonth(), today.getDate() + 1);
+	return Math.max(0, nextDay.getTime() - Date.now());
+}
+/**
+* Arc's `useToday`: the viewer's local date at midnight. It is `undefined` while rendering on the server and during
+* hydration, so markup never depends on the server clock, and it moves to the next day when the viewer's midnight
+* passes. The same `Date` instance is returned until the day changes.
+* @returns Today at 00:00 in the viewer's time zone, or `undefined` before hydration.
+*/
+export function useToday() {
+	const $ = _c(3);
+	const isHydrated = useIsHydrated();
+	const [today, setToday] = useState(startOfLocalToday);
+	let t0;
+	let t1;
+	if ($[0] !== today) {
+		t0 = () => {
+			const timeout = window.setTimeout(() => setToday(startOfLocalToday()), getDelayUntilNextDay(today));
+			return () => window.clearTimeout(timeout);
+		};
+		t1 = [today];
+		$[0] = today;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useEffect(t0, t1);
+	return isHydrated ? today : undefined;
+}

package/dist/hooks/use-viewer-time-zone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * IANA time zone of the browser (for example "Europe/Madrid"). Returns null on
+ * the server and during hydration so zone-dependent copy never causes a
+ * markup mismatch; it settles right after hydration without an effect.
+ */
+export declare function useViewerTimeZone(): string | null;

package/dist/hooks/use-viewer-time-zone.js

@@ -0,0 +1,20 @@
+"use client";
+/** Reads the viewer IANA time zone once hydrated, so zone-dependent copy never mismatches. */
+import { useSyncExternalStore } from "react";
+function subscribeToNothing() {
+	return () => undefined;
+}
+function getViewerTimeZoneSnapshot() {
+	return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function getServerViewerTimeZoneSnapshot() {
+	return null;
+}
+/**
+* IANA time zone of the browser (for example "Europe/Madrid"). Returns null on
+* the server and during hydration so zone-dependent copy never causes a
+* markup mismatch; it settles right after hydration without an effect.
+*/
+export function useViewerTimeZone() {
+	return useSyncExternalStore(subscribeToNothing, getViewerTimeZoneSnapshot, getServerViewerTimeZoneSnapshot);
+}

package/dist/hooks.d.ts

@@ -0,0 +1,11 @@
+/**
+ * General-purpose React hooks, published at `@astra-kit/ui/hooks` so the component barrel stays focused
+ * on UI. `useIsMobile` is also exported from the package root for existing consumers.
+ */
+export { useIsMobile } from "./hooks/use-mobile.js";
+export { useIsHydrated } from "./hooks/use-is-hydrated.js";
+export { useToday } from "./hooks/use-today.js";
+export { usePrefersReducedMotion } from "./hooks/use-prefers-reduced-motion.js";
+export { useViewerTimeZone } from "./hooks/use-viewer-time-zone.js";
+export { useHorizontalSwipe, type HorizontalSwipeHandlers } from "./hooks/use-horizontal-swipe.js";
+export { HORIZONTAL_SWIPE_DIRECTION, resolveHorizontalSwipe, type HorizontalSwipeDirection, type HorizontalSwipeGesture, } from "./lib/horizontal-swipe.js";

package/dist/hooks.js

@@ -0,0 +1,11 @@
+/**
+* General-purpose React hooks, published at `@astra-kit/ui/hooks` so the component barrel stays focused
+* on UI. `useIsMobile` is also exported from the package root for existing consumers.
+*/
+export { useIsMobile } from "./hooks/use-mobile.js";
+export { useIsHydrated } from "./hooks/use-is-hydrated.js";
+export { useToday } from "./hooks/use-today.js";
+export { usePrefersReducedMotion } from "./hooks/use-prefers-reduced-motion.js";
+export { useViewerTimeZone } from "./hooks/use-viewer-time-zone.js";
+export { useHorizontalSwipe } from "./hooks/use-horizontal-swipe.js";
+export { HORIZONTAL_SWIPE_DIRECTION, resolveHorizontalSwipe } from "./lib/horizontal-swipe.js";