@questpie/admin 3.2.3 → 3.2.5

package/dist/client/contexts/focus-context.mjs

@@ -1,6 +1,5 @@
 "use client";
 
-import { c } from "react/compiler-runtime";
 import * as React from "react";
 import { jsx } from "react/jsx-runtime";
 
@@ -13,133 +12,83 @@ import { jsx } from "react/jsx-runtime";
 * Used for preview click-to-focus functionality.
 */
 const FocusContext = React.createContext(null);
-function FocusProvider(t0) {
-	const $ = c(27);
-	const { children, onFocusChange } = t0;
-	let t1;
-	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-		t1 = { type: "idle" };
-		$[0] = t1;
-	} else t1 = $[0];
-	const [state, setState] = React.useState(t1);
-	let t2;
-	if ($[1] !== onFocusChange) {
-		t2 = (fieldPath) => {
-			const newState = {
-				type: "field",
-				fieldPath
-			};
-			setState(newState);
-			onFocusChange?.(newState);
-		};
-		$[1] = onFocusChange;
-		$[2] = t2;
-	} else t2 = $[2];
-	const focusField = t2;
-	let t3;
-	if ($[3] !== onFocusChange) {
-		t3 = (blockId, fieldPath_0) => {
-			const newState_0 = {
-				type: "block",
-				blockId,
-				fieldPath: fieldPath_0
-			};
-			setState(newState_0);
-			onFocusChange?.(newState_0);
-		};
-		$[3] = onFocusChange;
-		$[4] = t3;
-	} else t3 = $[4];
-	const focusBlock = t3;
-	let t4;
-	if ($[5] !== onFocusChange) {
-		t4 = (fieldPath_1, targetCollection) => {
-			const newState_1 = {
-				type: "relation",
-				fieldPath: fieldPath_1,
-				targetCollection
-			};
-			setState(newState_1);
-			onFocusChange?.(newState_1);
-		};
-		$[5] = onFocusChange;
-		$[6] = t4;
-	} else t4 = $[6];
-	const focusRelation = t4;
-	let t5;
-	if ($[7] !== onFocusChange) {
-		t5 = (position, referenceBlockId) => {
-			const newState_2 = {
-				type: "block-insert",
-				position,
-				referenceBlockId
-			};
-			setState(newState_2);
-			onFocusChange?.(newState_2);
-		};
-		$[7] = onFocusChange;
-		$[8] = t5;
-	} else t5 = $[8];
-	const requestBlockInsert = t5;
-	let t6;
-	if ($[9] !== onFocusChange) {
-		t6 = () => {
-			const newState_3 = { type: "idle" };
-			setState(newState_3);
-			onFocusChange?.(newState_3);
-		};
-		$[9] = onFocusChange;
-		$[10] = t6;
-	} else t6 = $[10];
-	const clearFocus = t6;
+function areBlockInsertPositionsEqual(left, right) {
+	return left.parentId === right.parentId && left.index === right.index;
+}
+function areFocusStatesEqual(left, right) {
+	if (left.type !== right.type) return false;
+	switch (left.type) {
+		case "idle": return true;
+		case "field": return right.type === "field" && left.fieldPath === right.fieldPath;
+		case "block": return right.type === "block" && left.blockId === right.blockId && left.fieldPath === right.fieldPath;
+		case "block-insert": return right.type === "block-insert" && areBlockInsertPositionsEqual(left.position, right.position) && left.referenceBlockId === right.referenceBlockId;
+		case "relation": return right.type === "relation" && left.fieldPath === right.fieldPath && left.targetCollection === right.targetCollection;
+	}
+}
+function FocusProvider({ children, onFocusChange }) {
+	const [state, setState] = React.useState({ type: "idle" });
+	const stateRef = React.useRef(state);
+	const setFocusState = React.useCallback((nextState) => {
+		if (areFocusStatesEqual(stateRef.current, nextState)) return;
+		stateRef.current = nextState;
+		setState(nextState);
+		onFocusChange?.(nextState);
+	}, [onFocusChange]);
+	const focusField = React.useCallback((fieldPath) => {
+		setFocusState({
+			type: "field",
+			fieldPath
+		});
+	}, [setFocusState]);
+	const focusBlock = React.useCallback((blockId, fieldPath) => {
+		setFocusState({
+			type: "block",
+			blockId,
+			fieldPath
+		});
+	}, [setFocusState]);
+	const focusRelation = React.useCallback((fieldPath, targetCollection) => {
+		setFocusState({
+			type: "relation",
+			fieldPath,
+			targetCollection
+		});
+	}, [setFocusState]);
+	const requestBlockInsert = React.useCallback((position, referenceBlockId) => {
+		setFocusState({
+			type: "block-insert",
+			position,
+			referenceBlockId
+		});
+	}, [setFocusState]);
+	const clearFocus = React.useCallback(() => {
+		setFocusState({ type: "idle" });
+	}, [setFocusState]);
 	const focusedFieldPath = state.type === "field" ? state.fieldPath : void 0;
 	const focusedBlockId = state.type === "block" ? state.blockId : void 0;
-	let t7;
-	if ($[11] !== focusedFieldPath) {
-		t7 = (path) => focusedFieldPath === path;
-		$[11] = focusedFieldPath;
-		$[12] = t7;
-	} else t7 = $[12];
-	let t8;
-	if ($[13] !== focusedBlockId) {
-		t8 = (id) => focusedBlockId === id;
-		$[13] = focusedBlockId;
-		$[14] = t8;
-	} else t8 = $[14];
-	let t9;
-	if ($[15] !== clearFocus || $[16] !== focusBlock || $[17] !== focusField || $[18] !== focusRelation || $[19] !== requestBlockInsert || $[20] !== state || $[21] !== t7 || $[22] !== t8) {
-		t9 = {
-			state,
-			focusField,
-			focusBlock,
-			requestBlockInsert,
-			focusRelation,
-			clearFocus,
-			isFieldFocused: t7,
-			isBlockFocused: t8
-		};
-		$[15] = clearFocus;
-		$[16] = focusBlock;
-		$[17] = focusField;
-		$[18] = focusRelation;
-		$[19] = requestBlockInsert;
-		$[20] = state;
-		$[21] = t7;
-		$[22] = t8;
-		$[23] = t9;
-	} else t9 = $[23];
-	const value = t9;
-	let t10;
-	if ($[24] !== children || $[25] !== value) {
-		t10 = /* @__PURE__ */ jsx(FocusContext.Provider, {
-			value,
-			children
-		});
-		$[24] = children;
-		$[25] = value;
-		$[26] = t10;
-	} else t10 = $[26];
-	return t10;
+	const value = React.useMemo(() => ({
+		state,
+		focusField,
+		focusBlock,
+		requestBlockInsert,
+		focusRelation,
+		clearFocus,
+		isFieldFocused: (path) => focusedFieldPath === path,
+		isBlockFocused: (id) => focusedBlockId === id
+	}), [
+		state,
+		focusField,
+		focusBlock,
+		requestBlockInsert,
+		focusRelation,
+		clearFocus,
+		focusedFieldPath,
+		focusedBlockId
+	]);
+	return /* @__PURE__ */ jsx(FocusContext.Provider, {
+		value,
+		children
+	});
 }
 /**
 * Use the focus context
@@ -159,33 +108,17 @@ function useFocusOptional() {
 * Hook for checking if a specific field is focused
 */
 function useIsFieldFocused(fieldPath) {
-	const $ = c(3);
 	const context = React.useContext(FocusContext);
 	if (!context) return false;
-	let t0;
-	if ($[0] !== context || $[1] !== fieldPath) {
-		t0 = context.isFieldFocused(fieldPath);
-		$[0] = context;
-		$[1] = fieldPath;
-		$[2] = t0;
-	} else t0 = $[2];
-	return t0;
+	return context.isFieldFocused(fieldPath);
 }
 /**
 * Hook for checking if a specific block is focused
 */
 function useIsBlockFocused(blockId) {
-	const $ = c(3);
 	const context = React.useContext(FocusContext);
 	if (!context) return false;
-	let t0;
-	if ($[0] !== blockId || $[1] !== context) {
-		t0 = context.isBlockFocused(blockId);
-		$[0] = blockId;
-		$[1] = context;
-		$[2] = t0;
-	} else t0 = $[2];
-	return t0;
+	return context.isBlockFocused(blockId);
 }
 /**
 * Parse a preview field path into focus state with optional context hints
@@ -273,26 +206,30 @@ function scrollFieldIntoView(fieldPath, options = {}) {
 	const wrapper = findFieldWrapper(fieldPath, options);
 	if (!wrapper) return false;
 	const focusable = wrapper.querySelector("input:not([type=\"hidden\"]), textarea, button, select, [tabindex]:not([tabindex=\"-1\"]), [contenteditable=\"true\"]");
+	const { behavior = "auto", block = "nearest", focus = true } = options;
 	(focusable ?? wrapper).scrollIntoView({
-		behavior: "smooth",
-		block: "center"
+		behavior,
+		block
 	});
 	wrapper.classList.add("field-focus-pulse");
 	wrapper.addEventListener("animationend", () => wrapper.classList.remove("field-focus-pulse"), { once: true });
-	if (focusable) requestAnimationFrame(() => {
+	if (focus && focusable) requestAnimationFrame(() => {
 		window.focus();
-		focusable.focus();
+		focusable.focus({ preventScroll: true });
 	});
 	return true;
 }
 function scheduleScrollFieldIntoView(fieldPath, options = {}) {
 	if (typeof window === "undefined") return;
-	const { attempts = 12, delayMs = 80, fallbackToBlock = false } = options;
+	const { attempts = 12, delayMs = 80, fallbackToBlock = false, ...scrollOptions } = options;
 	let attempt = 0;
 	const tryScroll = () => {
 		attempt += 1;
 		const isLastAttempt = attempt >= attempts;
-		if (scrollFieldIntoView(fieldPath, { fallbackToBlock: fallbackToBlock && isLastAttempt }) || isLastAttempt) return;
+		if (scrollFieldIntoView(fieldPath, {
+			...scrollOptions,
+			fallbackToBlock: fallbackToBlock && isLastAttempt
+		}) || isLastAttempt) return;
 		window.setTimeout(tryScroll, delayMs);
 	};
 	tryScroll();