@cristianmpx/react-import-sheet-ui-raw 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1696 @@
+// src/hooks/useRawImporterRoot/useRawImporterRoot.ts
+import { useMemo } from "react";
+var defaultStages = {};
+function useRawImporterRoot(options = {}) {
+  const {
+    layout,
+    engine,
+    persist,
+    persistKey,
+    fuzzyMatch = true,
+    editingEnabled = true,
+    stages = defaultStages,
+    autoApplyMappingWhenMismatchesAtMost = "never",
+    showErrorWhenMismatchesAbove,
+    onSubmit,
+    submitKeyMap
+  } = options;
+  const providerProps = useMemo(
+    () => ({
+      layout,
+      engine,
+      persist,
+      persistKey,
+      onSubmit,
+      submitKeyMap
+    }),
+    [layout, engine, persist, persistKey, onSubmit, submitKeyMap]
+  );
+  const rootConfig = useMemo(
+    () => ({
+      fuzzyMatch,
+      editingEnabled,
+      stages: { ...defaultStages, ...stages },
+      autoApplyMappingWhenMismatchesAtMost,
+      showErrorWhenMismatchesAbove
+    }),
+    [
+      fuzzyMatch,
+      editingEnabled,
+      stages,
+      autoApplyMappingWhenMismatchesAtMost,
+      showErrorWhenMismatchesAbove
+    ]
+  );
+  return { providerProps, rootConfig };
+}
+
+// src/hooks/useRawImporterRoot/RootConfigContext.tsx
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var defaultConfig = {
+  fuzzyMatch: true,
+  editingEnabled: true,
+  stages: {},
+  autoApplyMappingWhenMismatchesAtMost: "never",
+  showErrorWhenMismatchesAbove: void 0
+};
+var RootConfigContext = createContext(defaultConfig);
+var LayoutContext = createContext(null);
+function RootConfigProvider({ rootConfig, children }) {
+  return /* @__PURE__ */ jsx(RootConfigContext.Provider, { value: rootConfig, children });
+}
+function LayoutProvider({ layout, children }) {
+  return /* @__PURE__ */ jsx(LayoutContext.Provider, { value: layout, children });
+}
+
+// src/hooks/useStatusView/useStatusView.ts
+import { useContext, useEffect, useMemo as useMemo2, useRef } from "react";
+import { useConvert, useImporterStatus } from "@cristianmpx/react-import-sheet-headless";
+
+// src/shared/types/status-views.ts
+function getViewFromState(status, convertResult) {
+  if (convertResult !== null && convertResult !== void 0) {
+    return "mapping";
+  }
+  switch (status) {
+    case "idle":
+    case "loading":
+    case "parsing":
+      return "idle";
+    case "validating":
+    case "transforming":
+      return "process";
+    case "success":
+      return "result";
+    case "error":
+    case "cancelled":
+      return "error";
+    default:
+      return "idle";
+  }
+}
+
+// src/hooks/useStatusView/useStatusView.ts
+function applyStages(view, stages) {
+  if (view === "mapping" && stages.mapping === false) return "idle";
+  if (view === "process" && stages.process === false) return "idle";
+  if (view === "result" && stages.result === false) return "idle";
+  return view;
+}
+function resolveMappingView(rawView, mismatchCount, autoApply, showErrorAbove) {
+  if (rawView !== "mapping") {
+    return { view: rawView, mappingErrorDetail: null };
+  }
+  if (showErrorAbove != null && mismatchCount > showErrorAbove) {
+    return {
+      view: "error",
+      mappingErrorDetail: {
+        code: "TOO_MANY_MISMATCHES",
+        mismatchCount,
+        maxAllowed: showErrorAbove
+      }
+    };
+  }
+  if (autoApply !== "never" && typeof autoApply === "number" && mismatchCount <= autoApply) {
+    return { view: "process", mappingErrorDetail: null };
+  }
+  return { view: "mapping", mappingErrorDetail: null };
+}
+function useStatusView() {
+  const rootConfig = useContext(RootConfigContext);
+  const { status, progressEventTarget } = useImporterStatus();
+  const { convertResult } = useConvert();
+  const mismatchCount = useMemo2(
+    () => convertResult?.mismatches?.length ?? 0,
+    [convertResult]
+  );
+  const { view, mappingErrorDetail } = useMemo2(() => {
+    const raw = getViewFromState(status, convertResult);
+    const afterStages = applyStages(raw, rootConfig.stages);
+    return resolveMappingView(
+      afterStages,
+      mismatchCount,
+      rootConfig.autoApplyMappingWhenMismatchesAtMost,
+      rootConfig.showErrorWhenMismatchesAbove
+    );
+  }, [
+    status,
+    convertResult,
+    rootConfig.stages,
+    mismatchCount,
+    rootConfig.autoApplyMappingWhenMismatchesAtMost,
+    rootConfig.showErrorWhenMismatchesAbove
+  ]);
+  const appliedRef = useRef(null);
+  useEffect(() => {
+    const autoApply = rootConfig.autoApplyMappingWhenMismatchesAtMost;
+    if (convertResult != null && autoApply !== "never" && typeof autoApply === "number" && mismatchCount <= autoApply && appliedRef.current !== convertResult) {
+      appliedRef.current = convertResult;
+      convertResult.applyMapping();
+    }
+    if (convertResult == null) {
+      appliedRef.current = null;
+    }
+  }, [convertResult, mismatchCount, rootConfig.autoApplyMappingWhenMismatchesAtMost]);
+  return useMemo2(
+    () => ({
+      view,
+      status,
+      progressEventTarget,
+      convertResult,
+      mappingErrorDetail
+    }),
+    [view, status, progressEventTarget, convertResult, mappingErrorDetail]
+  );
+}
+
+// src/hooks/useRawFilePicker/useRawFilePicker.ts
+import { useCallback, useRef as useRef2, useState } from "react";
+import { useImporter } from "@cristianmpx/react-import-sheet-headless";
+function useRawFilePicker(options = {}) {
+  const { accept } = options;
+  const { processFile } = useImporter();
+  const [isDragging, setIsDragging] = useState(false);
+  const rootRef = useRef2(null);
+  const inputRef = useRef2(null);
+  const setRootRef = useCallback((el) => {
+    rootRef.current = el;
+  }, []);
+  const setInputRef = useCallback((el) => {
+    inputRef.current = el;
+  }, []);
+  const handleDrop = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setIsDragging(false);
+      const file = e.dataTransfer?.files?.[0];
+      if (file) processFile(file);
+    },
+    [processFile]
+  );
+  const handleDragOver = useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    e.dataTransfer.dropEffect = "copy";
+    setIsDragging(true);
+  }, []);
+  const handleDragLeave = useCallback((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (!rootRef.current?.contains(e.relatedTarget)) {
+      setIsDragging(false);
+    }
+  }, []);
+  const handleChange = useCallback(
+    (e) => {
+      const file = e.target.files?.[0];
+      if (file) processFile(file);
+      e.target.value = "";
+    },
+    [processFile]
+  );
+  const handleRootClick = useCallback((e) => {
+    if (e.target !== inputRef.current) {
+      inputRef.current?.click();
+    }
+  }, []);
+  const getRootProps = useCallback(
+    (opts) => ({
+      ref: setRootRef,
+      onClick: handleRootClick,
+      onDragOver: handleDragOver,
+      onDragLeave: handleDragLeave,
+      onDrop: handleDrop,
+      role: "button",
+      "aria-label": "Drop zone for file import",
+      "data-dropzone": "true",
+      className: opts?.className,
+      style: opts?.style
+    }),
+    [handleRootClick, handleDragOver, handleDragLeave, handleDrop, setRootRef]
+  );
+  const getInputProps = useCallback(
+    () => ({
+      ref: setInputRef,
+      type: "file",
+      onChange: handleChange,
+      accept: accept ?? ".xlsx,.xls,.csv",
+      tabIndex: -1,
+      "aria-label": "Select file to import"
+    }),
+    [handleChange, setInputRef, accept]
+  );
+  return {
+    isDragging,
+    getRootProps,
+    getInputProps
+  };
+}
+
+// src/hooks/useRawMappingTable/useRawMappingTable.ts
+import { useMemo as useMemo3 } from "react";
+import { useConvert as useConvert2 } from "@cristianmpx/react-import-sheet-headless";
+function useRawMappingTable() {
+  const { convertResult } = useConvert2();
+  const rows = useMemo3(() => {
+    if (!convertResult?.headersFound?.length) return [];
+    return convertResult.headersFound.map((headerOriginal, columnIndex) => ({
+      headerOriginal,
+      columnIndex
+    }));
+  }, [convertResult]);
+  const hasMappingData = convertResult != null && rows.length > 0;
+  return useMemo3(
+    () => ({
+      rows,
+      hasMappingData
+    }),
+    [rows, hasMappingData]
+  );
+}
+
+// src/hooks/useRawMappingRow/useRawMappingRow.ts
+import { useContext as useContext2, useCallback as useCallback2, useMemo as useMemo4 } from "react";
+import { useConvert as useConvert3 } from "@cristianmpx/react-import-sheet-headless";
+
+// src/shared/types/input-phase.ts
+function getLayoutFieldOptions(layout) {
+  if (!layout?.fields) return [];
+  return Object.entries(layout.fields).map(([id, field]) => ({
+    id,
+    label: field.name ?? id
+  }));
+}
+
+// src/hooks/useRawMappingRow/useRawMappingRow.ts
+function useRawMappingRow(options) {
+  const { rowContext } = options;
+  const { headerOriginal, columnIndex } = rowContext;
+  const layout = useContext2(LayoutContext);
+  const { convertResult } = useConvert3();
+  const optionsList = useMemo4(() => getLayoutFieldOptions(layout), [layout]);
+  const usedByOtherColumns = useMemo4(() => {
+    if (!convertResult?.headerToFieldMap) return /* @__PURE__ */ new Set();
+    return new Set(
+      Object.entries(convertResult.headerToFieldMap).filter(([header]) => header !== headerOriginal).map(([, fieldId]) => fieldId).filter(Boolean)
+    );
+  }, [convertResult?.headerToFieldMap, headerOriginal]);
+  const mappingOptions = useMemo4(
+    () => optionsList.map((opt) => ({
+      ...opt,
+      disabled: usedByOtherColumns.has(opt.id)
+    })),
+    [optionsList, usedByOtherColumns]
+  );
+  const value = useMemo4(() => {
+    if (!convertResult?.headerToFieldMap) return null;
+    return convertResult.headerToFieldMap[headerOriginal] ?? null;
+  }, [convertResult, headerOriginal]);
+  const onChange = useCallback2(
+    (fieldId) => {
+      convertResult?.renameColumn(headerOriginal, fieldId);
+    },
+    [convertResult, headerOriginal]
+  );
+  const mappingStatus = useMemo4(() => {
+    if (value == null || value === "") return "unmapped";
+    const mismatches = convertResult?.mismatches ?? [];
+    const stillMismatch = mismatches.some((m) => m.expected === value);
+    return stillMismatch ? "invalid" : "valid";
+  }, [value, convertResult?.mismatches]);
+  return useMemo4(
+    () => ({
+      headerOriginal,
+      columnIndex,
+      options: mappingOptions,
+      value,
+      onChange,
+      mappingStatus
+    }),
+    [headerOriginal, columnIndex, mappingOptions, value, onChange, mappingStatus]
+  );
+}
+
+// src/hooks/useRawMappingSuggest/useRawMappingSuggest.ts
+import { useContext as useContext3, useMemo as useMemo5 } from "react";
+
+// src/shared/utils/fuzzy-similarity.ts
+function normalize(s) {
+  return s.trim().toLowerCase().normalize("NFD").replace(/\p{Diacritic}/gu, "");
+}
+function levenshtein(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    prev = curr;
+  }
+  return prev[b.length];
+}
+function getSimilarity(s1, s2) {
+  const a = normalize(s1);
+  const b = normalize(s2);
+  if (a.length === 0 && b.length === 0) return 1;
+  const longer = a.length >= b.length ? a : b;
+  const shorter = a.length < b.length ? a : b;
+  if (longer.length === 0) return 1;
+  const distance = levenshtein(longer, shorter);
+  return (longer.length - distance) / longer.length;
+}
+
+// src/hooks/useRawMappingSuggest/useRawMappingSuggest.ts
+var DEFAULT_FUZZY_THRESHOLD = 0.8;
+function useRawMappingSuggest(options) {
+  const { columnContext } = options;
+  const { fileHeader } = columnContext;
+  const rootConfig = useContext3(RootConfigContext);
+  const layout = useContext3(LayoutContext);
+  return useMemo5(() => {
+    if (rootConfig.fuzzyMatch === false) {
+      return { matchScore: 0, suggestedFieldId: null, suggestedFieldLabel: null };
+    }
+    const optionsList = getLayoutFieldOptions(layout);
+    let bestScore = 0;
+    let bestId = null;
+    let bestLabel = null;
+    for (const opt of optionsList) {
+      const score = getSimilarity(fileHeader, opt.label);
+      if (score >= DEFAULT_FUZZY_THRESHOLD && score > bestScore) {
+        bestScore = score;
+        bestId = opt.id;
+        bestLabel = opt.label;
+      }
+    }
+    const matchScore = Math.round(bestScore * 100);
+    return {
+      matchScore: bestId != null ? matchScore : 0,
+      suggestedFieldId: bestId,
+      suggestedFieldLabel: bestLabel
+    };
+  }, [rootConfig.fuzzyMatch, layout, fileHeader]);
+}
+
+// src/hooks/useRawImportAction/useRawImportAction.ts
+import { useCallback as useCallback3, useMemo as useMemo6 } from "react";
+import { useConvert as useConvert4, useImporterStatus as useImporterStatus2 } from "@cristianmpx/react-import-sheet-headless";
+function useRawImportAction() {
+  const { convertResult } = useConvert4();
+  const { status } = useImporterStatus2();
+  const isProcessing = status === "loading" || status === "parsing" || status === "validating" || status === "transforming";
+  const disabled = useMemo6(() => {
+    if (isProcessing) return true;
+    if (!convertResult) return true;
+    if (typeof convertResult.layoutError === "boolean") {
+      return convertResult.layoutError === true;
+    }
+    return convertResult.mismatches.length > 0;
+  }, [isProcessing, convertResult]);
+  const runImport = useCallback3(() => {
+    if (convertResult && !disabled) {
+      convertResult.applyMapping();
+    }
+  }, [convertResult, disabled]);
+  return useMemo6(
+    () => ({
+      disabled,
+      runImport
+    }),
+    [disabled, runImport]
+  );
+}
+
+// src/hooks/useRawProgress/useRawProgress.ts
+import { useEffect as useEffect2, useRef as useRef3 } from "react";
+import {
+  useImporterStatus as useImporterStatus3,
+  IMPORTER_PROGRESS_EVENT,
+  IMPORTER_ABORTED_EVENT
+} from "@cristianmpx/react-import-sheet-headless";
+function useRawProgress(options = {}) {
+  const { onProgress } = options;
+  const { progressEventTarget } = useImporterStatus3();
+  const progressRef = useRef3(null);
+  useEffect2(() => {
+    const target = progressEventTarget;
+    const handleProgress = (e) => {
+      const detail = e.detail;
+      progressRef.current = detail ?? null;
+      onProgress?.(detail);
+    };
+    const handleAborted = () => {
+      progressRef.current = null;
+    };
+    target.addEventListener(IMPORTER_PROGRESS_EVENT, handleProgress);
+    target.addEventListener(IMPORTER_ABORTED_EVENT, handleAborted);
+    return () => {
+      target.removeEventListener(IMPORTER_PROGRESS_EVENT, handleProgress);
+      target.removeEventListener(IMPORTER_ABORTED_EVENT, handleAborted);
+    };
+  }, [progressEventTarget, onProgress]);
+  return {
+    progressRef,
+    ...onProgress ? { onProgress } : {}
+  };
+}
+
+// src/hooks/useRawStatus/useRawStatus.ts
+import { useMemo as useMemo7 } from "react";
+import { useImporterStatus as useImporterStatus4 } from "@cristianmpx/react-import-sheet-headless";
+function useRawStatus() {
+  const { status } = useImporterStatus4();
+  return useMemo7(
+    () => ({
+      status,
+      // When headless exposes lastError / errorDetail, wire it here for status === 'error'
+      errorDetail: void 0
+    }),
+    [status]
+  );
+}
+
+// src/hooks/useRawAbort/useRawAbort.ts
+import { useImporter as useImporter2 } from "@cristianmpx/react-import-sheet-headless";
+function useRawAbort() {
+  const { abort } = useImporter2();
+  return { abort };
+}
+
+// src/hooks/useRawDataTable/useRawDataTable.ts
+import { useContext as useContext4, useCallback as useCallback4, useMemo as useMemo8, useState as useState2 } from "react";
+import { useSheetData } from "@cristianmpx/react-import-sheet-headless";
+function useRawDataTable(options = {}) {
+  const { onNavigateToIndex } = options;
+  const layout = useContext4(LayoutContext);
+  const rootConfig = useContext4(RootConfigContext);
+  const { sheet } = useSheetData();
+  const [focusedRowIndex, setFocusedRowIndex] = useState2(null);
+  const [focusedCellKey, setFocusedCellKey] = useState2(null);
+  const [pendingCell, setPendingCell] = useState2(
+    null
+  );
+  const headerIds = useMemo8(() => {
+    if (!layout?.fields) return [];
+    return Object.keys(layout.fields);
+  }, [layout?.fields]);
+  const totalRowCount = sheet?.rows?.length ?? 0;
+  const editingEnabled = rootConfig.editingEnabled ?? true;
+  const headers = useMemo8(
+    () => getLayoutFieldOptions(layout).map((o) => ({ id: o.id, label: o.label })),
+    [layout]
+  );
+  const setFocused = useCallback4((rowIndex, cellKey) => {
+    setFocusedRowIndex(rowIndex);
+    setFocusedCellKey(cellKey);
+  }, []);
+  const getKeyDownHandler = useCallback4(
+    (rowIndex, cellKey) => {
+      return (e) => {
+        const key = e.key;
+        if (key !== "ArrowLeft" && key !== "ArrowRight" && key !== "ArrowUp" && key !== "ArrowDown") {
+          return;
+        }
+        e.preventDefault();
+        const colIdx = headerIds.indexOf(cellKey);
+        if (colIdx === -1) return;
+        if (key === "ArrowLeft" && colIdx > 0) {
+          setFocused(rowIndex, headerIds[colIdx - 1] ?? null);
+          return;
+        }
+        if (key === "ArrowRight" && colIdx < headerIds.length - 1) {
+          setFocused(rowIndex, headerIds[colIdx + 1] ?? null);
+          return;
+        }
+        if (key === "ArrowUp" && rowIndex > 0) {
+          const nextIndex = rowIndex - 1;
+          setFocused(nextIndex, cellKey);
+          onNavigateToIndex?.(nextIndex);
+          return;
+        }
+        if (key === "ArrowDown" && rowIndex < totalRowCount - 1) {
+          const nextIndex = rowIndex + 1;
+          setFocused(nextIndex, cellKey);
+          onNavigateToIndex?.(nextIndex);
+          return;
+        }
+      };
+    },
+    [headerIds, totalRowCount, setFocused, onNavigateToIndex]
+  );
+  const value = useMemo8(
+    () => ({
+      editingEnabled,
+      headerIds,
+      totalRowCount,
+      focusedRowIndex,
+      focusedCellKey,
+      setFocused,
+      pendingCell,
+      setPendingCell,
+      getKeyDownHandler,
+      onNavigateToIndex
+    }),
+    [
+      editingEnabled,
+      headerIds,
+      totalRowCount,
+      focusedRowIndex,
+      focusedCellKey,
+      setFocused,
+      pendingCell,
+      getKeyDownHandler,
+      onNavigateToIndex
+    ]
+  );
+  return useMemo8(
+    () => ({
+      ...value,
+      headers
+    }),
+    [value, headers]
+  );
+}
+
+// src/hooks/useRawDataTable/DataTableContext.tsx
+import { createContext as createContext2 } from "react";
+var defaultContext = {
+  editingEnabled: true,
+  headerIds: [],
+  totalRowCount: 0,
+  focusedRowIndex: null,
+  focusedCellKey: null,
+  setFocused: () => {
+  },
+  pendingCell: null,
+  setPendingCell: () => {
+  },
+  getKeyDownHandler: () => () => {
+  }
+};
+var DataTableContext = createContext2(defaultContext);
+
+// src/hooks/useRawDataTable/RawDataTableProvider.tsx
+import { useMemo as useMemo9 } from "react";
+import { useSheetEditor } from "@cristianmpx/react-import-sheet-headless";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function RawDataTableProvider({ children, onNavigateToIndex }) {
+  const editor = useSheetEditor();
+  const tableValue = useRawDataTable({ onNavigateToIndex });
+  const canEdit = editor.canEdit !== false;
+  const effectiveEditing = tableValue.editingEnabled && canEdit;
+  const value = useMemo9(
+    () => ({ ...tableValue, editingEnabled: effectiveEditing }),
+    [tableValue, effectiveEditing]
+  );
+  return /* @__PURE__ */ jsx2(DataTableContext.Provider, { value, children });
+}
+
+// src/hooks/useRawTableHead/useRawTableHead.ts
+import { useContext as useContext5, useMemo as useMemo10 } from "react";
+function useRawTableHead() {
+  const layout = useContext5(LayoutContext);
+  const headers = useMemo10(
+    () => getLayoutFieldOptions(layout).map((o) => ({ id: o.id, label: o.label })),
+    [layout]
+  );
+  return useMemo10(() => ({ headers }), [headers]);
+}
+
+// src/hooks/useRawTableBody/useRawTableBody.ts
+import { useCallback as useCallback5, useMemo as useMemo11 } from "react";
+import { useSheetData as useSheetData2 } from "@cristianmpx/react-import-sheet-headless";
+function useRawTableBody() {
+  const { sheet } = useSheetData2();
+  const totalRowCount = sheet?.rows?.length ?? 0;
+  const isPlaceholder = useCallback5(
+    (index) => index < 0 || index >= totalRowCount,
+    [totalRowCount]
+  );
+  const getRowProps = useCallback5(
+    (options) => {
+      const { index, style } = options;
+      const row = sheet?.rows?.[index];
+      const hasErrors = (row?.errors?.length ?? 0) > 0;
+      const placeholder = isPlaceholder(index);
+      return {
+        "data-row-index": index,
+        "data-has-errors": hasErrors || void 0,
+        "data-placeholder": placeholder || void 0,
+        style,
+        role: "row",
+        "aria-rowindex": index + 1
+      };
+    },
+    [sheet?.rows, isPlaceholder]
+  );
+  return useMemo11(
+    () => ({
+      totalRowCount,
+      getRowProps,
+      isPlaceholder
+    }),
+    [totalRowCount, getRowProps, isPlaceholder]
+  );
+}
+
+// src/hooks/useRawTableRow/useRawTableRow.ts
+import { useCallback as useCallback6, useMemo as useMemo12 } from "react";
+import { useSheetData as useSheetData3 } from "@cristianmpx/react-import-sheet-headless";
+function useRawTableRow(options) {
+  const { index, style } = options;
+  const { sheet } = useSheetData3();
+  const { getRowProps: bodyGetRowProps, isPlaceholder } = useRawTableBody();
+  const row = useMemo12(() => {
+    if (options.row !== void 0) return options.row;
+    if (!sheet?.rows) return null;
+    if (isPlaceholder(index)) return null;
+    return sheet.rows[index] ?? null;
+  }, [options.row, sheet?.rows, index, isPlaceholder]);
+  const getRowProps = useCallback6(
+    (merge) => {
+      const base = bodyGetRowProps({ index, style });
+      return {
+        ...base,
+        ...merge?.className != null && { className: merge.className },
+        ...merge?.style != null && { style: { ...base.style, ...merge.style } }
+      };
+    },
+    [bodyGetRowProps, index, style]
+  );
+  const rowErrors = row?.errors ?? [];
+  return useMemo12(
+    () => ({
+      getRowProps,
+      row: row ?? void 0,
+      rowErrors
+    }),
+    [getRowProps, row, rowErrors]
+  );
+}
+
+// src/hooks/useRawCell/useRawCell.ts
+import { useContext as useContext6, useCallback as useCallback7, useMemo as useMemo13, useRef as useRef4 } from "react";
+import { useSheetData as useSheetData4, useSheetEditor as useSheetEditor2 } from "@cristianmpx/react-import-sheet-headless";
+function useRawCell(options) {
+  const { rowIndex, fieldId } = options;
+  const { sheet } = useSheetData4();
+  const { editCell: editorEditCell } = useSheetEditor2();
+  const ctx = useContext6(DataTableContext);
+  const row = sheet?.rows?.[rowIndex];
+  const cell = useMemo13(() => row?.cells?.find((c) => c.key === fieldId), [row?.cells, fieldId]);
+  const value = cell?.value;
+  const errors = cell?.errors ?? [];
+  const isPending = ctx.pendingCell?.rowIndex === rowIndex && ctx.pendingCell?.fieldId === fieldId;
+  const isFocused = ctx.focusedRowIndex === rowIndex && ctx.focusedCellKey === fieldId;
+  const isEditing = (ctx.editingEnabled ?? true) && isFocused;
+  const editCell = useCallback7(
+    (newValue) => {
+      if (!(ctx.editingEnabled ?? true)) return;
+      ctx.setPendingCell({ rowIndex, fieldId });
+      const p = editorEditCell({
+        rowIndex,
+        cellKey: fieldId,
+        value: newValue
+      });
+      if (p && typeof p.then === "function") {
+        p.then(
+          () => ctx.setPendingCell(null),
+          () => ctx.setPendingCell(null)
+        );
+      } else {
+        ctx.setPendingCell(null);
+      }
+    },
+    [ctx.editingEnabled, ctx.setPendingCell, editorEditCell, rowIndex, fieldId]
+  );
+  const localValueRef = useRef4(value);
+  const displayValue = isPending ? localValueRef.current : value;
+  if (!isPending) localValueRef.current = value;
+  const getCellProps = useCallback7(
+    (opts) => {
+      const base = {
+        role: "gridcell",
+        tabIndex: isFocused ? 0 : -1,
+        "data-pending": isPending ? "true" : "false",
+        "data-has-error": errors.length > 0 ? "true" : void 0,
+        "aria-invalid": errors.length > 0 ? "true" : void 0,
+        "data-cell-key": fieldId,
+        "data-row-index": rowIndex,
+        onKeyDown: ctx.getKeyDownHandler(rowIndex, fieldId),
+        onFocus: () => ctx.setFocused(rowIndex, fieldId),
+        ...opts?.className != null && { className: opts.className },
+        ...opts?.style != null && { style: opts.style }
+      };
+      return base;
+    },
+    [isFocused, isPending, errors.length, fieldId, rowIndex, ctx.getKeyDownHandler, ctx.setFocused]
+  );
+  const getEditInputProps = useCallback7(() => {
+    return {
+      value: displayValue ?? "",
+      onChange: (e) => {
+        const v = e.target.value;
+        localValueRef.current = v;
+        editCell(v);
+      },
+      onBlur: () => {
+      },
+      "aria-label": fieldId
+    };
+  }, [displayValue, fieldId, editCell]);
+  const getErrorProps = useCallback7(
+    () => ({
+      role: "alert",
+      "aria-live": "polite",
+      "aria-atomic": true,
+      "data-ris-ui": "raw-cell-error-message"
+    }),
+    []
+  );
+  return useMemo13(
+    () => ({
+      value: displayValue,
+      errors,
+      isPending,
+      isEditing,
+      getCellProps,
+      getEditInputProps,
+      getErrorProps,
+      editCell
+    }),
+    [
+      displayValue,
+      errors,
+      isPending,
+      isEditing,
+      getCellProps,
+      getEditInputProps,
+      getErrorProps,
+      editCell
+    ]
+  );
+}
+
+// src/hooks/useRawErrorBadge/useRawErrorBadge.ts
+import { useMemo as useMemo14 } from "react";
+function useRawErrorBadge(options) {
+  const { error, translateError } = options;
+  const message = useMemo14(() => {
+    if (!error) return "";
+    if (translateError) return translateError(error.code, error.params);
+    return error.message ?? error.code;
+  }, [error, translateError]);
+  return useMemo14(
+    () => ({
+      error,
+      message,
+      translateError
+    }),
+    [error, message, translateError]
+  );
+}
+
+// src/hooks/useRawPagination/useRawPagination.ts
+import { useContext as useContext7 } from "react";
+
+// src/hooks/useRawPagination/ViewPhaseContext.tsx
+import { createContext as createContext3 } from "react";
+var ViewPhaseContext = createContext3(null);
+
+// src/hooks/useRawPagination/useRawPagination.ts
+var VIEW_PHASE_ERROR = "useRawPagination must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawPagination() {
+  const ctx = useContext7(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR);
+  return {
+    page: ctx.page,
+    pageSize: ctx.pageSize,
+    totalRows: ctx.totalRows,
+    visibleSheetIndices: ctx.visibleSheetIndices,
+    setPage: ctx.setPage,
+    setPageSize: ctx.setPageSize
+  };
+}
+
+// src/hooks/useRawPagination/useRawSubmitStatus.ts
+import { useContext as useContext8 } from "react";
+var VIEW_PHASE_ERROR2 = "useRawSubmitStatus must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawSubmitStatus() {
+  const ctx = useContext8(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR2);
+  return {
+    isSubmitted: ctx.isSubmitted,
+    markSubmitted: ctx.markSubmitted,
+    canSubmit: ctx.canSubmit
+  };
+}
+
+// src/hooks/useRawPagination/RawViewPhaseProvider.tsx
+import { useCallback as useCallback8, useContext as useContext9, useMemo as useMemo15, useState as useState3 } from "react";
+import { useSheetView, useSheetData as useSheetData5, useImporter as useImporter3 } from "@cristianmpx/react-import-sheet-headless";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function hasRowErrors(row) {
+  if (!row) return false;
+  if ((row.errors?.length ?? 0) > 0) return true;
+  return row.cells?.some((c) => (c?.errors?.length ?? 0) > 0) ?? false;
+}
+function escapeCsvCell(value) {
+  const s = value == null ? "" : String(value);
+  if (/[",\r\n]/.test(s)) return `"${s.replace(/"/g, '""')}"`;
+  return s;
+}
+function buildErrorsOnlyCSV(options, rowsWithErrors) {
+  const headerLine = options.map((o) => o.label).map(escapeCsvCell).join(",");
+  const dataLines = rowsWithErrors.map(
+    (row) => options.map((o) => row.cells?.find((c) => c.key === o.id)).map((c) => escapeCsvCell(c?.value)).join(",")
+  );
+  return [headerLine, ...dataLines].join("\r\n");
+}
+function buildErrorsOnlyJSON(rowsWithErrors) {
+  const arr = rowsWithErrors.map((row) => {
+    const obj = {};
+    (row.cells ?? []).forEach((c) => {
+      obj[c.key] = c.value;
+    });
+    return obj;
+  });
+  return JSON.stringify(arr, null, 2);
+}
+function downloadBlob(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+function RawViewPhaseProvider({
+  children,
+  initialPage = 1,
+  defaultPageSize = 25,
+  defaultFilterMode = "all"
+}) {
+  const [filterMode, setFilterMode] = useState3(defaultFilterMode);
+  const [pageSize, setPageSize] = useState3(defaultPageSize);
+  const layout = useContext9(LayoutContext);
+  const { sheet } = useSheetData5();
+  const { submitDone, submit, canSubmit } = useImporter3();
+  const view = useSheetView({
+    page: initialPage,
+    defaultPageSize: pageSize,
+    filterMode
+  });
+  const layoutOptions = useMemo15(() => getLayoutFieldOptions(layout), [layout]);
+  const rowsWithErrors = useMemo15(
+    () => (sheet?.rows ?? []).filter((row) => hasRowErrors(row)),
+    [sheet?.rows]
+  );
+  const downloadCSVErrorsOnly = useCallback8(
+    (opts) => {
+      if (rowsWithErrors.length === 0) return;
+      const csv = buildErrorsOnlyCSV(layoutOptions, rowsWithErrors);
+      const blob = new Blob([csv], { type: "text/csv;charset=utf-8" });
+      downloadBlob(blob, opts?.filename ?? "errors-only.csv");
+    },
+    [layoutOptions, rowsWithErrors]
+  );
+  const downloadJSONErrorsOnly = useCallback8(
+    (opts) => {
+      if (rowsWithErrors.length === 0) return;
+      const json = buildErrorsOnlyJSON(rowsWithErrors);
+      const blob = new Blob([json], { type: "application/json;charset=utf-8" });
+      downloadBlob(blob, opts?.filename ?? "errors-only.json");
+    },
+    [rowsWithErrors]
+  );
+  const visibleSheetIndices = useMemo15(() => {
+    const rows = sheet?.rows ?? [];
+    return view.paginatedRows.map((row) => rows.indexOf(row)).filter((i) => i >= 0);
+  }, [sheet?.rows, view.paginatedRows]);
+  const value = useMemo15(
+    () => ({
+      page: view.page,
+      setPage: view.setPage,
+      pageSize: view.pageSize,
+      setPageSize,
+      totalRows: view.totalRows,
+      visibleSheetIndices,
+      filterMode,
+      setFilterMode,
+      downloadCSV: view.downloadCSV,
+      downloadJSON: view.downloadJSON,
+      downloadCSVErrorsOnly,
+      downloadJSONErrorsOnly,
+      hasRowsWithErrors: rowsWithErrors.length > 0,
+      hasRecoverableSession: view.hasRecoverableSession,
+      recoverSession: view.recoverSession,
+      clearSession: view.clearPersistedState,
+      isSubmitted: submitDone ?? false,
+      markSubmitted: submit ?? (() => {
+      }),
+      canSubmit: canSubmit ?? false
+    }),
+    [
+      view.page,
+      view.setPage,
+      view.pageSize,
+      view.totalRows,
+      visibleSheetIndices,
+      view.downloadCSV,
+      view.downloadJSON,
+      view.hasRecoverableSession,
+      view.recoverSession,
+      view.clearPersistedState,
+      filterMode,
+      pageSize,
+      downloadCSVErrorsOnly,
+      downloadJSONErrorsOnly,
+      rowsWithErrors.length,
+      submitDone,
+      submit,
+      canSubmit
+    ]
+  );
+  return /* @__PURE__ */ jsx3(ViewPhaseContext.Provider, { value, children });
+}
+
+// src/hooks/useRawRemoveRow/useRawRemoveRow.ts
+import { useCallback as useCallback9 } from "react";
+import { useSheetEditor as useSheetEditor3 } from "@cristianmpx/react-import-sheet-headless";
+function useRawRemoveRow() {
+  const editor = useSheetEditor3();
+  const removeRowFn = editor.removeRow;
+  const canRemoveRow = typeof removeRowFn === "function";
+  const removeRow = useCallback9(
+    (rowIndex) => {
+      if (typeof removeRowFn === "function") {
+        removeRowFn(rowIndex);
+      }
+    },
+    [removeRowFn]
+  );
+  return { removeRow, canRemoveRow };
+}
+
+// src/hooks/useRawEditLog/useRawEditLog.ts
+import { useSheetEditor as useSheetEditor4 } from "@cristianmpx/react-import-sheet-headless";
+function useRawEditLog() {
+  const editor = useSheetEditor4();
+  const entries = editor.changeLog ?? [];
+  const changeLogAsText = editor.changeLogAsText ?? "";
+  return {
+    entries,
+    changeLogAsText,
+    clearLog: () => {
+    }
+  };
+}
+
+// src/hooks/useRawEditLog/EditLogContext.tsx
+import { createContext as createContext4 } from "react";
+var EditLogContext = createContext4(null);
+
+// src/hooks/useRawEditLog/RawEditLogProvider.tsx
+import { useCallback as useCallback10, useMemo as useMemo16, useState as useState4 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function RawEditLogProvider({ children }) {
+  const [entries, setEntries] = useState4([]);
+  const appendCellUpdate = useCallback10(
+    (params) => {
+      setEntries((prev) => [
+        ...prev,
+        {
+          type: "cell_update",
+          ...params,
+          timestamp: Date.now()
+        }
+      ]);
+    },
+    []
+  );
+  const appendRowRemoved = useCallback10((params) => {
+    setEntries((prev) => [
+      ...prev,
+      {
+        type: "row_removed",
+        ...params,
+        timestamp: Date.now()
+      }
+    ]);
+  }, []);
+  const clearLog = useCallback10(() => setEntries([]), []);
+  const value = useMemo16(
+    () => ({ entries, appendCellUpdate, appendRowRemoved, clearLog }),
+    [entries, appendCellUpdate, appendRowRemoved, clearLog]
+  );
+  return /* @__PURE__ */ jsx4(EditLogContext.Provider, { value, children });
+}
+
+// src/hooks/useRawFilterToggle/useRawFilterToggle.ts
+import { useContext as useContext10 } from "react";
+var VIEW_PHASE_ERROR3 = "useRawFilterToggle must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawFilterToggle() {
+  const ctx = useContext10(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR3);
+  return {
+    filterMode: ctx.filterMode,
+    setFilterMode: ctx.setFilterMode
+  };
+}
+
+// src/hooks/useRawExport/useRawExport.ts
+import { useContext as useContext11 } from "react";
+var VIEW_PHASE_ERROR4 = "useRawExport must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawExport() {
+  const ctx = useContext11(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR4);
+  return {
+    downloadCSV: ctx.downloadCSV,
+    downloadJSON: ctx.downloadJSON,
+    downloadCSVErrorsOnly: ctx.downloadCSVErrorsOnly,
+    downloadJSONErrorsOnly: ctx.downloadJSONErrorsOnly,
+    hasRowsWithErrors: ctx.hasRowsWithErrors
+  };
+}
+
+// src/hooks/useRawPersistence/useRawPersistence.ts
+import { useContext as useContext12 } from "react";
+var VIEW_PHASE_ERROR5 = "useRawPersistence must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawPersistence() {
+  const ctx = useContext12(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR5);
+  return {
+    hasRecoverableSession: ctx.hasRecoverableSession,
+    recoverSession: ctx.recoverSession,
+    clearSession: ctx.clearSession
+  };
+}
+
+// src/hooks/useImporterMetrics/useImporterMetrics.ts
+import { useImporter as useImporter4 } from "@cristianmpx/react-import-sheet-headless";
+function useImporterMetrics() {
+  const { metrics } = useImporter4();
+  return metrics;
+}
+
+// src/components/RawImporterRoot/RawImporterRoot.tsx
+import { forwardRef } from "react";
+import { ImporterProvider } from "@cristianmpx/react-import-sheet-headless";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var RawImporterRoot = forwardRef(
+  function RawImporterRoot2({ children, className, style, ...options }, ref) {
+    const { providerProps, rootConfig } = useRawImporterRoot(options);
+    return /* @__PURE__ */ jsx5(ImporterProvider, { ...providerProps, children: /* @__PURE__ */ jsx5(LayoutProvider, { layout: providerProps.layout ?? null, children: /* @__PURE__ */ jsx5(RootConfigProvider, { rootConfig, children: /* @__PURE__ */ jsx5("div", { ref, className, style, "data-ris-ui": "raw-importer-root", children }) }) }) });
+  }
+);
+
+// src/components/RawStatusGuard/RawStatusGuard.tsx
+import { forwardRef as forwardRef2 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var RawStatusGuard = forwardRef2(
+  function RawStatusGuard2({ renderIdle, renderMapping, renderProcess, renderResult, renderError, className, style }, ref) {
+    const data = useStatusView();
+    const { view } = data;
+    let content = null;
+    if (view === "idle" && renderIdle) content = renderIdle(data);
+    else if (view === "mapping" && renderMapping) content = renderMapping(data);
+    else if (view === "process" && renderProcess) content = renderProcess(data);
+    else if (view === "result" && renderResult) content = renderResult(data);
+    else if (view === "error" && renderError) content = renderError(data);
+    return /* @__PURE__ */ jsx6("div", { ref, className, style, "data-ris-ui": "raw-status-guard", children: content });
+  }
+);
+
+// src/components/RawFilePicker/RawFilePicker.tsx
+import { forwardRef as forwardRef3, useCallback as useCallback11 } from "react";
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var RawFilePicker = forwardRef3(function RawFilePicker2({ children, className, style }, ref) {
+  const state = useRawFilePicker();
+  const rootProps = state.getRootProps({ className, style });
+  const { ref: rootRef, ...restRootProps } = rootProps;
+  const setRef = useCallback11(
+    (el) => {
+      rootRef(el);
+      if (typeof ref === "function") ref(el);
+      else if (ref) ref.current = el;
+    },
+    [rootRef, ref]
+  );
+  return /* @__PURE__ */ jsxs("div", { ref: setRef, ...restRootProps, "data-ris-ui": "raw-file-picker", children: [
+    /* @__PURE__ */ jsx7("input", { ...state.getInputProps() }),
+    children(state)
+  ] });
+});
+
+// src/components/RawMappingTable/RawMappingTable.tsx
+import { forwardRef as forwardRef4 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var RawMappingTable = forwardRef4(
+  function RawMappingTable2({ children, className, style }, ref) {
+    const state = useRawMappingTable();
+    return /* @__PURE__ */ jsx8("div", { ref, className, style, "data-ris-ui": "raw-mapping-table", children: children(state) });
+  }
+);
+
+// src/components/RawMappingRow/RawMappingRow.tsx
+import { forwardRef as forwardRef5 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var RawMappingRow = forwardRef5(function RawMappingRow2({ rowContext, children, className, style }, ref) {
+  const state = useRawMappingRow({ rowContext });
+  return /* @__PURE__ */ jsx9("div", { ref, className, style, "data-ris-ui": "raw-mapping-row", children: children(state) });
+});
+
+// src/components/RawMappingSuggest/RawMappingSuggest.tsx
+import { forwardRef as forwardRef6 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var RawMappingSuggest = forwardRef6(
+  function RawMappingSuggest2({ columnContext, children, className, style }, ref) {
+    const state = useRawMappingSuggest({ columnContext });
+    return /* @__PURE__ */ jsx10("div", { ref, className, style, "data-ris-ui": "raw-mapping-suggest", children: children(state) });
+  }
+);
+
+// src/components/RawImportAction/RawImportAction.tsx
+import { forwardRef as forwardRef7 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var RawImportAction = forwardRef7(
+  function RawImportAction2({ children, className, style }, ref) {
+    const state = useRawImportAction();
+    return /* @__PURE__ */ jsx11("div", { ref, className, style, "data-ris-ui": "raw-import-action", children: children(state) });
+  }
+);
+
+// src/components/RawErrorBoundary/RawErrorBoundary.tsx
+import { Component } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var RawErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: null, errorInfo: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error, errorInfo: null };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.setState((s) => ({ ...s, errorInfo }));
+    this.props.onError?.(error, errorInfo);
+  }
+  render() {
+    const { error, errorInfo } = this.state;
+    const { children, fallback } = this.props;
+    if (error) {
+      const content = typeof fallback === "function" ? fallback(error, errorInfo ?? { componentStack: "" }) : fallback;
+      return /* @__PURE__ */ jsx12("div", { "data-ris-ui": "raw-error-boundary", children: content });
+    }
+    return children;
+  }
+};
+
+// src/components/RawProgressDisplay/RawProgressDisplay.tsx
+import { forwardRef as forwardRef8 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var RawProgressDisplay = forwardRef8(
+  function RawProgressDisplay2({ children, className, style, onProgress }, ref) {
+    const state = useRawProgress({ onProgress });
+    return /* @__PURE__ */ jsx13("div", { ref, className, style, "data-ris-ui": "raw-progress-display", children: children(state) });
+  }
+);
+
+// src/components/RawStatusIndicator/RawStatusIndicator.tsx
+import { forwardRef as forwardRef9 } from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var RawStatusIndicator = forwardRef9(
+  function RawStatusIndicator2({ children, className, style }, ref) {
+    const state = useRawStatus();
+    return /* @__PURE__ */ jsx14("div", { ref, className, style, "data-ris-ui": "raw-status-indicator", children: children(state) });
+  }
+);
+
+// src/components/RawAbortButton/RawAbortButton.tsx
+import { forwardRef as forwardRef10, useMemo as useMemo17 } from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+var PROCESSING_STATUSES = ["loading", "parsing", "validating", "transforming"];
+var RawAbortButton = forwardRef10(
+  function RawAbortButton2({ children, className, style, disabled: disabledProp, "aria-label": ariaLabel }, ref) {
+    const { abort } = useRawAbort();
+    const { status } = useRawStatus();
+    const isProcessing = PROCESSING_STATUSES.includes(
+      status
+    );
+    const disabled = disabledProp ?? !isProcessing;
+    const buttonProps = useMemo17(
+      () => ({
+        type: "button",
+        onClick: abort,
+        disabled,
+        className,
+        style,
+        "aria-label": ariaLabel ?? "Cancel import"
+      }),
+      [abort, disabled, className, style, ariaLabel]
+    );
+    return /* @__PURE__ */ jsx15("button", { ref, ...buttonProps, "data-ris-ui": "raw-abort-button", children: children ?? "Cancel" });
+  }
+);
+
+// src/components/RawImporterWorkflow/RawImporterWorkflow.tsx
+import { forwardRef as forwardRef12 } from "react";
+
+// src/components/RawEditLogPanel/RawEditLogPanel.tsx
+import { forwardRef as forwardRef11 } from "react";
+import { jsx as jsx16, jsxs as jsxs2 } from "react/jsx-runtime";
+var RawEditLogPanel = forwardRef11(
+  function RawEditLogPanel2({ className, style, children }, ref) {
+    const { entries, changeLogAsText } = useRawEditLog();
+    if (children) {
+      return /* @__PURE__ */ jsx16(
+        "div",
+        {
+          ref,
+          className,
+          style,
+          "data-ris-ui": "raw-edit-log-panel",
+          role: "log",
+          "aria-label": "Edit log",
+          children: children({ entries, changeLogAsText, clearLog: () => {
+          } })
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        ref,
+        className,
+        style,
+        "data-ris-ui": "raw-edit-log-panel",
+        role: "log",
+        "aria-label": "Edit log",
+        children: [
+          /* @__PURE__ */ jsx16("div", { "data-ris-ui": "raw-edit-log-header", children: /* @__PURE__ */ jsxs2("span", { children: [
+            "Edit log (",
+            entries.length,
+            " changes)"
+          ] }) }),
+          changeLogAsText ? /* @__PURE__ */ jsx16("pre", { "data-ris-ui": "raw-edit-log-list", children: changeLogAsText }) : /* @__PURE__ */ jsx16("ul", { "data-ris-ui": "raw-edit-log-list", children: entries.length === 0 ? /* @__PURE__ */ jsx16("li", { "data-ris-ui": "raw-edit-log-entry", children: "No changes yet." }) : null })
+        ]
+      }
+    );
+  }
+);
+
+// src/components/RawImporterWorkflow/RawImporterWorkflow.tsx
+import { Fragment, jsx as jsx17, jsxs as jsxs3 } from "react/jsx-runtime";
+function BackToFileButton({
+  children = "Choose another file",
+  "aria-label": ariaLabel = "Cancel and choose another file"
+}) {
+  const { abort } = useRawAbort();
+  return /* @__PURE__ */ jsx17(
+    "button",
+    {
+      type: "button",
+      onClick: abort,
+      "aria-label": ariaLabel,
+      "data-ris-ui": "raw-workflow-back-button",
+      children
+    }
+  );
+}
+function DefaultIdle() {
+  return /* @__PURE__ */ jsx17(RawFilePicker, { children: (state) => /* @__PURE__ */ jsx17("span", { "data-ris-ui": "raw-file-picker-prompt", children: state.isDragging ? "Drop file here" : "Click or drop file here" }) });
+}
+function DefaultMapping() {
+  return /* @__PURE__ */ jsx17(RawMappingTable, { children: (state) => state.rows.map((rowContext) => /* @__PURE__ */ jsx17(RawMappingRow, { rowContext, children: (rowState) => /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx17("span", { children: rowState.headerOriginal }),
+    /* @__PURE__ */ jsx17(
+      RawMappingSuggest,
+      {
+        columnContext: {
+          fileHeader: rowContext.headerOriginal,
+          columnIndex: rowContext.columnIndex
+        },
+        children: (suggestState) => suggestState.suggestedFieldId != null ? /* @__PURE__ */ jsxs3("span", { "data-ris-ui": "raw-mapping-suggest-badge", children: [
+          suggestState.suggestedFieldLabel,
+          " (",
+          suggestState.matchScore,
+          "%)"
+        ] }) : null
+      }
+    ),
+    /* @__PURE__ */ jsxs3(
+      "select",
+      {
+        value: rowState.value ?? "",
+        onChange: (e) => rowState.onChange(e.target.value),
+        "aria-label": `Map ${rowState.headerOriginal}`,
+        children: [
+          /* @__PURE__ */ jsx17("option", { value: "", children: "\u2014" }),
+          rowState.options.map((opt) => /* @__PURE__ */ jsx17("option", { value: opt.id, disabled: opt.disabled, children: opt.label }, opt.id))
+        ]
+      }
+    )
+  ] }) }, rowContext.columnIndex)) });
+}
+function DefaultMappingWithAction() {
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx17(DefaultMapping, {}),
+    /* @__PURE__ */ jsxs3("div", { "data-ris-ui": "raw-workflow-mapping-actions", role: "group", children: [
+      /* @__PURE__ */ jsx17(RawImportAction, { children: (state) => /* @__PURE__ */ jsx17(
+        "button",
+        {
+          type: "button",
+          disabled: state.disabled,
+          onClick: state.runImport,
+          "aria-label": "Run import",
+          children: "Import"
+        }
+      ) }),
+      /* @__PURE__ */ jsx17(BackToFileButton, { children: "Choose another file" })
+    ] })
+  ] });
+}
+function DefaultProcess() {
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx17(RawProgressDisplay, { children: (state) => /* @__PURE__ */ jsx17("div", { "data-ris-ui": "raw-progress", children: String(state.progressRef?.current ?? 0) }) }),
+    /* @__PURE__ */ jsx17(RawStatusIndicator, { children: (state) => /* @__PURE__ */ jsx17("div", { "data-ris-ui": "raw-status", children: state.status }) }),
+    /* @__PURE__ */ jsx17(RawAbortButton, {})
+  ] });
+}
+function ResultToolbar({
+  submitLabel = "Submit"
+} = {}) {
+  const filter = useRawFilterToggle();
+  const exportApi = useRawExport();
+  const { isSubmitted, markSubmitted, canSubmit } = useRawSubmitStatus();
+  return /* @__PURE__ */ jsxs3("div", { "data-ris-ui": "raw-workflow-toolbar", role: "toolbar", children: [
+    isSubmitted ? /* @__PURE__ */ jsx17("span", { "data-ris-ui": "raw-workflow-submitted-message", role: "status", children: "Submitted. You can download the file below." }) : null,
+    /* @__PURE__ */ jsx17(BackToFileButton, { "aria-label": "Import another file", children: "New file" }),
+    /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        onClick: () => filter.setFilterMode(filter.filterMode === "all" ? "errors-only" : "all"),
+        "aria-pressed": filter.filterMode === "errors-only",
+        children: filter.filterMode === "all" ? "All" : "Errors only"
+      }
+    ),
+    /* @__PURE__ */ jsx17("button", { type: "button", onClick: () => exportApi.downloadCSV?.(), children: "Export CSV" }),
+    /* @__PURE__ */ jsx17("button", { type: "button", onClick: () => exportApi.downloadJSON?.(), children: "Export JSON" }),
+    exportApi.downloadCSVErrorsOnly != null ? /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        disabled: !exportApi.hasRowsWithErrors || isSubmitted,
+        onClick: () => exportApi.downloadCSVErrorsOnly?.(),
+        title: exportApi.hasRowsWithErrors ? void 0 : "No hay filas con errores",
+        children: "Export CSV (errors only)"
+      }
+    ) : null,
+    exportApi.downloadJSONErrorsOnly != null ? /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        disabled: !exportApi.hasRowsWithErrors || isSubmitted,
+        onClick: () => exportApi.downloadJSONErrorsOnly?.(),
+        title: exportApi.hasRowsWithErrors ? void 0 : "No hay filas con errores",
+        children: "Export JSON (errors only)"
+      }
+    ) : null,
+    !isSubmitted ? /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        disabled: !canSubmit,
+        onClick: () => markSubmitted(),
+        "data-ris-ui": "raw-workflow-submit",
+        "aria-label": typeof submitLabel === "string" ? submitLabel : "Submit",
+        children: submitLabel
+      }
+    ) : null
+  ] });
+}
+function ResultGrid({
+  cellErrorPlacement = "inline"
+}) {
+  const { headers } = useRawTableHead();
+  const { visibleSheetIndices } = useRawPagination();
+  const { canRemoveRow } = useRawRemoveRow();
+  return /* @__PURE__ */ jsxs3("table", { "data-ris-ui": "raw-workflow-grid", role: "grid", children: [
+    /* @__PURE__ */ jsx17("thead", { children: /* @__PURE__ */ jsxs3("tr", { role: "row", children: [
+      headers.map((h) => /* @__PURE__ */ jsx17("th", { scope: "col", role: "columnheader", children: h.label }, h.id)),
+      canRemoveRow ? /* @__PURE__ */ jsx17("th", { scope: "col", role: "columnheader", "data-ris-ui": "raw-workflow-row-actions-header", children: "Actions" }) : null
+    ] }) }),
+    /* @__PURE__ */ jsx17("tbody", { children: visibleSheetIndices.map((sheetIndex) => /* @__PURE__ */ jsx17(
+      ResultRow,
+      {
+        index: sheetIndex,
+        headerIds: headers.map((h) => h.id),
+        showRemoveAction: canRemoveRow,
+        cellErrorPlacement
+      },
+      sheetIndex
+    )) })
+  ] });
+}
+function ResultRow({
+  index,
+  headerIds,
+  showRemoveAction,
+  cellErrorPlacement = "inline"
+}) {
+  const row = useRawTableRow({ index });
+  const { removeRow, canRemoveRow } = useRawRemoveRow();
+  const { isSubmitted } = useRawSubmitStatus();
+  const showDelete = showRemoveAction && canRemoveRow && !isSubmitted;
+  return /* @__PURE__ */ jsxs3("tr", { ...row.getRowProps(), children: [
+    headerIds.map((fieldId) => /* @__PURE__ */ jsx17(
+      ResultCell,
+      {
+        rowIndex: index,
+        fieldId,
+        cellErrorPlacement
+      },
+      fieldId
+    )),
+    showDelete ? /* @__PURE__ */ jsx17("td", { role: "gridcell", "data-ris-ui": "raw-workflow-row-remove-cell", children: /* @__PURE__ */ jsx17(
+      "button",
+      {
+        type: "button",
+        onClick: () => removeRow(index),
+        "aria-label": `Remove row ${index + 1}`,
+        "data-ris-ui": "raw-workflow-remove-row",
+        children: "Remove row"
+      }
+    ) }) : null
+  ] }, index);
+}
+function ResultCell({
+  rowIndex,
+  fieldId,
+  cellErrorPlacement = "inline"
+}) {
+  const cell = useRawCell({ rowIndex, fieldId });
+  const error = cell.errors?.[0];
+  const badge = useRawErrorBadge({
+    error: error ?? null,
+    translateError: void 0
+  });
+  const showError = cellErrorPlacement !== "none" && badge.message;
+  const errorSlot = showError && /* @__PURE__ */ jsx17("span", { ...cell.getErrorProps(), children: badge.message });
+  return /* @__PURE__ */ jsx17("td", { ...cell.getCellProps(), children: cellErrorPlacement === "below" ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+    /* @__PURE__ */ jsx17("div", { "data-ris-ui": "raw-cell-value-line", children: cell.isEditing ? /* @__PURE__ */ jsx17("input", { ...cell.getEditInputProps() }) : /* @__PURE__ */ jsx17("span", { children: String(cell.value ?? "") }) }),
+    showError ? /* @__PURE__ */ jsx17("div", { "data-ris-ui": "raw-cell-error-line", children: errorSlot }) : null
+  ] }) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+    cell.isEditing ? /* @__PURE__ */ jsx17("input", { ...cell.getEditInputProps() }) : /* @__PURE__ */ jsx17("span", { children: String(cell.value ?? "") }),
+    cellErrorPlacement === "inline" && errorSlot
+  ] }) });
+}
+function ResultFooter() {
+  const pagination = useRawPagination();
+  const persistence = useRawPersistence();
+  return /* @__PURE__ */ jsxs3("div", { "data-ris-ui": "raw-workflow-footer", role: "contentinfo", children: [
+    /* @__PURE__ */ jsxs3("div", { "data-ris-ui": "raw-workflow-pagination", children: [
+      /* @__PURE__ */ jsx17(
+        "button",
+        {
+          type: "button",
+          disabled: pagination.page <= 1,
+          onClick: () => pagination.setPage(pagination.page - 1),
+          "aria-label": "Previous page",
+          children: "Previous"
+        }
+      ),
+      /* @__PURE__ */ jsxs3("span", { children: [
+        "Page ",
+        pagination.page,
+        " of",
+        " ",
+        Math.max(1, Math.ceil(pagination.totalRows / pagination.pageSize))
+      ] }),
+      /* @__PURE__ */ jsx17(
+        "button",
+        {
+          type: "button",
+          disabled: pagination.page >= Math.ceil(pagination.totalRows / pagination.pageSize),
+          onClick: () => pagination.setPage(pagination.page + 1),
+          "aria-label": "Next page",
+          children: "Next"
+        }
+      )
+    ] }),
+    persistence.hasRecoverableSession ? /* @__PURE__ */ jsxs3("div", { "data-ris-ui": "raw-workflow-persistence", children: [
+      /* @__PURE__ */ jsx17("button", { type: "button", onClick: persistence.recoverSession, children: "Recover session" }),
+      /* @__PURE__ */ jsx17("button", { type: "button", onClick: persistence.clearSession, children: "Clear" })
+    ] }) : null
+  ] });
+}
+function DefaultResult({
+  submitLabel,
+  cellErrorPlacement = "inline"
+} = {}) {
+  return /* @__PURE__ */ jsxs3(RawViewPhaseProvider, { children: [
+    /* @__PURE__ */ jsx17(ResultToolbar, { submitLabel }),
+    /* @__PURE__ */ jsx17(RawEditLogPanel, {}),
+    /* @__PURE__ */ jsx17(RawDataTableProvider, { children: /* @__PURE__ */ jsx17(ResultGrid, { cellErrorPlacement }) }),
+    /* @__PURE__ */ jsx17(ResultFooter, {})
+  ] });
+}
+function DefaultError({ mappingErrorDetail }) {
+  if (mappingErrorDetail?.code === "TOO_MANY_MISMATCHES") {
+    return /* @__PURE__ */ jsxs3("div", { "data-ris-ui": "raw-workflow-mapping-error", role: "alert", children: [
+      /* @__PURE__ */ jsxs3("p", { children: [
+        "Too many column mismatches (",
+        mappingErrorDetail.mismatchCount,
+        "). Maximum allowed:",
+        " ",
+        mappingErrorDetail.maxAllowed,
+        "."
+      ] }),
+      /* @__PURE__ */ jsx17(BackToFileButton, { children: "Choose another file" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx17(DefaultIdle, {});
+}
+var RawImporterWorkflow = forwardRef12(
+  function RawImporterWorkflow2({
+    className,
+    style,
+    renderIdle,
+    renderMapping,
+    renderProcess,
+    renderResult,
+    renderError,
+    submitLabel,
+    cellErrorPlacement = "inline"
+  }, ref) {
+    const { view, mappingErrorDetail } = useStatusView();
+    let content;
+    switch (view) {
+      case "idle":
+        content = renderIdle ? renderIdle() : /* @__PURE__ */ jsx17(DefaultIdle, {});
+        break;
+      case "mapping":
+        content = renderMapping ? renderMapping() : /* @__PURE__ */ jsx17(DefaultMappingWithAction, {});
+        break;
+      case "process":
+        content = renderProcess ? renderProcess() : /* @__PURE__ */ jsx17(DefaultProcess, {});
+        break;
+      case "result":
+        content = renderResult ? renderResult() : /* @__PURE__ */ jsx17(DefaultResult, { submitLabel, cellErrorPlacement });
+        break;
+      case "error":
+        content = renderError ? renderError({ mappingErrorDetail }) : /* @__PURE__ */ jsx17(DefaultError, { mappingErrorDetail });
+        break;
+      default:
+        content = renderIdle ? renderIdle() : /* @__PURE__ */ jsx17(DefaultIdle, {});
+    }
+    return /* @__PURE__ */ jsx17("div", { ref, className, style, "data-ris-ui": "raw-importer-workflow", children: content });
+  }
+);
+
+// src/index.ts
+import {
+  ImporterProvider as ImporterProvider2,
+  useImporter as useImporter5,
+  useImportSheet,
+  useConvert as useConvert5,
+  useImporterStatus as useImporterStatus5,
+  useSheetData as useSheetData6,
+  useSheetEditor as useSheetEditor5,
+  useSheetView as useSheetView2,
+  useImporterEventTarget,
+  useImporterProgressSubscription,
+  IMPORTER_ABORTED_EVENT as IMPORTER_ABORTED_EVENT2,
+  IMPORTER_PROGRESS_EVENT as IMPORTER_PROGRESS_EVENT2
+} from "@cristianmpx/react-import-sheet-headless";
+export {
+  DataTableContext,
+  EditLogContext,
+  IMPORTER_ABORTED_EVENT2 as IMPORTER_ABORTED_EVENT,
+  IMPORTER_PROGRESS_EVENT2 as IMPORTER_PROGRESS_EVENT,
+  ImporterProvider2 as ImporterProvider,
+  LayoutContext,
+  LayoutProvider,
+  RawAbortButton,
+  RawDataTableProvider,
+  RawEditLogPanel,
+  RawEditLogProvider,
+  RawErrorBoundary,
+  RawFilePicker,
+  RawImportAction,
+  RawImporterRoot,
+  RawImporterWorkflow,
+  RawMappingRow,
+  RawMappingSuggest,
+  RawMappingTable,
+  RawProgressDisplay,
+  RawStatusGuard,
+  RawStatusIndicator,
+  RawViewPhaseProvider,
+  RootConfigContext,
+  RootConfigProvider,
+  ViewPhaseContext,
+  getLayoutFieldOptions,
+  getViewFromState,
+  useConvert5 as useConvert,
+  useImportSheet,
+  useImporter5 as useImporter,
+  useImporterEventTarget,
+  useImporterMetrics,
+  useImporterProgressSubscription,
+  useImporterStatus5 as useImporterStatus,
+  useRawAbort,
+  useRawCell,
+  useRawDataTable,
+  useRawEditLog,
+  useRawErrorBadge,
+  useRawExport,
+  useRawFilePicker,
+  useRawFilterToggle,
+  useRawImportAction,
+  useRawImporterRoot,
+  useRawMappingRow,
+  useRawMappingSuggest,
+  useRawMappingTable,
+  useRawPagination,
+  useRawPersistence,
+  useRawProgress,
+  useRawRemoveRow,
+  useRawStatus,
+  useRawSubmitStatus,
+  useRawTableBody,
+  useRawTableHead,
+  useRawTableRow,
+  useSheetData6 as useSheetData,
+  useSheetEditor5 as useSheetEditor,
+  useSheetView2 as useSheetView,
+  useStatusView
+};
+//# sourceMappingURL=index.mjs.map