@keboola/design 11.0.0 → 11.0.1

package/dist/useColorSchemeState-CYqcUfSH.js

@@ -0,0 +1,61 @@
+import { DEFAULT_BRAND_ID, DEFAULT_COLOR_SCHEME } from "./context-KxxeMHbR.js";
+import { useCallback, useEffect, useState } from "react";
+//#region src/components/ThemeProvider/useBrandState.ts
+const BRAND_ATTRIBUTE = "data-brand";
+const useBrandState = ({ defaultBrandId: defaultBrand = DEFAULT_BRAND_ID, brandId: controlledBrand, onBrandIdChange: onBrandChange } = {}) => {
+	const [uncontrolledBrand, setUncontrolledBrand] = useState(defaultBrand);
+	const isControlled = controlledBrand !== void 0;
+	const brandId = isControlled ? controlledBrand : uncontrolledBrand;
+	const setBrand = useCallback((next) => {
+		if (!isControlled) setUncontrolledBrand(next);
+		onBrandChange?.(next);
+	}, [isControlled, onBrandChange]);
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		document.documentElement.setAttribute(BRAND_ATTRIBUTE, brandId);
+	}, [brandId]);
+	return {
+		brandId,
+		setBrand
+	};
+};
+//#endregion
+//#region src/components/ThemeProvider/useColorSchemeState.ts
+const DARK_QUERY = "(prefers-color-scheme: dark)";
+const THEME_ATTRIBUTE = "data-theme";
+const getSystemColorScheme = () => {
+	if (typeof window === "undefined" || typeof window.matchMedia !== "function") return "light";
+	return window.matchMedia(DARK_QUERY).matches ? "dark" : "light";
+};
+const useColorSchemeState = ({ defaultScheme = DEFAULT_COLOR_SCHEME, scheme: propScheme, onSchemeChange } = {}) => {
+	const [uncontrolledScheme, setUncontrolledScheme] = useState(defaultScheme);
+	const [systemScheme, setSystemScheme] = useState(getSystemColorScheme);
+	const isControlled = propScheme !== void 0;
+	const scheme = isControlled ? propScheme : uncontrolledScheme;
+	const setScheme = useCallback((next) => {
+		if (!isControlled) setUncontrolledScheme(next);
+		onSchemeChange?.(next);
+	}, [isControlled, onSchemeChange]);
+	useEffect(() => {
+		if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+		const mq = window.matchMedia(DARK_QUERY);
+		const onChange = () => setSystemScheme(mq.matches ? "dark" : "light");
+		onChange();
+		mq.addEventListener("change", onChange);
+		return () => mq.removeEventListener("change", onChange);
+	}, []);
+	const resolvedScheme = scheme === "system" ? systemScheme : scheme;
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		document.documentElement.setAttribute(THEME_ATTRIBUTE, resolvedScheme);
+	}, [resolvedScheme]);
+	return {
+		scheme,
+		resolvedScheme,
+		setScheme
+	};
+};
+//#endregion
+export { BRAND_ATTRIBUTE, THEME_ATTRIBUTE, useBrandState, useColorSchemeState };
+
+//# sourceMappingURL=useColorSchemeState-CYqcUfSH.js.map

package/dist/useColorSchemeState-CYqcUfSH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useColorSchemeState-CYqcUfSH.js","names":[],"sources":["../src/components/ThemeProvider/useBrandState.ts","../src/components/ThemeProvider/useColorSchemeState.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\n\nimport { DEFAULT_BRAND_ID } from './defaults';\nimport type { BrandId } from './types';\n\nexport const BRAND_ATTRIBUTE = 'data-brand';\n\nexport type UseBrandOptions = {\n  /** Initial active brand id for uncontrolled use. Defaults to the design-system sentinel (`DEFAULT_BRAND_ID`) — no brand tokens injected, so the stylesheet defaults apply. */\n  defaultBrandId?: BrandId;\n  /** Controlled active brand id. When set, the parent owns the value and `setBrand` only notifies via `onBrandIdChange` (it does not mutate internal state). */\n  brandId?: BrandId;\n  /** Called with the next id whenever `setBrand` runs — required to persist the choice in controlled mode. */\n  onBrandIdChange?: (brandId: BrandId) => void;\n};\n\nexport const useBrandState = ({\n  defaultBrandId: defaultBrand = DEFAULT_BRAND_ID,\n  brandId: controlledBrand,\n  onBrandIdChange: onBrandChange,\n}: UseBrandOptions = {}) => {\n  const [uncontrolledBrand, setUncontrolledBrand] = useState(defaultBrand);\n\n  const isControlled = controlledBrand !== undefined;\n  const brandId = isControlled ? controlledBrand : uncontrolledBrand;\n\n  const setBrand = useCallback(\n    (next: BrandId) => {\n      if (!isControlled) setUncontrolledBrand(next);\n      onBrandChange?.(next);\n    },\n    [isControlled, onBrandChange],\n  );\n\n  useEffect(() => {\n    if (typeof document === 'undefined') return;\n    document.documentElement.setAttribute(BRAND_ATTRIBUTE, brandId);\n  }, [brandId]);\n\n  return { brandId, setBrand };\n};\n","import { useCallback, useEffect, useState } from 'react';\n\nimport { DEFAULT_COLOR_SCHEME } from './defaults';\nimport type { ColorScheme, ResolvedColorScheme } from './types';\n\nconst DARK_QUERY = '(prefers-color-scheme: dark)';\nexport const THEME_ATTRIBUTE = 'data-theme';\n\nconst getSystemColorScheme = (): ResolvedColorScheme => {\n  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return 'light';\n  return window.matchMedia(DARK_QUERY).matches ? 'dark' : 'light';\n};\n\nexport type UseColorSchemeOptions = {\n  /** Initial colour scheme for uncontrolled use. Defaults to `light` (`DEFAULT_COLOR_SCHEME`). */\n  defaultScheme?: ColorScheme;\n  /** Controlled colour scheme (`light` / `dark` / `system`). When set, the parent owns the value and `setScheme` only notifies via `onSchemeChange`. `system` follows `prefers-color-scheme` and resolves reactively. */\n  scheme?: ColorScheme;\n  /** Called with the next scheme whenever `setScheme` runs — required to persist the choice in controlled mode. */\n  onSchemeChange?: (theme: ColorScheme) => void;\n};\n\nexport const useColorSchemeState = ({\n  defaultScheme = DEFAULT_COLOR_SCHEME,\n  scheme: propScheme,\n  onSchemeChange,\n}: UseColorSchemeOptions = {}) => {\n  const [uncontrolledScheme, setUncontrolledScheme] = useState(defaultScheme);\n  const [systemScheme, setSystemScheme] = useState<ResolvedColorScheme>(getSystemColorScheme);\n\n  const isControlled = propScheme !== undefined;\n  const scheme = isControlled ? propScheme : uncontrolledScheme;\n\n  const setScheme = useCallback(\n    (next: ColorScheme) => {\n      if (!isControlled) setUncontrolledScheme(next);\n      onSchemeChange?.(next);\n    },\n    [isControlled, onSchemeChange],\n  );\n\n  // Track the OS preference so `system` stays live as the user flips it.\n  useEffect(() => {\n    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return;\n    const mq = window.matchMedia(DARK_QUERY);\n    const onChange = () => setSystemScheme(mq.matches ? 'dark' : 'light');\n    onChange();\n    mq.addEventListener('change', onChange);\n    return () => mq.removeEventListener('change', onChange);\n  }, []);\n\n  const resolvedScheme: ResolvedColorScheme = scheme === 'system' ? systemScheme : scheme;\n\n  useEffect(() => {\n    if (typeof document === 'undefined') return;\n    document.documentElement.setAttribute(THEME_ATTRIBUTE, resolvedScheme);\n  }, [resolvedScheme]);\n\n  return { scheme, resolvedScheme, setScheme };\n};\n"],"mappings":";;;AAKA,MAAa,kBAAkB;AAW/B,MAAa,iBAAiB,EAC5B,gBAAgB,eAAe,kBAC/B,SAAS,iBACT,iBAAiB,kBACE,CAAC,MAAM;CAC1B,MAAM,CAAC,mBAAmB,wBAAwB,SAAS,YAAY;CAEvE,MAAM,eAAe,oBAAoB,KAAA;CACzC,MAAM,UAAU,eAAe,kBAAkB;CAEjD,MAAM,WAAW,aACd,SAAkB;EACjB,IAAI,CAAC,cAAc,qBAAqB,IAAI;EAC5C,gBAAgB,IAAI;CACtB,GACA,CAAC,cAAc,aAAa,CAC9B;CAEA,gBAAgB;EACd,IAAI,OAAO,aAAa,aAAa;EACrC,SAAS,gBAAgB,aAAa,iBAAiB,OAAO;CAChE,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO;EAAE;EAAS;CAAS;AAC7B;;;ACnCA,MAAM,aAAa;AACnB,MAAa,kBAAkB;AAE/B,MAAM,6BAAkD;CACtD,IAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,YAAY,OAAO;CACrF,OAAO,OAAO,WAAW,UAAU,CAAC,CAAC,UAAU,SAAS;AAC1D;AAWA,MAAa,uBAAuB,EAClC,gBAAgB,sBAChB,QAAQ,YACR,mBACyB,CAAC,MAAM;CAChC,MAAM,CAAC,oBAAoB,yBAAyB,SAAS,aAAa;CAC1E,MAAM,CAAC,cAAc,mBAAmB,SAA8B,oBAAoB;CAE1F,MAAM,eAAe,eAAe,KAAA;CACpC,MAAM,SAAS,eAAe,aAAa;CAE3C,MAAM,YAAY,aACf,SAAsB;EACrB,IAAI,CAAC,cAAc,sBAAsB,IAAI;EAC7C,iBAAiB,IAAI;CACvB,GACA,CAAC,cAAc,cAAc,CAC/B;CAGA,gBAAgB;EACd,IAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,YAAY;EAC9E,MAAM,KAAK,OAAO,WAAW,UAAU;EACvC,MAAM,iBAAiB,gBAAgB,GAAG,UAAU,SAAS,OAAO;EACpE,SAAS;EACT,GAAG,iBAAiB,UAAU,QAAQ;EACtC,aAAa,GAAG,oBAAoB,UAAU,QAAQ;CACxD,GAAG,CAAC,CAAC;CAEL,MAAM,iBAAsC,WAAW,WAAW,eAAe;CAEjF,gBAAgB;EACd,IAAI,OAAO,aAAa,aAAa;EACrC,SAAS,gBAAgB,aAAa,iBAAiB,cAAc;CACvE,GAAG,CAAC,cAAc,CAAC;CAEnB,OAAO;EAAE;EAAQ;EAAgB;CAAU;AAC7C"}

package/dist/useControllableState-M6494mCT.js

@@ -0,0 +1,31 @@
+import { useCallback, useRef, useState } from "react";
+//#region src/hooks/useControllableState.ts
+/**
+* Controlled/uncontrolled state, à la Radix's `useControllableState`.
+*
+* Returns a `[value, setValue]` tuple where `setValue` accepts a value or an updater
+* function (`SetStateAction<T>`). In controlled mode (`prop !== undefined`) the hook never
+* owns state — `setValue` resolves the next value and calls `onChange`; the parent is
+* responsible for feeding the new `prop` back. In uncontrolled mode the hook owns the value
+* in internal state and still calls `onChange`. `onChange` fires on every `setValue` call
+* (it is not deduped against the previous value).
+*/
+const useControllableState = ({ prop, defaultProp, onChange }) => {
+	const [uncontrolled, setUncontrolled] = useState(defaultProp);
+	const isControlled = prop !== void 0;
+	const value = prop !== void 0 ? prop : uncontrolled;
+	const valueRef = useRef(value);
+	valueRef.current = value;
+	const onChangeRef = useRef(onChange);
+	onChangeRef.current = onChange;
+	return [value, useCallback((next) => {
+		const nextValue = typeof next === "function" ? next(valueRef.current) : next;
+		valueRef.current = nextValue;
+		if (!isControlled) setUncontrolled(nextValue);
+		onChangeRef.current?.(nextValue);
+	}, [isControlled])];
+};
+//#endregion
+export { useControllableState };
+
+//# sourceMappingURL=useControllableState-M6494mCT.js.map

package/dist/useControllableState-M6494mCT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useControllableState-M6494mCT.js","names":[],"sources":["../src/hooks/useControllableState.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\nimport type { Dispatch, SetStateAction } from 'react';\n\ntype UseControllableStateParams<T> = {\n  /** The controlled value. When defined, the hook operates in controlled mode. */\n  prop: T | undefined;\n  /** The initial value used in uncontrolled mode. */\n  defaultProp: T;\n  /** Called with the next value whenever `setValue` runs (controlled and uncontrolled). */\n  onChange?: (value: T) => void;\n};\n\n/**\n * Controlled/uncontrolled state, à la Radix's `useControllableState`.\n *\n * Returns a `[value, setValue]` tuple where `setValue` accepts a value or an updater\n * function (`SetStateAction<T>`). In controlled mode (`prop !== undefined`) the hook never\n * owns state — `setValue` resolves the next value and calls `onChange`; the parent is\n * responsible for feeding the new `prop` back. In uncontrolled mode the hook owns the value\n * in internal state and still calls `onChange`. `onChange` fires on every `setValue` call\n * (it is not deduped against the previous value).\n */\nexport const useControllableState = <T>({\n  prop,\n  defaultProp,\n  onChange,\n}: UseControllableStateParams<T>): readonly [T, Dispatch<SetStateAction<T>>] => {\n  const [uncontrolled, setUncontrolled] = useState<T>(defaultProp);\n  const isControlled = prop !== undefined;\n  // Inline the `!== undefined` check (rather than reusing `isControlled`) so TypeScript\n  // narrows `prop` from `T | undefined` to `T` here.\n  const value = prop !== undefined ? prop : uncontrolled;\n\n  // Read the latest value/onChange without widening `setValue`'s dependency list,\n  // keeping its identity stable across renders.\n  const valueRef = useRef(value);\n  valueRef.current = value;\n  const onChangeRef = useRef(onChange);\n  onChangeRef.current = onChange;\n\n  const setValue = useCallback<Dispatch<SetStateAction<T>>>(\n    (next) => {\n      const nextValue =\n        typeof next === 'function' ? (next as (prev: T) => T)(valueRef.current) : next;\n      // Advance the ref immediately so multiple functional-updater calls in the same tick\n      // compose (each resolves against the previous result, not the stale render value).\n      valueRef.current = nextValue;\n      if (!isControlled) setUncontrolled(nextValue);\n      onChangeRef.current?.(nextValue);\n    },\n    [isControlled],\n  );\n\n  return [value, setValue] as const;\n};\n"],"mappings":";;;;;;;;;;;;AAsBA,MAAa,wBAA2B,EACtC,MACA,aACA,eAC8E;CAC9E,MAAM,CAAC,cAAc,mBAAmB,SAAY,WAAW;CAC/D,MAAM,eAAe,SAAS,KAAA;CAG9B,MAAM,QAAQ,SAAS,KAAA,IAAY,OAAO;CAI1C,MAAM,WAAW,OAAO,KAAK;CAC7B,SAAS,UAAU;CACnB,MAAM,cAAc,OAAO,QAAQ;CACnC,YAAY,UAAU;CAetB,OAAO,CAAC,OAbS,aACd,SAAS;EACR,MAAM,YACJ,OAAO,SAAS,aAAc,KAAwB,SAAS,OAAO,IAAI;EAG5E,SAAS,UAAU;EACnB,IAAI,CAAC,cAAc,gBAAgB,SAAS;EAC5C,YAAY,UAAU,SAAS;CACjC,GACA,CAAC,YAAY,CAGO,CAAC;AACzB"}

package/dist/useElement-DkF6esWL.js

@@ -0,0 +1,15 @@
+import { useCallback, useState } from "react";
+//#region src/hooks/useElement.ts
+const useElement = () => {
+	const [element, _setElement] = useState(null);
+	return [element, useCallback((node) => {
+		_setElement((prev) => {
+			if (prev !== null) return prev;
+			return node;
+		});
+	}, [])];
+};
+//#endregion
+export { useElement };
+
+//# sourceMappingURL=useElement-DkF6esWL.js.map

package/dist/useElement-DkF6esWL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useElement-DkF6esWL.js","names":[],"sources":["../src/hooks/useElement.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\n\n// This hook is used to set an element reference and ensure that it only updates once, when element is first set.\nexport const useElement = () => {\n  const [element, _setElement] = useState<HTMLElement | null>(null);\n\n  const setElement = useCallback((node: HTMLElement | null) => {\n    _setElement((prev) => {\n      // Only update if not already set\n      if (prev !== null) return prev;\n      return node;\n    });\n  }, []);\n\n  return [element, setElement] as const;\n};\n"],"mappings":";;AAGA,MAAa,mBAAmB;CAC9B,MAAM,CAAC,SAAS,eAAe,SAA6B,IAAI;CAUhE,OAAO,CAAC,SARW,aAAa,SAA6B;EAC3D,aAAa,SAAS;GAEpB,IAAI,SAAS,MAAM,OAAO;GAC1B,OAAO;EACT,CAAC;CACH,GAAG,CAAC,CAEsB,CAAC;AAC7B"}

package/dist/useMergeDiff-CvowEXJ1.js

@@ -0,0 +1,465 @@
+import { CHANGE_CLASS, CHUNK_TYPE } from "./internal/components/MergeEditor/constants.js";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { diffLines } from "diff";
+import { diff3Merge } from "node-diff3";
+//#region src/components/MergeEditor/helpers.ts
+/**
+* Computes diff chunks between oldText and newText using line-level diffing.
+* Adjacent removed+added pairs are kept as separate chunks so the consumer
+* can pair them into "modifications" for accept controls.
+*/
+const computeDiffChunks = (oldText, newText) => {
+	const changes = diffLines(oldText, newText);
+	const chunks = [];
+	let oldLine = 1;
+	let newLine = 1;
+	for (const change of changes) {
+		if (change.value === "") continue;
+		const lineCount = change.count || change.value.replace(/\n$/, "").split("\n").length;
+		if (change.removed) {
+			chunks.push({
+				type: CHUNK_TYPE.REMOVED,
+				value: change.value,
+				oldStart: oldLine,
+				oldEnd: oldLine + lineCount - 1,
+				newStart: newLine,
+				newEnd: newLine
+			});
+			oldLine += lineCount;
+		} else if (change.added) {
+			chunks.push({
+				type: CHUNK_TYPE.ADDED,
+				value: change.value,
+				oldStart: oldLine,
+				oldEnd: oldLine,
+				newStart: newLine,
+				newEnd: newLine + lineCount - 1
+			});
+			newLine += lineCount;
+		} else {
+			chunks.push({
+				type: CHUNK_TYPE.UNCHANGED,
+				value: change.value,
+				oldStart: oldLine,
+				oldEnd: oldLine + lineCount - 1,
+				newStart: newLine,
+				newEnd: newLine + lineCount - 1
+			});
+			oldLine += lineCount;
+			newLine += lineCount;
+		}
+	}
+	return chunks;
+};
+/**
+* Collects 1-indexed line numbers that are marked as changed (added or removed)
+* from a set of diff chunks. `side` determines which line range to use.
+*/
+const getChangedLineNumbers = (chunks, side) => {
+	const lines = /* @__PURE__ */ new Set();
+	for (const chunk of chunks) {
+		if (chunk.type === CHUNK_TYPE.UNCHANGED) continue;
+		if (side === "old" && chunk.type === CHUNK_TYPE.REMOVED) for (let i = chunk.oldStart; i <= chunk.oldEnd; i++) lines.add(i);
+		if (side === "new" && chunk.type === CHUNK_TYPE.ADDED) for (let i = chunk.newStart; i <= chunk.newEnd; i++) lines.add(i);
+	}
+	return lines;
+};
+/**
+* Filters changed line numbers, keeping only those that are classified
+* and not suppressed (resolved/dismissed).
+*
+* `classification` and `suppressedLines` must be keyed by line numbers
+* from the same `side` (old-side lines for 'old', new-side lines for 'new').
+*/
+const filterHighlightedLines = (chunks, side, classification, suppressedLines) => {
+	const filtered = /* @__PURE__ */ new Set();
+	for (const line of getChangedLineNumbers(chunks, side)) if (classification.has(line) && !suppressedLines.has(line)) filtered.add(line);
+	return filtered;
+};
+/**
+* Replaces lines in `text` between `startLine` and `endLine` (1-indexed, inclusive)
+* with `replacementLines`. If startLine > endLine, inserts before startLine.
+*/
+const replaceLines = (text, startLine, endLine, replacement) => {
+	const lines = text.split("\n");
+	const before = lines.slice(0, startLine - 1);
+	const after = startLine > endLine ? lines.slice(startLine - 1) : lines.slice(endLine);
+	const replacementArr = replacement === "" ? [] : replacement.replace(/\n$/, "").split("\n");
+	return [
+		...before,
+		...replacementArr,
+		...after
+	].join("\n");
+};
+//#endregion
+//#region src/components/MergeEditor/useMergeDiff.ts
+const DEBOUNCE_MS = 150;
+const rangesOverlap = (s1, e1, s2, e2) => s1 <= e2 && e1 >= s2;
+const computeSuppressedLines = (dismissedLines, pairs, resolvedIds, getRange) => {
+	const lines = new Set(dismissedLines);
+	for (const pair of pairs) if (resolvedIds.has(pair.id)) {
+		const [start, end] = getRange(pair);
+		for (let i = start; i <= end; i++) lines.add(i);
+	}
+	return lines;
+};
+const filterVisibleConflicts = (conflicts, classification, dismissedLines, getRange, findPair, fullyResolvedPairIds) => conflicts.filter((c) => {
+	const [start, end] = getRange(c);
+	let hasClassifiedLine = false;
+	let allDismissed = true;
+	for (let i = start; i <= end; i++) {
+		if (classification.has(i)) hasClassifiedLine = true;
+		if (!dismissedLines.has(i)) allDismissed = false;
+	}
+	if (!hasClassifiedLine || allDismissed) return false;
+	const pair = findPair(c);
+	return !pair || !fullyResolvedPairIds.has(pair.id);
+});
+const useMergeDiff = (baseText, leftText, rightText) => {
+	const [mergeValue, setMergeValue] = useState(baseText);
+	const debounceRef = useRef(null);
+	const [debouncedMergeValue, setDebouncedMergeValue] = useState(mergeValue);
+	const [acceptedPairSides, setAcceptedPairSides] = useState(() => /* @__PURE__ */ new Map());
+	const [dismissedLeftLines, setDismissedLeftLines] = useState(() => /* @__PURE__ */ new Set());
+	const [dismissedRightLines, setDismissedRightLines] = useState(() => /* @__PURE__ */ new Set());
+	const reset = useCallback(() => {
+		if (debounceRef.current) {
+			clearTimeout(debounceRef.current);
+			debounceRef.current = null;
+		}
+		setMergeValue(baseText);
+		setDebouncedMergeValue(baseText);
+		setAcceptedPairSides(/* @__PURE__ */ new Map());
+		setDismissedLeftLines(/* @__PURE__ */ new Set());
+		setDismissedRightLines(/* @__PURE__ */ new Set());
+	}, [baseText]);
+	useLayoutEffect(() => {
+		reset();
+	}, [
+		baseText,
+		leftText,
+		rightText
+	]);
+	useEffect(() => {
+		return () => {
+			if (debounceRef.current) clearTimeout(debounceRef.current);
+		};
+	}, []);
+	const handleMergeChange = useCallback((value) => {
+		setMergeValue(value);
+		if (debounceRef.current) clearTimeout(debounceRef.current);
+		debounceRef.current = setTimeout(() => {
+			setDebouncedMergeValue(value);
+		}, DEBOUNCE_MS);
+	}, []);
+	const leftDiffChunks = useMemo(() => computeDiffChunks(leftText, debouncedMergeValue), [leftText, debouncedMergeValue]);
+	const rightDiffChunks = useMemo(() => computeDiffChunks(debouncedMergeValue, rightText), [debouncedMergeValue, rightText]);
+	const leftConflicts = useMemo(() => pairChunksIntoConflicts(leftDiffChunks), [leftDiffChunks]);
+	const rightConflicts = useMemo(() => pairChunksIntoConflicts(rightDiffChunks), [rightDiffChunks]);
+	const leftVsBase = useMemo(() => computeDiffChunks(baseText, leftText), [baseText, leftText]);
+	const rightVsBase = useMemo(() => computeDiffChunks(baseText, rightText), [baseText, rightText]);
+	const { leftClassification, rightClassification, conflictPairs } = useMemo(() => {
+		const baseLines = baseText.split("\n");
+		const leftLines = leftText.split("\n");
+		const rightLines = rightText.split("\n");
+		const result = diff3Merge(leftLines, baseLines, rightLines);
+		const leftConflictLineSet = /* @__PURE__ */ new Set();
+		const rightConflictLineSet = /* @__PURE__ */ new Set();
+		const pairs = [];
+		for (const block of result) if ("conflict" in block && block.conflict) {
+			const { a, aIndex, b, bIndex } = block.conflict;
+			for (let i = 0; i < a.length; i++) leftConflictLineSet.add(aIndex + i + 1);
+			for (let i = 0; i < b.length; i++) rightConflictLineSet.add(bIndex + i + 1);
+			pairs.push({
+				id: `pair-${aIndex}-${bIndex}`,
+				leftStart: aIndex + 1,
+				leftEnd: aIndex + a.length,
+				rightStart: bIndex + 1,
+				rightEnd: bIndex + b.length
+			});
+		}
+		const leftChanged = getChangedLineNumbers(leftVsBase, "new");
+		const rightChanged = getChangedLineNumbers(rightVsBase, "new");
+		const leftMap = /* @__PURE__ */ new Map();
+		for (const line of leftChanged) leftMap.set(line, leftConflictLineSet.has(line) ? CHANGE_CLASS.CONFLICT : CHANGE_CLASS.SAFE);
+		const rightMap = /* @__PURE__ */ new Map();
+		for (const line of rightChanged) rightMap.set(line, rightConflictLineSet.has(line) ? CHANGE_CLASS.CONFLICT : CHANGE_CLASS.SAFE);
+		return {
+			leftClassification: leftMap,
+			rightClassification: rightMap,
+			conflictPairs: pairs
+		};
+	}, [
+		baseText,
+		leftText,
+		rightText,
+		leftVsBase,
+		rightVsBase
+	]);
+	const findPairForLeft = useCallback((conflict) => conflictPairs.find((p) => rangesOverlap(conflict.oldStartLine, conflict.oldEndLine, p.leftStart, p.leftEnd)), [conflictPairs]);
+	const findPairForRight = useCallback((conflict) => conflictPairs.find((p) => rangesOverlap(conflict.newStartLine, conflict.newEndLine, p.rightStart, p.rightEnd)), [conflictPairs]);
+	const markSideAccepted = useCallback((pair, side) => {
+		if (!pair) return;
+		setAcceptedPairSides((prev) => {
+			const next = new Map(prev);
+			const sides = new Set(prev.get(pair.id) ?? []);
+			sides.add(side);
+			next.set(pair.id, sides);
+			return next;
+		});
+	}, []);
+	const isOtherSideAccepted = useCallback((pair, side) => {
+		if (!pair) return false;
+		const otherSide = side === "left" ? "right" : "left";
+		return acceptedPairSides.get(pair.id)?.has(otherSide) ?? false;
+	}, [acceptedPairSides]);
+	const acceptSide = useCallback((conflict, side) => {
+		const pair = (side === "left" ? findPairForLeft : findPairForRight)(conflict);
+		const otherAccepted = isOtherSideAccepted(pair, side);
+		const sourceValue = side === "left" ? conflict.oldValue : conflict.newValue;
+		const targetStart = side === "left" ? conflict.newStartLine : conflict.oldStartLine;
+		const targetEnd = side === "left" ? conflict.newEndLine : conflict.oldEndLine;
+		if (debounceRef.current) {
+			clearTimeout(debounceRef.current);
+			debounceRef.current = null;
+		}
+		const mergeTargetEmpty = side === "left" ? conflict.newValue === "" : conflict.oldValue === "";
+		const newValue = otherAccepted ? replaceLines(mergeValue, targetEnd + 1, targetEnd, sourceValue) : mergeTargetEmpty ? replaceLines(mergeValue, targetStart, targetStart - 1, sourceValue) : replaceLines(mergeValue, targetStart, targetEnd, sourceValue);
+		setMergeValue(newValue);
+		setDebouncedMergeValue(newValue);
+		markSideAccepted(pair, side);
+		if (!pair) {
+			const setDismissedSide = side === "left" ? setDismissedLeftLines : setDismissedRightLines;
+			const [sideStart, sideEnd] = side === "left" ? [conflict.oldStartLine, conflict.oldEndLine] : [conflict.newStartLine, conflict.newEndLine];
+			setDismissedSide((prev) => {
+				const next = new Set(prev);
+				for (let i = sideStart; i <= sideEnd; i++) next.add(i);
+				return next;
+			});
+		}
+	}, [
+		mergeValue,
+		findPairForLeft,
+		findPairForRight,
+		isOtherSideAccepted,
+		markSideAccepted
+	]);
+	const acceptLeft = useCallback((conflict) => acceptSide(conflict, "left"), [acceptSide]);
+	const acceptRight = useCallback((conflict) => acceptSide(conflict, "right"), [acceptSide]);
+	const dismissSide = useCallback((conflict, side) => {
+		const setDismissed = side === "left" ? setDismissedLeftLines : setDismissedRightLines;
+		const [sideStart, sideEnd] = side === "left" ? [conflict.oldStartLine, conflict.oldEndLine] : [conflict.newStartLine, conflict.newEndLine];
+		setDismissed((prev) => {
+			const next = new Set(prev);
+			for (let i = sideStart; i <= sideEnd; i++) next.add(i);
+			return next;
+		});
+	}, []);
+	const dismissLeft = useCallback((conflict) => dismissSide(conflict, "left"), [dismissSide]);
+	const dismissRight = useCallback((conflict) => dismissSide(conflict, "right"), [dismissSide]);
+	const fullyResolvedPairIds = useMemo(() => {
+		const ids = /* @__PURE__ */ new Set();
+		for (const pair of conflictPairs) {
+			const leftAccepted = acceptedPairSides.get(pair.id)?.has("left") ?? false;
+			const rightAccepted = acceptedPairSides.get(pair.id)?.has("right") ?? false;
+			let leftDismissed = true;
+			for (let i = pair.leftStart; i <= pair.leftEnd; i++) if (!dismissedLeftLines.has(i)) {
+				leftDismissed = false;
+				break;
+			}
+			let rightDismissed = true;
+			for (let i = pair.rightStart; i <= pair.rightEnd; i++) if (!dismissedRightLines.has(i)) {
+				rightDismissed = false;
+				break;
+			}
+			if ((leftAccepted || leftDismissed) && (rightAccepted || rightDismissed)) ids.add(pair.id);
+		}
+		return ids;
+	}, [
+		conflictPairs,
+		acceptedPairSides,
+		dismissedLeftLines,
+		dismissedRightLines
+	]);
+	const visibleLeftConflicts = useMemo(() => filterVisibleConflicts(leftConflicts, leftClassification, dismissedLeftLines, (c) => [c.oldStartLine, c.oldEndLine], findPairForLeft, fullyResolvedPairIds), [
+		leftConflicts,
+		leftClassification,
+		dismissedLeftLines,
+		findPairForLeft,
+		fullyResolvedPairIds
+	]);
+	const visibleRightConflicts = useMemo(() => filterVisibleConflicts(rightConflicts, rightClassification, dismissedRightLines, (c) => [c.newStartLine, c.newEndLine], findPairForRight, fullyResolvedPairIds), [
+		rightConflicts,
+		rightClassification,
+		dismissedRightLines,
+		findPairForRight,
+		fullyResolvedPairIds
+	]);
+	const suppressedLeftLines = useMemo(() => computeSuppressedLines(dismissedLeftLines, conflictPairs, fullyResolvedPairIds, (p) => [p.leftStart, p.leftEnd]), [
+		conflictPairs,
+		fullyResolvedPairIds,
+		dismissedLeftLines
+	]);
+	const suppressedRightLines = useMemo(() => computeSuppressedLines(dismissedRightLines, conflictPairs, fullyResolvedPairIds, (p) => [p.rightStart, p.rightEnd]), [
+		conflictPairs,
+		fullyResolvedPairIds,
+		dismissedRightLines
+	]);
+	const { mergeHighlightedLines, mergeClassification } = useMemo(() => {
+		const mergeLeftLines = getChangedLineNumbers(leftDiffChunks, "new");
+		const mergeRightLines = getChangedLineNumbers(rightDiffChunks, "old");
+		const mergeLineToPair = /* @__PURE__ */ new Map();
+		for (const conflict of leftConflicts) {
+			const pair = findPairForLeft(conflict);
+			if (pair) for (let i = conflict.newStartLine; i <= conflict.newEndLine; i++) mergeLineToPair.set(i, pair.id);
+		}
+		for (const conflict of rightConflicts) {
+			const pair = findPairForRight(conflict);
+			if (pair) for (let i = conflict.oldStartLine; i <= conflict.oldEndLine; i++) mergeLineToPair.set(i, pair.id);
+		}
+		const suppressedMergeLines = /* @__PURE__ */ new Set();
+		for (const conflict of leftConflicts) {
+			if (findPairForLeft(conflict)) continue;
+			if (conflict.oldStartLine > conflict.oldEndLine) continue;
+			let allDismissed = true;
+			for (let i = conflict.oldStartLine; i <= conflict.oldEndLine; i++) if (!dismissedLeftLines.has(i)) {
+				allDismissed = false;
+				break;
+			}
+			if (allDismissed) for (let i = conflict.newStartLine; i <= conflict.newEndLine; i++) suppressedMergeLines.add(i);
+		}
+		for (const conflict of rightConflicts) {
+			if (findPairForRight(conflict)) continue;
+			if (conflict.newStartLine > conflict.newEndLine) continue;
+			let allDismissed = true;
+			for (let i = conflict.newStartLine; i <= conflict.newEndLine; i++) if (!dismissedRightLines.has(i)) {
+				allDismissed = false;
+				break;
+			}
+			if (allDismissed) for (let i = conflict.oldStartLine; i <= conflict.oldEndLine; i++) suppressedMergeLines.add(i);
+		}
+		const allMergeLines = /* @__PURE__ */ new Set();
+		for (const line of mergeLeftLines) allMergeLines.add(line);
+		for (const line of mergeRightLines) allMergeLines.add(line);
+		const highlighted = /* @__PURE__ */ new Set();
+		const classification = /* @__PURE__ */ new Map();
+		for (const line of allMergeLines) {
+			if (suppressedMergeLines.has(line)) continue;
+			const pairId = mergeLineToPair.get(line);
+			if (pairId && fullyResolvedPairIds.has(pairId)) continue;
+			highlighted.add(line);
+			classification.set(line, pairId ? CHANGE_CLASS.CONFLICT : CHANGE_CLASS.SAFE);
+		}
+		return {
+			mergeHighlightedLines: highlighted,
+			mergeClassification: classification
+		};
+	}, [
+		leftDiffChunks,
+		rightDiffChunks,
+		leftConflicts,
+		rightConflicts,
+		findPairForLeft,
+		findPairForRight,
+		fullyResolvedPairIds,
+		dismissedLeftLines,
+		dismissedRightLines
+	]);
+	const leftHighlightedLines = useMemo(() => filterHighlightedLines(leftDiffChunks, "old", leftClassification, suppressedLeftLines), [
+		leftDiffChunks,
+		leftClassification,
+		suppressedLeftLines
+	]);
+	const rightHighlightedLines = useMemo(() => filterHighlightedLines(rightDiffChunks, "new", rightClassification, suppressedRightLines), [
+		rightDiffChunks,
+		rightClassification,
+		suppressedRightLines
+	]);
+	const remainingSafeChanges = useMemo(() => {
+		return visibleLeftConflicts.filter((c) => !findPairForLeft(c)).length + visibleRightConflicts.filter((c) => !findPairForRight(c)).length;
+	}, [
+		visibleLeftConflicts,
+		visibleRightConflicts,
+		findPairForLeft,
+		findPairForRight
+	]);
+	return {
+		mergeValue,
+		handleMergeChange,
+		leftConflicts: visibleLeftConflicts,
+		rightConflicts: visibleRightConflicts,
+		leftHighlightedLines,
+		rightHighlightedLines,
+		leftClassification,
+		rightClassification,
+		mergeHighlightedLines,
+		mergeClassification,
+		acceptLeft,
+		acceptRight,
+		dismissLeft,
+		dismissRight,
+		totalConflicts: conflictPairs.length,
+		resolvedConflicts: fullyResolvedPairIds.size,
+		remainingSafeChanges,
+		isDirty: mergeValue !== baseText || dismissedLeftLines.size > 0 || dismissedRightLines.size > 0,
+		reset
+	};
+};
+/**
+* Pairs adjacent removed+added chunks into MergeConflicts.
+* A standalone REMOVED or ADDED chunk becomes a conflict with
+* the other side empty.
+*/
+const pairChunksIntoConflicts = (chunks) => {
+	const conflicts = [];
+	let i = 0;
+	while (i < chunks.length) {
+		const chunk = chunks[i];
+		if (chunk.type === CHUNK_TYPE.UNCHANGED) {
+			i++;
+			continue;
+		}
+		if (chunk.type === CHUNK_TYPE.REMOVED) {
+			const next = chunks[i + 1];
+			if (next?.type === CHUNK_TYPE.ADDED) {
+				conflicts.push({
+					id: `${chunk.oldStart}-${next.newStart}`,
+					oldValue: chunk.value,
+					oldStartLine: chunk.oldStart,
+					oldEndLine: chunk.oldEnd,
+					newValue: next.value,
+					newStartLine: next.newStart,
+					newEndLine: next.newEnd
+				});
+				i += 2;
+			} else {
+				conflicts.push({
+					id: `${chunk.oldStart}-del`,
+					oldValue: chunk.value,
+					oldStartLine: chunk.oldStart,
+					oldEndLine: chunk.oldEnd,
+					newValue: "",
+					newStartLine: chunk.newStart,
+					newEndLine: chunk.newStart
+				});
+				i++;
+			}
+		} else {
+			conflicts.push({
+				id: `add-${chunk.newStart}`,
+				oldValue: "",
+				oldStartLine: chunk.oldStart,
+				oldEndLine: chunk.oldStart,
+				newValue: chunk.value,
+				newStartLine: chunk.newStart,
+				newEndLine: chunk.newEnd
+			});
+			i++;
+		}
+	}
+	return conflicts;
+};
+//#endregion
+export { useMergeDiff };
+
+//# sourceMappingURL=useMergeDiff-CvowEXJ1.js.map