beez-ui 0.7.0 → 0.8.0

package/dist/hooks/use-month-transition-direction.js

@@ -0,0 +1,110 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+/** Tracks which way the visible month moved, to orient month entrance animations. */
+import { useEffect, useState } from "react";
+export const MONTH_TRANSITION_DIRECTION = {
+	next: "next",
+	none: "none",
+	previous: "previous"
+};
+/**
+* How long, in milliseconds, the last shown month still orients the next calendar mount. Month
+* links may remount the calendar behind a route loading state, so the memory must outlive that
+* gap but not a later, unrelated visit.
+*/
+const SHOWN_MONTH_MEMORY_MS = 5e3;
+/**
+* Last month shown by a calendar in this tab. It is written only from effects, which never run on
+* the server, so server renders and the hydration render always read `null` and match.
+*/
+let lastShownMonth = null;
+/**
+* Records the month a calendar is showing.
+* @param scopeKey - Calendar identity, such as a group or resource id.
+* @param month - Visible `YYYY-MM` month.
+*/
+function rememberShownMonth(scopeKey, month) {
+	lastShownMonth = {
+		month,
+		shownAt: Date.now(),
+		scopeKey
+	};
+}
+/**
+* Reads the month recently shown by the same calendar, if still within the memory window.
+* @param scopeKey - Calendar identity.
+* @returns The month, or null.
+*/
+function readRecentlyShownMonth(scopeKey) {
+	if (lastShownMonth === null || lastShownMonth.scopeKey !== scopeKey || Date.now() - lastShownMonth.shownAt > SHOWN_MONTH_MEMORY_MS) {
+		return null;
+	}
+	return lastShownMonth.month;
+}
+/**
+* Compares two `YYYY-MM` keys, which sort chronologically as plain strings.
+* @param fromMonth - Month shown before, or null when there is none.
+* @param toMonth - Month shown now.
+* @returns `next` or `previous` when the month changed, `none` otherwise.
+*/
+export function resolveMonthTransitionDirection(fromMonth, toMonth) {
+	if (fromMonth === null || fromMonth === toMonth) return MONTH_TRANSITION_DIRECTION.none;
+	return toMonth > fromMonth ? MONTH_TRANSITION_DIRECTION.next : MONTH_TRANSITION_DIRECTION.previous;
+}
+/**
+* Direction of the latest month change of a calendar: a new `month` on the same instance, or a
+* fresh mount right after another month of the same calendar was on screen.
+* @param scopeKey - Calendar identity, so different calendars do not orient each other.
+* @param month - Visible `YYYY-MM` month.
+* @returns Direction to animate the month entrance with.
+*/
+export function useMonthTransitionDirection(scopeKey, month) {
+	const $ = _c(11);
+	let t0;
+	if ($[0] !== month || $[1] !== scopeKey) {
+		t0 = () => ({
+			direction: resolveMonthTransitionDirection(readRecentlyShownMonth(scopeKey), month),
+			month
+		});
+		$[0] = month;
+		$[1] = scopeKey;
+		$[2] = t0;
+	} else {
+		t0 = $[2];
+	}
+	const [transition, setTransition] = useState(t0);
+	if (transition.month !== month) {
+		setTransition({
+			direction: resolveMonthTransitionDirection(transition.month, month),
+			month
+		});
+	}
+	let t1;
+	let t2;
+	if ($[3] !== month || $[4] !== scopeKey) {
+		t1 = () => {
+			rememberShownMonth(scopeKey, month);
+			return () => rememberShownMonth(scopeKey, month);
+		};
+		t2 = [month, scopeKey];
+		$[3] = month;
+		$[4] = scopeKey;
+		$[5] = t1;
+		$[6] = t2;
+	} else {
+		t1 = $[5];
+		t2 = $[6];
+	}
+	useEffect(t1, t2);
+	let t3;
+	if ($[7] !== month || $[8] !== transition.direction || $[9] !== transition.month) {
+		t3 = transition.month === month ? transition.direction : resolveMonthTransitionDirection(transition.month, month);
+		$[7] = month;
+		$[8] = transition.direction;
+		$[9] = transition.month;
+		$[10] = t3;
+	} else {
+		t3 = $[10];
+	}
+	return t3;
+}

package/dist/hooks/use-rich-link-editor.d.ts

@@ -0,0 +1,55 @@
+/** Owns the state of `RichLinkEditor`: content, tracked links, popover and selection. */
+import { type ClipboardEvent, type FormEvent, type KeyboardEvent } from "react";
+import { RICH_LINK_POPOVER_MODE } from "../lib/rich-text/link-markdown-constants.js";
+import type { ActiveRichPreviewLink, RichLink, RichPreviewSegment } from "../lib/rich-text/link-markdown-types.js";
+type RichLinkPopoverMode = (typeof RICH_LINK_POPOVER_MODE)[keyof typeof RICH_LINK_POPOVER_MODE];
+/** Plain-text content plus tracked links, used to snapshot/restore the editor. */
+export type RichLinkEditorDisplayState = {
+    content: string;
+    links: RichLink[];
+};
+type UseRichLinkEditorOptions = {
+    /** Persisted markdown loaded as the initial editor value. */
+    initialMarkdown?: string;
+    /** Called whenever the author changes the content (e.g. to clear errors). */
+    onContentChange?: () => void;
+};
+/** Imperative + reactive API exposed by `useRichLinkEditor` to the editor UI. */
+export type RichLinkEditorController = {
+    setEditorElement: (node: HTMLDivElement | null) => void;
+    segments: RichPreviewSegment[];
+    hasContent: boolean;
+    content: string;
+    activeLink: ActiveRichPreviewLink | null;
+    linkTextInput: string;
+    linkUrlInput: string;
+    popoverMode: RichLinkPopoverMode;
+    /** Whether the popover draft has visible text and an http(s) URL, so it can be saved. */
+    isLinkEditValid: boolean;
+    /** Whether the author typed a URL that cannot become a safe http(s) link. */
+    hasInvalidLinkUrl: boolean;
+    setLinkTextInput: (value: string) => void;
+    setLinkUrlInput: (value: string) => void;
+    setPopoverMode: (mode: RichLinkPopoverMode) => void;
+    handleBeforeInput: (event: FormEvent<HTMLDivElement>) => void;
+    handleInput: (event: FormEvent<HTMLDivElement>) => void;
+    handleKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
+    handlePaste: (event: ClipboardEvent<HTMLDivElement>) => void;
+    openLinkPopover: (segment: ActiveRichPreviewLink) => void;
+    closeLinkPopover: () => void;
+    removeLink: (segment: ActiveRichPreviewLink) => void;
+    saveLinkEdit: (segment: ActiveRichPreviewLink) => void;
+    serialize: () => string;
+    reset: (markdown?: string) => void;
+    getDisplayState: () => RichLinkEditorDisplayState;
+    loadFromDisplay: (state: RichLinkEditorDisplayState) => void;
+};
+/**
+ * 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 declare function useRichLinkEditor(options?: UseRichLinkEditorOptions): RichLinkEditorController;
+export {};

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-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);
+}