@keboola/design 10.1.0 → 11.0.0

package/dist/chunk-BHGIDSRJ.js

@@ -0,0 +1,140 @@
+import { ChevronsUpDown, ChevronUp, ChevronDown } from './chunk-RQVK4IYC.js';
+import { cn } from './chunk-LXLIQ2D6.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var TableBody = ({
+  withBorderSeparator = true,
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx(
+    "tbody",
+    {
+      className: cn(
+        {
+          "tw:[&_tr]:border-0 tw:[&_tr]:border-b-border tw:[&_tr]:border-b tw:[&_tr]:border-solid tw:[&_tr:last-child]:border-0": withBorderSeparator
+        },
+        className
+      ),
+      ...props
+    }
+  );
+};
+var TableCell = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsx("td", { className: cn("tw:px-3 tw:py-2", className), ...props });
+};
+var TableFooter = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsx(
+    "tfoot",
+    {
+      className: cn(
+        "tw:bg-muted/50 tw:border-t tw:border-border tw:font-medium tw:[&>tr]:last:border-b-0",
+        className
+      ),
+      ...props
+    }
+  );
+};
+var TableHead = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsx(
+    "th",
+    {
+      className: cn(
+        "tw:px-3 tw:py-2 tw:text-left tw:font-medium tw:whitespace-nowrap tw:[&:has([role=checkbox])]:pr-0 tw:[&>[role=checkbox]]:translate-y-[2px] tw:focus-within:ring-2 tw:focus-within:ring-ring/50",
+        className
+      ),
+      ...props
+    }
+  );
+};
+var TableHeader = ({
+  withShadow = false,
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx(
+    "thead",
+    {
+      className: cn(
+        // `[&_tr]:hover:` (0,2,1) outranks `TableRow`'s own `hover:bg-muted/50` (0,2,0), so the
+        // header row keeps its background instead of flashing muted — a header is not hoverable.
+        "tw:sticky tw:top-0 tw:z-10 tw:[&_tr]:bg-table-header tw:[&_tr]:hover:bg-table-header tw:[&_tr]:border-b tw:[&_tr]:border-border",
+        { "tw:shadow-table": withShadow },
+        className
+      ),
+      ...props
+    }
+  );
+};
+var TableRow = ({ ref, className, ...props }) => /* @__PURE__ */ jsx(
+  "tr",
+  {
+    ref,
+    className: cn(
+      "tw:hover:bg-muted/50 tw:aria-selected:bg-accent tw:aria-selected:hover:bg-accent",
+      className
+    ),
+    ...props
+  }
+);
+var tableAriaSort = (sorted) => sorted === "asc" ? "ascending" : sorted === "desc" ? "descending" : "none";
+var TableSortHeader = ({ sorted, children, className, ...props }) => {
+  const Icon = sorted === false ? ChevronsUpDown : sorted === "asc" ? ChevronUp : ChevronDown;
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: cn(
+        "tw:group tw:flex tw:cursor-pointer tw:items-center tw:gap-1 tw:border-0 tw:bg-transparent tw:p-0 tw:font-medium tw:text-inherit",
+        className
+      ),
+      ...props,
+      type: "button",
+      children: [
+        children,
+        /* @__PURE__ */ jsx(Icon, { className: "tw:size-3 tw:text-muted-foreground" })
+      ]
+    }
+  );
+};
+var Table = ({
+  borderCollapsed = true,
+  bordered = false,
+  containerClassName,
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "tw:relative tw:w-full",
+        bordered && "tw:overflow-auto tw:rounded-[10px] tw:border tw:border-solid tw:border-border",
+        containerClassName
+      ),
+      children: /* @__PURE__ */ jsx(
+        "table",
+        {
+          className: cn(
+            // `tw:text-foreground` (a semantic token) so header + cell text flips
+            // under `[data-theme='dark']` instead of inheriting a fixed dark color.
+            "tw:w-full tw:caption-bottom tw:text-sm tw:text-foreground",
+            borderCollapsed ? "tw:border-collapse" : "tw:border-separate tw:border-spacing-y-1",
+            className
+          ),
+          ...props
+        }
+      )
+    }
+  );
+};
+Table.Header = TableHeader;
+Table.Head = TableHead;
+Table.Body = TableBody;
+Table.Row = TableRow;
+Table.Cell = TableCell;
+Table.Footer = TableFooter;
+Table.SortHeader = TableSortHeader;
+
+export { Table, TableSortHeader, tableAriaSort };
+//# sourceMappingURL=chunk-BHGIDSRJ.js.map
+//# sourceMappingURL=chunk-BHGIDSRJ.js.map

package/dist/chunk-BHGIDSRJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Table/TableBody.tsx","../src/components/Table/TableCell.tsx","../src/components/Table/TableFooter.tsx","../src/components/Table/TableHead.tsx","../src/components/Table/TableHeader.tsx","../src/components/Table/TableRow.tsx","../src/components/Table/TableSortHeader.tsx","../src/components/Table/Table.tsx"],"names":["jsx"],"mappings":"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","file":"chunk-BHGIDSRJ.js","sourcesContent":["import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nexport const TableBody = ({\n  withBorderSeparator = true,\n  className,\n  ...props\n}: { withBorderSeparator?: boolean } & ComponentProps<'tbody'>) => {\n  return (\n    <tbody\n      className={cn(\n        {\n          'tw:[&_tr]:border-0 tw:[&_tr]:border-b-border tw:[&_tr]:border-b tw:[&_tr]:border-solid tw:[&_tr:last-child]:border-0':\n            withBorderSeparator,\n        },\n        className,\n      )}\n      {...props}\n    />\n  );\n};\n","import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nexport const TableCell = ({ className, ...props }: ComponentProps<'td'>) => {\n  return <td className={cn('tw:px-3 tw:py-2', className)} {...props} />;\n};\n","import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nexport const TableFooter = ({ className, ...props }: ComponentProps<'tfoot'>) => {\n  return (\n    <tfoot\n      className={cn(\n        'tw:bg-muted/50 tw:border-t tw:border-border tw:font-medium tw:[&>tr]:last:border-b-0',\n        className,\n      )}\n      {...props}\n    />\n  );\n};\n","import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nexport const TableHead = ({ className, ...props }: ComponentProps<'th'>) => {\n  return (\n    <th\n      className={cn(\n        'tw:px-3 tw:py-2 tw:text-left tw:font-medium tw:whitespace-nowrap tw:[&:has([role=checkbox])]:pr-0 tw:[&>[role=checkbox]]:translate-y-[2px] tw:focus-within:ring-2 tw:focus-within:ring-ring/50',\n        className,\n      )}\n      {...props}\n    />\n  );\n};\n","import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nexport const TableHeader = ({\n  withShadow = false,\n  className,\n  ...props\n}: { withShadow?: boolean } & ComponentProps<'thead'>) => {\n  return (\n    <thead\n      className={cn(\n        // `[&_tr]:hover:` (0,2,1) outranks `TableRow`'s own `hover:bg-muted/50` (0,2,0), so the\n        // header row keeps its background instead of flashing muted — a header is not hoverable.\n        'tw:sticky tw:top-0 tw:z-10 tw:[&_tr]:bg-table-header tw:[&_tr]:hover:bg-table-header tw:[&_tr]:border-b tw:[&_tr]:border-border',\n        { 'tw:shadow-table': withShadow },\n        className,\n      )}\n      {...props}\n    />\n  );\n};\n","import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nexport const TableRow = ({ ref, className, ...props }: ComponentProps<'tr'>) => (\n  <tr\n    ref={ref}\n    className={cn(\n      'tw:hover:bg-muted/50 tw:aria-selected:bg-accent tw:aria-selected:hover:bg-accent',\n      className,\n    )}\n    {...props}\n  />\n);\n","import type { ComponentProps, ReactNode } from 'react';\n\nimport { ChevronDown, ChevronsUpDown, ChevronUp } from '../../icons';\nimport { cn } from '../../utils';\n\nexport type TableSortDirection = 'asc' | 'desc' | false;\n\n/** Maps a sort direction to the `aria-sort` value for the enclosing `Table.Head`. */\nexport const tableAriaSort = (sorted: TableSortDirection): ComponentProps<'th'>['aria-sort'] =>\n  sorted === 'asc' ? 'ascending' : sorted === 'desc' ? 'descending' : 'none';\n\ntype Props = {\n  /** Current sort state for this column: `'asc'`, `'desc'`, or `false` when unsorted. */\n  sorted: TableSortDirection;\n  children: ReactNode;\n} & Omit<ComponentProps<'button'>, 'children' | 'type'>;\n\n/**\n * Clickable column-header label with a sort-direction chevron, for use inside `Table.Head`.\n *\n * Presentational only — it owns no sort state. Pair it with your sort model (a `useState`\n * key/direction pair, or `@tanstack/react-table`'s `getToggleSortingHandler()` / `getIsSorted()`)\n * and set `aria-sort` on the enclosing `Table.Head` via {@link tableAriaSort}.\n */\nexport const TableSortHeader = ({ sorted, children, className, ...props }: Props) => {\n  const Icon = sorted === false ? ChevronsUpDown : sorted === 'asc' ? ChevronUp : ChevronDown;\n  return (\n    <button\n      className={cn(\n        'tw:group tw:flex tw:cursor-pointer tw:items-center tw:gap-1 tw:border-0 tw:bg-transparent tw:p-0 tw:font-medium tw:text-inherit',\n        className,\n      )}\n      {...props}\n      type=\"button\"\n    >\n      {children}\n      <Icon className=\"tw:size-3 tw:text-muted-foreground\" />\n    </button>\n  );\n};\n","import type { ComponentProps } from 'react';\n\nimport { cn } from '../../utils';\n\nimport { TableBody } from './TableBody';\nimport { TableCell } from './TableCell';\nimport { TableFooter } from './TableFooter';\nimport { TableHead } from './TableHead';\nimport { TableHeader } from './TableHeader';\nimport { TableRow } from './TableRow';\nimport { TableSortHeader } from './TableSortHeader';\n\n/**\n * Props for `Table`. `borderCollapsed` toggles standard collapsed borders vs separate row spacing;\n * `bordered` wraps the table in a rounded bordered container with overflow scrolling.\n */\ntype Props = {\n  borderCollapsed?: boolean;\n  bordered?: boolean;\n  containerClassName?: string;\n} & ComponentProps<'table'>;\n\n/**\n * Tabular data surface with header / body / row / cell compound parts.\n *\n * **When to use:** tabular data with named columns — entity lists with shared schema (jobs, buckets,\n * tables), sortable rows, row-level actions. Compose `Table.Header` + `Table.Body` + `Table.Row` +\n * `Table.Head` / `Table.Cell`.\n * **When NOT to use:** for heterogeneous lists where each row has its own shape use a `Card` list;\n * for tree / hierarchy layouts use a custom recursive list with `Table` per level.\n * **Composition:** wrap in `PageLayout.Content`. For sortable / filterable behaviour bring your own\n * state library (TanStack Table is a common pairing); this component is presentational.\n *\n * @see RECIPES.md#list-detail — for a list-table + row-click-to-detail pattern\n */\nexport const Table = ({\n  borderCollapsed = true,\n  bordered = false,\n  containerClassName,\n  className,\n  ...props\n}: Props) => {\n  return (\n    <div\n      className={cn(\n        'tw:relative tw:w-full',\n        bordered && 'tw:overflow-auto tw:rounded-[10px] tw:border tw:border-solid tw:border-border',\n        containerClassName,\n      )}\n    >\n      <table\n        className={cn(\n          // `tw:text-foreground` (a semantic token) so header + cell text flips\n          // under `[data-theme='dark']` instead of inheriting a fixed dark color.\n          'tw:w-full tw:caption-bottom tw:text-sm tw:text-foreground',\n          borderCollapsed ? 'tw:border-collapse' : 'tw:border-separate tw:border-spacing-y-1',\n          className,\n        )}\n        {...props}\n      />\n    </div>\n  );\n};\n\nTable.Header = TableHeader;\nTable.Head = TableHead;\nTable.Body = TableBody;\nTable.Row = TableRow;\nTable.Cell = TableCell;\nTable.Footer = TableFooter;\nTable.SortHeader = TableSortHeader;\n"]}

package/dist/chunk-BSQWZITZ.js

@@ -0,0 +1,507 @@
+import { CHANGE_CLASS, CHUNK_TYPE } from './chunk-OTL5WXIJ.js';
+import { useState, useRef, useCallback, useLayoutEffect, useEffect, useMemo } from 'react';
+import { diff3Merge } from 'node-diff3';
+import { diffLines } from 'diff';
+
+var 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;
+};
+var 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;
+};
+var 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;
+};
+var 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");
+};
+
+// src/components/MergeEditor/useMergeDiff.ts
+var DEBOUNCE_MS = 150;
+var rangesOverlap = (s1, e1, s2, e2) => s1 <= e2 && e1 >= s2;
+var 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;
+};
+var 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);
+});
+var 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 findPair = side === "left" ? findPairForLeft : findPairForRight;
+      const pair = findPair(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(() => {
+    const leftSafe = visibleLeftConflicts.filter((c) => !findPairForLeft(c)).length;
+    const rightSafe = visibleRightConflicts.filter((c) => !findPairForRight(c)).length;
+    return leftSafe + rightSafe;
+  }, [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
+  };
+};
+var 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;
+};
+
+export { useMergeDiff };
+//# sourceMappingURL=chunk-BSQWZITZ.js.map
+//# sourceMappingURL=chunk-BSQWZITZ.js.map