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

package/dist/index.js

@@ -0,0 +1,1766 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DataTableContext: () => DataTableContext,
+  EditLogContext: () => EditLogContext,
+  IMPORTER_ABORTED_EVENT: () => import_react_import_sheet_headless19.IMPORTER_ABORTED_EVENT,
+  IMPORTER_PROGRESS_EVENT: () => import_react_import_sheet_headless19.IMPORTER_PROGRESS_EVENT,
+  ImporterProvider: () => import_react_import_sheet_headless19.ImporterProvider,
+  LayoutContext: () => LayoutContext,
+  LayoutProvider: () => LayoutProvider,
+  RawAbortButton: () => RawAbortButton,
+  RawDataTableProvider: () => RawDataTableProvider,
+  RawEditLogPanel: () => RawEditLogPanel,
+  RawEditLogProvider: () => RawEditLogProvider,
+  RawErrorBoundary: () => RawErrorBoundary,
+  RawFilePicker: () => RawFilePicker,
+  RawImportAction: () => RawImportAction,
+  RawImporterRoot: () => RawImporterRoot,
+  RawImporterWorkflow: () => RawImporterWorkflow,
+  RawMappingRow: () => RawMappingRow,
+  RawMappingSuggest: () => RawMappingSuggest,
+  RawMappingTable: () => RawMappingTable,
+  RawProgressDisplay: () => RawProgressDisplay,
+  RawStatusGuard: () => RawStatusGuard,
+  RawStatusIndicator: () => RawStatusIndicator,
+  RawViewPhaseProvider: () => RawViewPhaseProvider,
+  RootConfigContext: () => RootConfigContext,
+  RootConfigProvider: () => RootConfigProvider,
+  ViewPhaseContext: () => ViewPhaseContext,
+  getLayoutFieldOptions: () => getLayoutFieldOptions,
+  getViewFromState: () => getViewFromState,
+  useConvert: () => import_react_import_sheet_headless19.useConvert,
+  useImportSheet: () => import_react_import_sheet_headless19.useImportSheet,
+  useImporter: () => import_react_import_sheet_headless19.useImporter,
+  useImporterEventTarget: () => import_react_import_sheet_headless19.useImporterEventTarget,
+  useImporterMetrics: () => useImporterMetrics,
+  useImporterProgressSubscription: () => import_react_import_sheet_headless19.useImporterProgressSubscription,
+  useImporterStatus: () => import_react_import_sheet_headless19.useImporterStatus,
+  useRawAbort: () => useRawAbort,
+  useRawCell: () => useRawCell,
+  useRawDataTable: () => useRawDataTable,
+  useRawEditLog: () => useRawEditLog,
+  useRawErrorBadge: () => useRawErrorBadge,
+  useRawExport: () => useRawExport,
+  useRawFilePicker: () => useRawFilePicker,
+  useRawFilterToggle: () => useRawFilterToggle,
+  useRawImportAction: () => useRawImportAction,
+  useRawImporterRoot: () => useRawImporterRoot,
+  useRawMappingRow: () => useRawMappingRow,
+  useRawMappingSuggest: () => useRawMappingSuggest,
+  useRawMappingTable: () => useRawMappingTable,
+  useRawPagination: () => useRawPagination,
+  useRawPersistence: () => useRawPersistence,
+  useRawProgress: () => useRawProgress,
+  useRawRemoveRow: () => useRawRemoveRow,
+  useRawStatus: () => useRawStatus,
+  useRawSubmitStatus: () => useRawSubmitStatus,
+  useRawTableBody: () => useRawTableBody,
+  useRawTableHead: () => useRawTableHead,
+  useRawTableRow: () => useRawTableRow,
+  useSheetData: () => import_react_import_sheet_headless19.useSheetData,
+  useSheetEditor: () => import_react_import_sheet_headless19.useSheetEditor,
+  useSheetView: () => import_react_import_sheet_headless19.useSheetView,
+  useStatusView: () => useStatusView
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hooks/useRawImporterRoot/useRawImporterRoot.ts
+var import_react = require("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 = (0, import_react.useMemo)(
+    () => ({
+      layout,
+      engine,
+      persist,
+      persistKey,
+      onSubmit,
+      submitKeyMap
+    }),
+    [layout, engine, persist, persistKey, onSubmit, submitKeyMap]
+  );
+  const rootConfig = (0, import_react.useMemo)(
+    () => ({
+      fuzzyMatch,
+      editingEnabled,
+      stages: { ...defaultStages, ...stages },
+      autoApplyMappingWhenMismatchesAtMost,
+      showErrorWhenMismatchesAbove
+    }),
+    [
+      fuzzyMatch,
+      editingEnabled,
+      stages,
+      autoApplyMappingWhenMismatchesAtMost,
+      showErrorWhenMismatchesAbove
+    ]
+  );
+  return { providerProps, rootConfig };
+}
+
+// src/hooks/useRawImporterRoot/RootConfigContext.tsx
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultConfig = {
+  fuzzyMatch: true,
+  editingEnabled: true,
+  stages: {},
+  autoApplyMappingWhenMismatchesAtMost: "never",
+  showErrorWhenMismatchesAbove: void 0
+};
+var RootConfigContext = (0, import_react2.createContext)(defaultConfig);
+var LayoutContext = (0, import_react2.createContext)(null);
+function RootConfigProvider({ rootConfig, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RootConfigContext.Provider, { value: rootConfig, children });
+}
+function LayoutProvider({ layout, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LayoutContext.Provider, { value: layout, children });
+}
+
+// src/hooks/useStatusView/useStatusView.ts
+var import_react3 = require("react");
+var import_react_import_sheet_headless = require("@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 = (0, import_react3.useContext)(RootConfigContext);
+  const { status, progressEventTarget } = (0, import_react_import_sheet_headless.useImporterStatus)();
+  const { convertResult } = (0, import_react_import_sheet_headless.useConvert)();
+  const mismatchCount = (0, import_react3.useMemo)(
+    () => convertResult?.mismatches?.length ?? 0,
+    [convertResult]
+  );
+  const { view, mappingErrorDetail } = (0, import_react3.useMemo)(() => {
+    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 = (0, import_react3.useRef)(null);
+  (0, import_react3.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 (0, import_react3.useMemo)(
+    () => ({
+      view,
+      status,
+      progressEventTarget,
+      convertResult,
+      mappingErrorDetail
+    }),
+    [view, status, progressEventTarget, convertResult, mappingErrorDetail]
+  );
+}
+
+// src/hooks/useRawFilePicker/useRawFilePicker.ts
+var import_react4 = require("react");
+var import_react_import_sheet_headless2 = require("@cristianmpx/react-import-sheet-headless");
+function useRawFilePicker(options = {}) {
+  const { accept } = options;
+  const { processFile } = (0, import_react_import_sheet_headless2.useImporter)();
+  const [isDragging, setIsDragging] = (0, import_react4.useState)(false);
+  const rootRef = (0, import_react4.useRef)(null);
+  const inputRef = (0, import_react4.useRef)(null);
+  const setRootRef = (0, import_react4.useCallback)((el) => {
+    rootRef.current = el;
+  }, []);
+  const setInputRef = (0, import_react4.useCallback)((el) => {
+    inputRef.current = el;
+  }, []);
+  const handleDrop = (0, import_react4.useCallback)(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setIsDragging(false);
+      const file = e.dataTransfer?.files?.[0];
+      if (file) processFile(file);
+    },
+    [processFile]
+  );
+  const handleDragOver = (0, import_react4.useCallback)((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    e.dataTransfer.dropEffect = "copy";
+    setIsDragging(true);
+  }, []);
+  const handleDragLeave = (0, import_react4.useCallback)((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (!rootRef.current?.contains(e.relatedTarget)) {
+      setIsDragging(false);
+    }
+  }, []);
+  const handleChange = (0, import_react4.useCallback)(
+    (e) => {
+      const file = e.target.files?.[0];
+      if (file) processFile(file);
+      e.target.value = "";
+    },
+    [processFile]
+  );
+  const handleRootClick = (0, import_react4.useCallback)((e) => {
+    if (e.target !== inputRef.current) {
+      inputRef.current?.click();
+    }
+  }, []);
+  const getRootProps = (0, import_react4.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 = (0, import_react4.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
+var import_react5 = require("react");
+var import_react_import_sheet_headless3 = require("@cristianmpx/react-import-sheet-headless");
+function useRawMappingTable() {
+  const { convertResult } = (0, import_react_import_sheet_headless3.useConvert)();
+  const rows = (0, import_react5.useMemo)(() => {
+    if (!convertResult?.headersFound?.length) return [];
+    return convertResult.headersFound.map((headerOriginal, columnIndex) => ({
+      headerOriginal,
+      columnIndex
+    }));
+  }, [convertResult]);
+  const hasMappingData = convertResult != null && rows.length > 0;
+  return (0, import_react5.useMemo)(
+    () => ({
+      rows,
+      hasMappingData
+    }),
+    [rows, hasMappingData]
+  );
+}
+
+// src/hooks/useRawMappingRow/useRawMappingRow.ts
+var import_react6 = require("react");
+var import_react_import_sheet_headless4 = require("@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 = (0, import_react6.useContext)(LayoutContext);
+  const { convertResult } = (0, import_react_import_sheet_headless4.useConvert)();
+  const optionsList = (0, import_react6.useMemo)(() => getLayoutFieldOptions(layout), [layout]);
+  const usedByOtherColumns = (0, import_react6.useMemo)(() => {
+    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 = (0, import_react6.useMemo)(
+    () => optionsList.map((opt) => ({
+      ...opt,
+      disabled: usedByOtherColumns.has(opt.id)
+    })),
+    [optionsList, usedByOtherColumns]
+  );
+  const value = (0, import_react6.useMemo)(() => {
+    if (!convertResult?.headerToFieldMap) return null;
+    return convertResult.headerToFieldMap[headerOriginal] ?? null;
+  }, [convertResult, headerOriginal]);
+  const onChange = (0, import_react6.useCallback)(
+    (fieldId) => {
+      convertResult?.renameColumn(headerOriginal, fieldId);
+    },
+    [convertResult, headerOriginal]
+  );
+  const mappingStatus = (0, import_react6.useMemo)(() => {
+    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 (0, import_react6.useMemo)(
+    () => ({
+      headerOriginal,
+      columnIndex,
+      options: mappingOptions,
+      value,
+      onChange,
+      mappingStatus
+    }),
+    [headerOriginal, columnIndex, mappingOptions, value, onChange, mappingStatus]
+  );
+}
+
+// src/hooks/useRawMappingSuggest/useRawMappingSuggest.ts
+var import_react7 = require("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 = (0, import_react7.useContext)(RootConfigContext);
+  const layout = (0, import_react7.useContext)(LayoutContext);
+  return (0, import_react7.useMemo)(() => {
+    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
+var import_react8 = require("react");
+var import_react_import_sheet_headless5 = require("@cristianmpx/react-import-sheet-headless");
+function useRawImportAction() {
+  const { convertResult } = (0, import_react_import_sheet_headless5.useConvert)();
+  const { status } = (0, import_react_import_sheet_headless5.useImporterStatus)();
+  const isProcessing = status === "loading" || status === "parsing" || status === "validating" || status === "transforming";
+  const disabled = (0, import_react8.useMemo)(() => {
+    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 = (0, import_react8.useCallback)(() => {
+    if (convertResult && !disabled) {
+      convertResult.applyMapping();
+    }
+  }, [convertResult, disabled]);
+  return (0, import_react8.useMemo)(
+    () => ({
+      disabled,
+      runImport
+    }),
+    [disabled, runImport]
+  );
+}
+
+// src/hooks/useRawProgress/useRawProgress.ts
+var import_react9 = require("react");
+var import_react_import_sheet_headless6 = require("@cristianmpx/react-import-sheet-headless");
+function useRawProgress(options = {}) {
+  const { onProgress } = options;
+  const { progressEventTarget } = (0, import_react_import_sheet_headless6.useImporterStatus)();
+  const progressRef = (0, import_react9.useRef)(null);
+  (0, import_react9.useEffect)(() => {
+    const target = progressEventTarget;
+    const handleProgress = (e) => {
+      const detail = e.detail;
+      progressRef.current = detail ?? null;
+      onProgress?.(detail);
+    };
+    const handleAborted = () => {
+      progressRef.current = null;
+    };
+    target.addEventListener(import_react_import_sheet_headless6.IMPORTER_PROGRESS_EVENT, handleProgress);
+    target.addEventListener(import_react_import_sheet_headless6.IMPORTER_ABORTED_EVENT, handleAborted);
+    return () => {
+      target.removeEventListener(import_react_import_sheet_headless6.IMPORTER_PROGRESS_EVENT, handleProgress);
+      target.removeEventListener(import_react_import_sheet_headless6.IMPORTER_ABORTED_EVENT, handleAborted);
+    };
+  }, [progressEventTarget, onProgress]);
+  return {
+    progressRef,
+    ...onProgress ? { onProgress } : {}
+  };
+}
+
+// src/hooks/useRawStatus/useRawStatus.ts
+var import_react10 = require("react");
+var import_react_import_sheet_headless7 = require("@cristianmpx/react-import-sheet-headless");
+function useRawStatus() {
+  const { status } = (0, import_react_import_sheet_headless7.useImporterStatus)();
+  return (0, import_react10.useMemo)(
+    () => ({
+      status,
+      // When headless exposes lastError / errorDetail, wire it here for status === 'error'
+      errorDetail: void 0
+    }),
+    [status]
+  );
+}
+
+// src/hooks/useRawAbort/useRawAbort.ts
+var import_react_import_sheet_headless8 = require("@cristianmpx/react-import-sheet-headless");
+function useRawAbort() {
+  const { abort } = (0, import_react_import_sheet_headless8.useImporter)();
+  return { abort };
+}
+
+// src/hooks/useRawDataTable/useRawDataTable.ts
+var import_react11 = require("react");
+var import_react_import_sheet_headless9 = require("@cristianmpx/react-import-sheet-headless");
+function useRawDataTable(options = {}) {
+  const { onNavigateToIndex } = options;
+  const layout = (0, import_react11.useContext)(LayoutContext);
+  const rootConfig = (0, import_react11.useContext)(RootConfigContext);
+  const { sheet } = (0, import_react_import_sheet_headless9.useSheetData)();
+  const [focusedRowIndex, setFocusedRowIndex] = (0, import_react11.useState)(null);
+  const [focusedCellKey, setFocusedCellKey] = (0, import_react11.useState)(null);
+  const [pendingCell, setPendingCell] = (0, import_react11.useState)(
+    null
+  );
+  const headerIds = (0, import_react11.useMemo)(() => {
+    if (!layout?.fields) return [];
+    return Object.keys(layout.fields);
+  }, [layout?.fields]);
+  const totalRowCount = sheet?.rows?.length ?? 0;
+  const editingEnabled = rootConfig.editingEnabled ?? true;
+  const headers = (0, import_react11.useMemo)(
+    () => getLayoutFieldOptions(layout).map((o) => ({ id: o.id, label: o.label })),
+    [layout]
+  );
+  const setFocused = (0, import_react11.useCallback)((rowIndex, cellKey) => {
+    setFocusedRowIndex(rowIndex);
+    setFocusedCellKey(cellKey);
+  }, []);
+  const getKeyDownHandler = (0, import_react11.useCallback)(
+    (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 = (0, import_react11.useMemo)(
+    () => ({
+      editingEnabled,
+      headerIds,
+      totalRowCount,
+      focusedRowIndex,
+      focusedCellKey,
+      setFocused,
+      pendingCell,
+      setPendingCell,
+      getKeyDownHandler,
+      onNavigateToIndex
+    }),
+    [
+      editingEnabled,
+      headerIds,
+      totalRowCount,
+      focusedRowIndex,
+      focusedCellKey,
+      setFocused,
+      pendingCell,
+      getKeyDownHandler,
+      onNavigateToIndex
+    ]
+  );
+  return (0, import_react11.useMemo)(
+    () => ({
+      ...value,
+      headers
+    }),
+    [value, headers]
+  );
+}
+
+// src/hooks/useRawDataTable/DataTableContext.tsx
+var import_react12 = require("react");
+var defaultContext = {
+  editingEnabled: true,
+  headerIds: [],
+  totalRowCount: 0,
+  focusedRowIndex: null,
+  focusedCellKey: null,
+  setFocused: () => {
+  },
+  pendingCell: null,
+  setPendingCell: () => {
+  },
+  getKeyDownHandler: () => () => {
+  }
+};
+var DataTableContext = (0, import_react12.createContext)(defaultContext);
+
+// src/hooks/useRawDataTable/RawDataTableProvider.tsx
+var import_react13 = require("react");
+var import_react_import_sheet_headless10 = require("@cristianmpx/react-import-sheet-headless");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function RawDataTableProvider({ children, onNavigateToIndex }) {
+  const editor = (0, import_react_import_sheet_headless10.useSheetEditor)();
+  const tableValue = useRawDataTable({ onNavigateToIndex });
+  const canEdit = editor.canEdit !== false;
+  const effectiveEditing = tableValue.editingEnabled && canEdit;
+  const value = (0, import_react13.useMemo)(
+    () => ({ ...tableValue, editingEnabled: effectiveEditing }),
+    [tableValue, effectiveEditing]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DataTableContext.Provider, { value, children });
+}
+
+// src/hooks/useRawTableHead/useRawTableHead.ts
+var import_react14 = require("react");
+function useRawTableHead() {
+  const layout = (0, import_react14.useContext)(LayoutContext);
+  const headers = (0, import_react14.useMemo)(
+    () => getLayoutFieldOptions(layout).map((o) => ({ id: o.id, label: o.label })),
+    [layout]
+  );
+  return (0, import_react14.useMemo)(() => ({ headers }), [headers]);
+}
+
+// src/hooks/useRawTableBody/useRawTableBody.ts
+var import_react15 = require("react");
+var import_react_import_sheet_headless11 = require("@cristianmpx/react-import-sheet-headless");
+function useRawTableBody() {
+  const { sheet } = (0, import_react_import_sheet_headless11.useSheetData)();
+  const totalRowCount = sheet?.rows?.length ?? 0;
+  const isPlaceholder = (0, import_react15.useCallback)(
+    (index) => index < 0 || index >= totalRowCount,
+    [totalRowCount]
+  );
+  const getRowProps = (0, import_react15.useCallback)(
+    (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 (0, import_react15.useMemo)(
+    () => ({
+      totalRowCount,
+      getRowProps,
+      isPlaceholder
+    }),
+    [totalRowCount, getRowProps, isPlaceholder]
+  );
+}
+
+// src/hooks/useRawTableRow/useRawTableRow.ts
+var import_react16 = require("react");
+var import_react_import_sheet_headless12 = require("@cristianmpx/react-import-sheet-headless");
+function useRawTableRow(options) {
+  const { index, style } = options;
+  const { sheet } = (0, import_react_import_sheet_headless12.useSheetData)();
+  const { getRowProps: bodyGetRowProps, isPlaceholder } = useRawTableBody();
+  const row = (0, import_react16.useMemo)(() => {
+    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 = (0, import_react16.useCallback)(
+    (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 (0, import_react16.useMemo)(
+    () => ({
+      getRowProps,
+      row: row ?? void 0,
+      rowErrors
+    }),
+    [getRowProps, row, rowErrors]
+  );
+}
+
+// src/hooks/useRawCell/useRawCell.ts
+var import_react17 = require("react");
+var import_react_import_sheet_headless13 = require("@cristianmpx/react-import-sheet-headless");
+function useRawCell(options) {
+  const { rowIndex, fieldId } = options;
+  const { sheet } = (0, import_react_import_sheet_headless13.useSheetData)();
+  const { editCell: editorEditCell } = (0, import_react_import_sheet_headless13.useSheetEditor)();
+  const ctx = (0, import_react17.useContext)(DataTableContext);
+  const row = sheet?.rows?.[rowIndex];
+  const cell = (0, import_react17.useMemo)(() => 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 = (0, import_react17.useCallback)(
+    (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 = (0, import_react17.useRef)(value);
+  const displayValue = isPending ? localValueRef.current : value;
+  if (!isPending) localValueRef.current = value;
+  const getCellProps = (0, import_react17.useCallback)(
+    (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 = (0, import_react17.useCallback)(() => {
+    return {
+      value: displayValue ?? "",
+      onChange: (e) => {
+        const v = e.target.value;
+        localValueRef.current = v;
+        editCell(v);
+      },
+      onBlur: () => {
+      },
+      "aria-label": fieldId
+    };
+  }, [displayValue, fieldId, editCell]);
+  const getErrorProps = (0, import_react17.useCallback)(
+    () => ({
+      role: "alert",
+      "aria-live": "polite",
+      "aria-atomic": true,
+      "data-ris-ui": "raw-cell-error-message"
+    }),
+    []
+  );
+  return (0, import_react17.useMemo)(
+    () => ({
+      value: displayValue,
+      errors,
+      isPending,
+      isEditing,
+      getCellProps,
+      getEditInputProps,
+      getErrorProps,
+      editCell
+    }),
+    [
+      displayValue,
+      errors,
+      isPending,
+      isEditing,
+      getCellProps,
+      getEditInputProps,
+      getErrorProps,
+      editCell
+    ]
+  );
+}
+
+// src/hooks/useRawErrorBadge/useRawErrorBadge.ts
+var import_react18 = require("react");
+function useRawErrorBadge(options) {
+  const { error, translateError } = options;
+  const message = (0, import_react18.useMemo)(() => {
+    if (!error) return "";
+    if (translateError) return translateError(error.code, error.params);
+    return error.message ?? error.code;
+  }, [error, translateError]);
+  return (0, import_react18.useMemo)(
+    () => ({
+      error,
+      message,
+      translateError
+    }),
+    [error, message, translateError]
+  );
+}
+
+// src/hooks/useRawPagination/useRawPagination.ts
+var import_react20 = require("react");
+
+// src/hooks/useRawPagination/ViewPhaseContext.tsx
+var import_react19 = require("react");
+var ViewPhaseContext = (0, import_react19.createContext)(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 = (0, import_react20.useContext)(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
+var import_react21 = require("react");
+var VIEW_PHASE_ERROR2 = "useRawSubmitStatus must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawSubmitStatus() {
+  const ctx = (0, import_react21.useContext)(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR2);
+  return {
+    isSubmitted: ctx.isSubmitted,
+    markSubmitted: ctx.markSubmitted,
+    canSubmit: ctx.canSubmit
+  };
+}
+
+// src/hooks/useRawPagination/RawViewPhaseProvider.tsx
+var import_react22 = require("react");
+var import_react_import_sheet_headless14 = require("@cristianmpx/react-import-sheet-headless");
+var import_jsx_runtime3 = require("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] = (0, import_react22.useState)(defaultFilterMode);
+  const [pageSize, setPageSize] = (0, import_react22.useState)(defaultPageSize);
+  const layout = (0, import_react22.useContext)(LayoutContext);
+  const { sheet } = (0, import_react_import_sheet_headless14.useSheetData)();
+  const { submitDone, submit, canSubmit } = (0, import_react_import_sheet_headless14.useImporter)();
+  const view = (0, import_react_import_sheet_headless14.useSheetView)({
+    page: initialPage,
+    defaultPageSize: pageSize,
+    filterMode
+  });
+  const layoutOptions = (0, import_react22.useMemo)(() => getLayoutFieldOptions(layout), [layout]);
+  const rowsWithErrors = (0, import_react22.useMemo)(
+    () => (sheet?.rows ?? []).filter((row) => hasRowErrors(row)),
+    [sheet?.rows]
+  );
+  const downloadCSVErrorsOnly = (0, import_react22.useCallback)(
+    (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 = (0, import_react22.useCallback)(
+    (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 = (0, import_react22.useMemo)(() => {
+    const rows = sheet?.rows ?? [];
+    return view.paginatedRows.map((row) => rows.indexOf(row)).filter((i) => i >= 0);
+  }, [sheet?.rows, view.paginatedRows]);
+  const value = (0, import_react22.useMemo)(
+    () => ({
+      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__ */ (0, import_jsx_runtime3.jsx)(ViewPhaseContext.Provider, { value, children });
+}
+
+// src/hooks/useRawRemoveRow/useRawRemoveRow.ts
+var import_react23 = require("react");
+var import_react_import_sheet_headless15 = require("@cristianmpx/react-import-sheet-headless");
+function useRawRemoveRow() {
+  const editor = (0, import_react_import_sheet_headless15.useSheetEditor)();
+  const removeRowFn = editor.removeRow;
+  const canRemoveRow = typeof removeRowFn === "function";
+  const removeRow = (0, import_react23.useCallback)(
+    (rowIndex) => {
+      if (typeof removeRowFn === "function") {
+        removeRowFn(rowIndex);
+      }
+    },
+    [removeRowFn]
+  );
+  return { removeRow, canRemoveRow };
+}
+
+// src/hooks/useRawEditLog/useRawEditLog.ts
+var import_react_import_sheet_headless16 = require("@cristianmpx/react-import-sheet-headless");
+function useRawEditLog() {
+  const editor = (0, import_react_import_sheet_headless16.useSheetEditor)();
+  const entries = editor.changeLog ?? [];
+  const changeLogAsText = editor.changeLogAsText ?? "";
+  return {
+    entries,
+    changeLogAsText,
+    clearLog: () => {
+    }
+  };
+}
+
+// src/hooks/useRawEditLog/EditLogContext.tsx
+var import_react24 = require("react");
+var EditLogContext = (0, import_react24.createContext)(null);
+
+// src/hooks/useRawEditLog/RawEditLogProvider.tsx
+var import_react25 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function RawEditLogProvider({ children }) {
+  const [entries, setEntries] = (0, import_react25.useState)([]);
+  const appendCellUpdate = (0, import_react25.useCallback)(
+    (params) => {
+      setEntries((prev) => [
+        ...prev,
+        {
+          type: "cell_update",
+          ...params,
+          timestamp: Date.now()
+        }
+      ]);
+    },
+    []
+  );
+  const appendRowRemoved = (0, import_react25.useCallback)((params) => {
+    setEntries((prev) => [
+      ...prev,
+      {
+        type: "row_removed",
+        ...params,
+        timestamp: Date.now()
+      }
+    ]);
+  }, []);
+  const clearLog = (0, import_react25.useCallback)(() => setEntries([]), []);
+  const value = (0, import_react25.useMemo)(
+    () => ({ entries, appendCellUpdate, appendRowRemoved, clearLog }),
+    [entries, appendCellUpdate, appendRowRemoved, clearLog]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(EditLogContext.Provider, { value, children });
+}
+
+// src/hooks/useRawFilterToggle/useRawFilterToggle.ts
+var import_react26 = require("react");
+var VIEW_PHASE_ERROR3 = "useRawFilterToggle must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawFilterToggle() {
+  const ctx = (0, import_react26.useContext)(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR3);
+  return {
+    filterMode: ctx.filterMode,
+    setFilterMode: ctx.setFilterMode
+  };
+}
+
+// src/hooks/useRawExport/useRawExport.ts
+var import_react27 = require("react");
+var VIEW_PHASE_ERROR4 = "useRawExport must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawExport() {
+  const ctx = (0, import_react27.useContext)(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
+var import_react28 = require("react");
+var VIEW_PHASE_ERROR5 = "useRawPersistence must be used within RawViewPhaseProvider (e.g. in RESULT view).";
+function useRawPersistence() {
+  const ctx = (0, import_react28.useContext)(ViewPhaseContext);
+  if (!ctx) throw new Error(VIEW_PHASE_ERROR5);
+  return {
+    hasRecoverableSession: ctx.hasRecoverableSession,
+    recoverSession: ctx.recoverSession,
+    clearSession: ctx.clearSession
+  };
+}
+
+// src/hooks/useImporterMetrics/useImporterMetrics.ts
+var import_react_import_sheet_headless17 = require("@cristianmpx/react-import-sheet-headless");
+function useImporterMetrics() {
+  const { metrics } = (0, import_react_import_sheet_headless17.useImporter)();
+  return metrics;
+}
+
+// src/components/RawImporterRoot/RawImporterRoot.tsx
+var import_react29 = require("react");
+var import_react_import_sheet_headless18 = require("@cristianmpx/react-import-sheet-headless");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var RawImporterRoot = (0, import_react29.forwardRef)(
+  function RawImporterRoot2({ children, className, style, ...options }, ref) {
+    const { providerProps, rootConfig } = useRawImporterRoot(options);
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_import_sheet_headless18.ImporterProvider, { ...providerProps, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutProvider, { layout: providerProps.layout ?? null, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(RootConfigProvider, { rootConfig, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { ref, className, style, "data-ris-ui": "raw-importer-root", children }) }) }) });
+  }
+);
+
+// src/components/RawStatusGuard/RawStatusGuard.tsx
+var import_react30 = require("react");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var RawStatusGuard = (0, import_react30.forwardRef)(
+  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__ */ (0, import_jsx_runtime6.jsx)("div", { ref, className, style, "data-ris-ui": "raw-status-guard", children: content });
+  }
+);
+
+// src/components/RawFilePicker/RawFilePicker.tsx
+var import_react31 = require("react");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var RawFilePicker = (0, import_react31.forwardRef)(function RawFilePicker2({ children, className, style }, ref) {
+  const state = useRawFilePicker();
+  const rootProps = state.getRootProps({ className, style });
+  const { ref: rootRef, ...restRootProps } = rootProps;
+  const setRef = (0, import_react31.useCallback)(
+    (el) => {
+      rootRef(el);
+      if (typeof ref === "function") ref(el);
+      else if (ref) ref.current = el;
+    },
+    [rootRef, ref]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { ref: setRef, ...restRootProps, "data-ris-ui": "raw-file-picker", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("input", { ...state.getInputProps() }),
+    children(state)
+  ] });
+});
+
+// src/components/RawMappingTable/RawMappingTable.tsx
+var import_react32 = require("react");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var RawMappingTable = (0, import_react32.forwardRef)(
+  function RawMappingTable2({ children, className, style }, ref) {
+    const state = useRawMappingTable();
+    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { ref, className, style, "data-ris-ui": "raw-mapping-table", children: children(state) });
+  }
+);
+
+// src/components/RawMappingRow/RawMappingRow.tsx
+var import_react33 = require("react");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var RawMappingRow = (0, import_react33.forwardRef)(function RawMappingRow2({ rowContext, children, className, style }, ref) {
+  const state = useRawMappingRow({ rowContext });
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { ref, className, style, "data-ris-ui": "raw-mapping-row", children: children(state) });
+});
+
+// src/components/RawMappingSuggest/RawMappingSuggest.tsx
+var import_react34 = require("react");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var RawMappingSuggest = (0, import_react34.forwardRef)(
+  function RawMappingSuggest2({ columnContext, children, className, style }, ref) {
+    const state = useRawMappingSuggest({ columnContext });
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { ref, className, style, "data-ris-ui": "raw-mapping-suggest", children: children(state) });
+  }
+);
+
+// src/components/RawImportAction/RawImportAction.tsx
+var import_react35 = require("react");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var RawImportAction = (0, import_react35.forwardRef)(
+  function RawImportAction2({ children, className, style }, ref) {
+    const state = useRawImportAction();
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { ref, className, style, "data-ris-ui": "raw-import-action", children: children(state) });
+  }
+);
+
+// src/components/RawErrorBoundary/RawErrorBoundary.tsx
+var import_react36 = require("react");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var RawErrorBoundary = class extends import_react36.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__ */ (0, import_jsx_runtime12.jsx)("div", { "data-ris-ui": "raw-error-boundary", children: content });
+    }
+    return children;
+  }
+};
+
+// src/components/RawProgressDisplay/RawProgressDisplay.tsx
+var import_react37 = require("react");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var RawProgressDisplay = (0, import_react37.forwardRef)(
+  function RawProgressDisplay2({ children, className, style, onProgress }, ref) {
+    const state = useRawProgress({ onProgress });
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { ref, className, style, "data-ris-ui": "raw-progress-display", children: children(state) });
+  }
+);
+
+// src/components/RawStatusIndicator/RawStatusIndicator.tsx
+var import_react38 = require("react");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var RawStatusIndicator = (0, import_react38.forwardRef)(
+  function RawStatusIndicator2({ children, className, style }, ref) {
+    const state = useRawStatus();
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { ref, className, style, "data-ris-ui": "raw-status-indicator", children: children(state) });
+  }
+);
+
+// src/components/RawAbortButton/RawAbortButton.tsx
+var import_react39 = require("react");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var PROCESSING_STATUSES = ["loading", "parsing", "validating", "transforming"];
+var RawAbortButton = (0, import_react39.forwardRef)(
+  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 = (0, import_react39.useMemo)(
+      () => ({
+        type: "button",
+        onClick: abort,
+        disabled,
+        className,
+        style,
+        "aria-label": ariaLabel ?? "Cancel import"
+      }),
+      [abort, disabled, className, style, ariaLabel]
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { ref, ...buttonProps, "data-ris-ui": "raw-abort-button", children: children ?? "Cancel" });
+  }
+);
+
+// src/components/RawImporterWorkflow/RawImporterWorkflow.tsx
+var import_react41 = require("react");
+
+// src/components/RawEditLogPanel/RawEditLogPanel.tsx
+var import_react40 = require("react");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+var RawEditLogPanel = (0, import_react40.forwardRef)(
+  function RawEditLogPanel2({ className, style, children }, ref) {
+    const { entries, changeLogAsText } = useRawEditLog();
+    if (children) {
+      return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+        "div",
+        {
+          ref,
+          className,
+          style,
+          "data-ris-ui": "raw-edit-log-panel",
+          role: "log",
+          "aria-label": "Edit log",
+          children: children({ entries, changeLogAsText, clearLog: () => {
+          } })
+        }
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(
+      "div",
+      {
+        ref,
+        className,
+        style,
+        "data-ris-ui": "raw-edit-log-panel",
+        role: "log",
+        "aria-label": "Edit log",
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { "data-ris-ui": "raw-edit-log-header", children: /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("span", { children: [
+            "Edit log (",
+            entries.length,
+            " changes)"
+          ] }) }),
+          changeLogAsText ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("pre", { "data-ris-ui": "raw-edit-log-list", children: changeLogAsText }) : /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("ul", { "data-ris-ui": "raw-edit-log-list", children: entries.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("li", { "data-ris-ui": "raw-edit-log-entry", children: "No changes yet." }) : null })
+        ]
+      }
+    );
+  }
+);
+
+// src/components/RawImporterWorkflow/RawImporterWorkflow.tsx
+var import_jsx_runtime17 = require("react/jsx-runtime");
+function BackToFileButton({
+  children = "Choose another file",
+  "aria-label": ariaLabel = "Cancel and choose another file"
+}) {
+  const { abort } = useRawAbort();
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    "button",
+    {
+      type: "button",
+      onClick: abort,
+      "aria-label": ariaLabel,
+      "data-ris-ui": "raw-workflow-back-button",
+      children
+    }
+  );
+}
+function DefaultIdle() {
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawFilePicker, { children: (state) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { "data-ris-ui": "raw-file-picker-prompt", children: state.isDragging ? "Drop file here" : "Click or drop file here" }) });
+}
+function DefaultMapping() {
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawMappingTable, { children: (state) => state.rows.map((rowContext) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawMappingRow, { rowContext, children: (rowState) => /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { children: rowState.headerOriginal }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      RawMappingSuggest,
+      {
+        columnContext: {
+          fileHeader: rowContext.headerOriginal,
+          columnIndex: rowContext.columnIndex
+        },
+        children: (suggestState) => suggestState.suggestedFieldId != null ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("span", { "data-ris-ui": "raw-mapping-suggest-badge", children: [
+          suggestState.suggestedFieldLabel,
+          " (",
+          suggestState.matchScore,
+          "%)"
+        ] }) : null
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(
+      "select",
+      {
+        value: rowState.value ?? "",
+        onChange: (e) => rowState.onChange(e.target.value),
+        "aria-label": `Map ${rowState.headerOriginal}`,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("option", { value: "", children: "\u2014" }),
+          rowState.options.map((opt) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("option", { value: opt.id, disabled: opt.disabled, children: opt.label }, opt.id))
+        ]
+      }
+    )
+  ] }) }, rowContext.columnIndex)) });
+}
+function DefaultMappingWithAction() {
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultMapping, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { "data-ris-ui": "raw-workflow-mapping-actions", role: "group", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawImportAction, { children: (state) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "button",
+        {
+          type: "button",
+          disabled: state.disabled,
+          onClick: state.runImport,
+          "aria-label": "Run import",
+          children: "Import"
+        }
+      ) }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(BackToFileButton, { children: "Choose another file" })
+    ] })
+  ] });
+}
+function DefaultProcess() {
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawProgressDisplay, { children: (state) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-ris-ui": "raw-progress", children: String(state.progressRef?.current ?? 0) }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawStatusIndicator, { children: (state) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-ris-ui": "raw-status", children: state.status }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawAbortButton, {})
+  ] });
+}
+function ResultToolbar({
+  submitLabel = "Submit"
+} = {}) {
+  const filter = useRawFilterToggle();
+  const exportApi = useRawExport();
+  const { isSubmitted, markSubmitted, canSubmit } = useRawSubmitStatus();
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { "data-ris-ui": "raw-workflow-toolbar", role: "toolbar", children: [
+    isSubmitted ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { "data-ris-ui": "raw-workflow-submitted-message", role: "status", children: "Submitted. You can download the file below." }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(BackToFileButton, { "aria-label": "Import another file", children: "New file" }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      "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__ */ (0, import_jsx_runtime17.jsx)("button", { type: "button", onClick: () => exportApi.downloadCSV?.(), children: "Export CSV" }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("button", { type: "button", onClick: () => exportApi.downloadJSON?.(), children: "Export JSON" }),
+    exportApi.downloadCSVErrorsOnly != null ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      "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__ */ (0, import_jsx_runtime17.jsx)(
+      "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__ */ (0, import_jsx_runtime17.jsx)(
+      "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__ */ (0, import_jsx_runtime17.jsxs)("table", { "data-ris-ui": "raw-workflow-grid", role: "grid", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("tr", { role: "row", children: [
+      headers.map((h) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("th", { scope: "col", role: "columnheader", children: h.label }, h.id)),
+      canRemoveRow ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("th", { scope: "col", role: "columnheader", "data-ris-ui": "raw-workflow-row-actions-header", children: "Actions" }) : null
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("tbody", { children: visibleSheetIndices.map((sheetIndex) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      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__ */ (0, import_jsx_runtime17.jsxs)("tr", { ...row.getRowProps(), children: [
+    headerIds.map((fieldId) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      ResultCell,
+      {
+        rowIndex: index,
+        fieldId,
+        cellErrorPlacement
+      },
+      fieldId
+    )),
+    showDelete ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("td", { role: "gridcell", "data-ris-ui": "raw-workflow-row-remove-cell", children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      "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__ */ (0, import_jsx_runtime17.jsx)("span", { ...cell.getErrorProps(), children: badge.message });
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("td", { ...cell.getCellProps(), children: cellErrorPlacement === "below" ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-ris-ui": "raw-cell-value-line", children: cell.isEditing ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("input", { ...cell.getEditInputProps() }) : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { children: String(cell.value ?? "") }) }),
+    showError ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-ris-ui": "raw-cell-error-line", children: errorSlot }) : null
+  ] }) : /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+    cell.isEditing ? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("input", { ...cell.getEditInputProps() }) : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { children: String(cell.value ?? "") }),
+    cellErrorPlacement === "inline" && errorSlot
+  ] }) });
+}
+function ResultFooter() {
+  const pagination = useRawPagination();
+  const persistence = useRawPersistence();
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { "data-ris-ui": "raw-workflow-footer", role: "contentinfo", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { "data-ris-ui": "raw-workflow-pagination", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "button",
+        {
+          type: "button",
+          disabled: pagination.page <= 1,
+          onClick: () => pagination.setPage(pagination.page - 1),
+          "aria-label": "Previous page",
+          children: "Previous"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("span", { children: [
+        "Page ",
+        pagination.page,
+        " of",
+        " ",
+        Math.max(1, Math.ceil(pagination.totalRows / pagination.pageSize))
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "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__ */ (0, import_jsx_runtime17.jsxs)("div", { "data-ris-ui": "raw-workflow-persistence", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("button", { type: "button", onClick: persistence.recoverSession, children: "Recover session" }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("button", { type: "button", onClick: persistence.clearSession, children: "Clear" })
+    ] }) : null
+  ] });
+}
+function DefaultResult({
+  submitLabel,
+  cellErrorPlacement = "inline"
+} = {}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(RawViewPhaseProvider, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ResultToolbar, { submitLabel }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawEditLogPanel, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(RawDataTableProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ResultGrid, { cellErrorPlacement }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ResultFooter, {})
+  ] });
+}
+function DefaultError({ mappingErrorDetail }) {
+  if (mappingErrorDetail?.code === "TOO_MANY_MISMATCHES") {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { "data-ris-ui": "raw-workflow-mapping-error", role: "alert", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("p", { children: [
+        "Too many column mismatches (",
+        mappingErrorDetail.mismatchCount,
+        "). Maximum allowed:",
+        " ",
+        mappingErrorDetail.maxAllowed,
+        "."
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(BackToFileButton, { children: "Choose another file" })
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultIdle, {});
+}
+var RawImporterWorkflow = (0, import_react41.forwardRef)(
+  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__ */ (0, import_jsx_runtime17.jsx)(DefaultIdle, {});
+        break;
+      case "mapping":
+        content = renderMapping ? renderMapping() : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultMappingWithAction, {});
+        break;
+      case "process":
+        content = renderProcess ? renderProcess() : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultProcess, {});
+        break;
+      case "result":
+        content = renderResult ? renderResult() : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultResult, { submitLabel, cellErrorPlacement });
+        break;
+      case "error":
+        content = renderError ? renderError({ mappingErrorDetail }) : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultError, { mappingErrorDetail });
+        break;
+      default:
+        content = renderIdle ? renderIdle() : /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DefaultIdle, {});
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { ref, className, style, "data-ris-ui": "raw-importer-workflow", children: content });
+  }
+);
+
+// src/index.ts
+var import_react_import_sheet_headless19 = require("@cristianmpx/react-import-sheet-headless");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataTableContext,
+  EditLogContext,
+  IMPORTER_ABORTED_EVENT,
+  IMPORTER_PROGRESS_EVENT,
+  ImporterProvider,
+  LayoutContext,
+  LayoutProvider,
+  RawAbortButton,
+  RawDataTableProvider,
+  RawEditLogPanel,
+  RawEditLogProvider,
+  RawErrorBoundary,
+  RawFilePicker,
+  RawImportAction,
+  RawImporterRoot,
+  RawImporterWorkflow,
+  RawMappingRow,
+  RawMappingSuggest,
+  RawMappingTable,
+  RawProgressDisplay,
+  RawStatusGuard,
+  RawStatusIndicator,
+  RawViewPhaseProvider,
+  RootConfigContext,
+  RootConfigProvider,
+  ViewPhaseContext,
+  getLayoutFieldOptions,
+  getViewFromState,
+  useConvert,
+  useImportSheet,
+  useImporter,
+  useImporterEventTarget,
+  useImporterMetrics,
+  useImporterProgressSubscription,
+  useImporterStatus,
+  useRawAbort,
+  useRawCell,
+  useRawDataTable,
+  useRawEditLog,
+  useRawErrorBadge,
+  useRawExport,
+  useRawFilePicker,
+  useRawFilterToggle,
+  useRawImportAction,
+  useRawImporterRoot,
+  useRawMappingRow,
+  useRawMappingSuggest,
+  useRawMappingTable,
+  useRawPagination,
+  useRawPersistence,
+  useRawProgress,
+  useRawRemoveRow,
+  useRawStatus,
+  useRawSubmitStatus,
+  useRawTableBody,
+  useRawTableHead,
+  useRawTableRow,
+  useSheetData,
+  useSheetEditor,
+  useSheetView,
+  useStatusView
+});
+//# sourceMappingURL=index.js.map