@wakastellar/ui 0.2.0 → 0.4.0

package/dist/useDataTableImport-sQwBFAJ_.js

@@ -0,0 +1,775 @@
+import { useState as H, useRef as Z, useEffect as Q, useMemo as q, useCallback as d } from "react";
+class ee {
+  constructor(e) {
+    this.config = {
+      debug: !1,
+      minLevel: "debug",
+      prefix: "[WakaUI]"
+    }, e && (this.config = { ...this.config, ...e });
+  }
+  /**
+   * Configure the logger
+   */
+  configure(e) {
+    this.config = { ...this.config, ...e };
+  }
+  /**
+   * Check if logging is enabled for the given level
+   */
+  shouldLog(e) {
+    if (e === "error" || e === "warn")
+      return !0;
+    if (process.env.NODE_ENV === "production" && !this.config.debug)
+      return !1;
+    const s = ["debug", "info", "warn", "error"], x = s.indexOf(e), T = s.indexOf(this.config.minLevel || "debug");
+    return x >= T;
+  }
+  /**
+   * Format log message with prefix
+   */
+  format(e) {
+    return this.config.prefix ? `${this.config.prefix} ${e}` : e;
+  }
+  /**
+   * Debug level logging (development only by default)
+   */
+  debug(e, ...s) {
+    this.shouldLog("debug") && console.log(this.format(e), ...s);
+  }
+  /**
+   * Info level logging
+   */
+  info(e, ...s) {
+    this.shouldLog("info") && console.log(this.format(e), ...s);
+  }
+  /**
+   * Warning level logging (always shown)
+   */
+  warn(e, ...s) {
+    this.shouldLog("warn") && console.warn(this.format(e), ...s);
+  }
+  /**
+   * Error level logging (always shown)
+   */
+  error(e, ...s) {
+    this.shouldLog("error") && console.error(this.format(e), ...s);
+  }
+}
+const z = new ee(), F = {
+  // Generic errors
+  UNKNOWN: "WAKA_UNKNOWN",
+  VALIDATION: "WAKA_VALIDATION",
+  NETWORK: "WAKA_NETWORK",
+  TIMEOUT: "WAKA_TIMEOUT",
+  // Theme errors
+  THEME_LOAD_FAILED: "WAKA_THEME_LOAD_FAILED",
+  THEME_PARSE_FAILED: "WAKA_THEME_PARSE_FAILED",
+  THEME_APPLY_FAILED: "WAKA_THEME_APPLY_FAILED",
+  // Language errors
+  LANG_LOAD_FAILED: "WAKA_LANG_LOAD_FAILED",
+  LANG_PARSE_FAILED: "WAKA_LANG_PARSE_FAILED",
+  TRANSLATION_MISSING: "WAKA_TRANSLATION_MISSING",
+  // DataTable errors
+  DATATABLE_EXPORT_FAILED: "WAKA_DATATABLE_EXPORT_FAILED",
+  DATATABLE_IMPORT_FAILED: "WAKA_DATATABLE_IMPORT_FAILED",
+  DATATABLE_PARSE_FAILED: "WAKA_DATATABLE_PARSE_FAILED",
+  // Component errors
+  COMPONENT_RENDER_FAILED: "WAKA_COMPONENT_RENDER_FAILED",
+  COMPONENT_INIT_FAILED: "WAKA_COMPONENT_INIT_FAILED",
+  // Provider errors
+  PROVIDER_MISSING: "WAKA_PROVIDER_MISSING",
+  PROVIDER_CONFIG_INVALID: "WAKA_PROVIDER_CONFIG_INVALID"
+};
+class _ extends Error {
+  constructor(e, s = {}) {
+    super(e), this.name = "WakaError", this.code = s.code || F.UNKNOWN, this.context = s.context, this.cause = s.cause, this.metadata = s.metadata, this.timestamp = /* @__PURE__ */ new Date(), Error.captureStackTrace && Error.captureStackTrace(this, _);
+  }
+  /**
+   * Create a WakaError from any error type
+   */
+  static from(e, s = {}) {
+    return e instanceof _ ? e : e instanceof Error ? new _(e.message, {
+      ...s,
+      cause: e
+    }) : new _(String(e), s);
+  }
+  /**
+   * Serialize error for logging or transmission
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      context: this.context,
+      metadata: this.metadata,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack,
+      cause: this.cause?.message
+    };
+  }
+}
+function M(h, e = {}) {
+  const s = _.from(h, {
+    code: e.code,
+    context: e.context,
+    metadata: e.metadata
+  });
+  if (e.silent || z.error(
+    `${e.context || "Error"}: ${s.message}`,
+    s.toJSON()
+  ), e.onError?.(s), e.rethrow)
+    throw s;
+  return s;
+}
+function oe(h, e = {}) {
+  try {
+    return h();
+  } catch (s) {
+    return M(s, e), e.fallback;
+  }
+}
+async function ae(h, e = {}) {
+  try {
+    return await h();
+  } catch (s) {
+    return M(s, e), e.fallback;
+  }
+}
+function se(h, e = {}) {
+  return async (...s) => {
+    try {
+      return await h(...s);
+    } catch (x) {
+      throw M(x, e);
+    }
+  };
+}
+function ce(h, e, s = {}) {
+  if (!h)
+    throw new _(e, {
+      code: s.code || F.VALIDATION,
+      context: s.context,
+      metadata: s.metadata
+    });
+}
+function te(h) {
+  return h instanceof _;
+}
+function ie(h, e) {
+  return te(h) && h.code === e;
+}
+function le(h) {
+  return (e, s = F.UNKNOWN, x) => new _(e, { code: s, context: h, metadata: x });
+}
+async function ue(h, e = {}) {
+  const {
+    maxRetries: s = 3,
+    baseDelay: x = 1e3,
+    maxDelay: T = 1e4,
+    context: y,
+    onRetry: b
+  } = e;
+  let m;
+  for (let E = 0; E <= s; E++)
+    try {
+      return await h();
+    } catch (w) {
+      if (m = _.from(w, { context: y }), E < s) {
+        const g = Math.min(x * Math.pow(2, E), T);
+        b?.(E + 1, m), z.warn(
+          `${y || "Operation"} failed (attempt ${E + 1}/${s + 1}), retrying in ${g}ms...`
+        ), await new Promise((k) => setTimeout(k, g));
+      }
+    }
+  throw m;
+}
+const re = 1e3;
+function pe({
+  data: h,
+  columns: e,
+  exportConfig: s,
+  onError: x
+}) {
+  const [T, y] = H(0), [b, m] = H(!1), E = Z(null);
+  Q(() => () => {
+    E.current && (E.current.terminate(), E.current = null);
+  }, []);
+  const w = q(() => ({
+    formats: ["csv", "xlsx", "json"],
+    filename: "export",
+    includeHeaders: !0,
+    useWorker: !0,
+    // Utiliser le worker par défaut pour les grandes tables
+    workerThreshold: re,
+    ...s
+  }), [s]), g = d((t) => {
+    const n = t;
+    return n.accessorKey || n.id;
+  }, []), k = d((t) => {
+    const n = t;
+    return typeof t.header == "string" ? t.header : (typeof t.header == "function", n.accessorKey || n.id || "");
+  }, []), v = d((t, n) => {
+    const o = g(n);
+    if (o)
+      return t[o];
+  }, [g]), S = d(() => e.filter((t) => g(t)).map((t) => ({
+    key: g(t),
+    header: k(t)
+  })), [e, g, k]), O = d(async (t, n, o) => new Promise((r, a) => {
+    m(!0), y(0);
+    try {
+      const p = `
+          // Fonction pour convertir en CSV
+          function convertToCSV(data, columns) {
+            const headers = columns.map(col => col.header).join(',');
+            const rows = data.map(row => {
+              return columns
+                .map(col => {
+                  const value = row[col.key];
+                  const stringValue = String(value ?? '');
+                  if (stringValue.includes(',') || stringValue.includes('"') || stringValue.includes('\\n')) {
+                    return '"' + stringValue.replace(/"/g, '""') + '"';
+                  }
+                  return stringValue;
+                })
+                .join(',');
+            });
+            return [headers, ...rows].join('\\n');
+          }
+
+          // Fonction pour convertir en JSON
+          function convertToJSON(data) {
+            return JSON.stringify(data, null, 2);
+          }
+
+          // Fonction pour convertir en XML
+          function convertToXML(data, columns) {
+            let xmlContent = '<?xml version="1.0" encoding="UTF-8"?>\\n<data>\\n';
+            data.forEach((row, index) => {
+              xmlContent += '  <row id="' + index + '">\\n';
+              columns.forEach(col => {
+                const value = row[col.key];
+                const stringValue = String(value ?? '')
+                  .replace(/&/g, '&amp;')
+                  .replace(/</g, '&lt;')
+                  .replace(/>/g, '&gt;');
+                xmlContent += '    <' + col.key + '>' + stringValue + '</' + col.key + '>\\n';
+              });
+              xmlContent += '  </row>\\n';
+            });
+            xmlContent += '</data>';
+            return xmlContent;
+          }
+
+          // Traitement par chunks avec progression
+          function processWithProgress(data, columns, format) {
+            const CHUNK_SIZE = 500;
+            const totalRows = data.length;
+
+            if (format === 'json') {
+              self.postMessage({ type: 'progress', progress: 50 });
+              const result = convertToJSON(data);
+              self.postMessage({ type: 'progress', progress: 100 });
+              return result;
+            }
+
+            let result = '';
+
+            if (format === 'csv') {
+              result = columns.map(col => col.header).join(',') + '\\n';
+              for (let i = 0; i < totalRows; i += CHUNK_SIZE) {
+                const chunk = data.slice(i, Math.min(i + CHUNK_SIZE, totalRows));
+                const chunkRows = chunk.map(row => {
+                  return columns
+                    .map(col => {
+                      const value = row[col.key];
+                      const stringValue = String(value ?? '');
+                      if (stringValue.includes(',') || stringValue.includes('"') || stringValue.includes('\\n')) {
+                        return '"' + stringValue.replace(/"/g, '""') + '"';
+                      }
+                      return stringValue;
+                    })
+                    .join(',');
+                });
+                result += chunkRows.join('\\n') + (i + CHUNK_SIZE < totalRows ? '\\n' : '');
+                self.postMessage({ type: 'progress', progress: Math.round(((i + CHUNK_SIZE) / totalRows) * 100) });
+              }
+              return result;
+            }
+
+            if (format === 'xml') {
+              result = '<?xml version="1.0" encoding="UTF-8"?>\\n<data>\\n';
+              for (let i = 0; i < totalRows; i += CHUNK_SIZE) {
+                const chunk = data.slice(i, Math.min(i + CHUNK_SIZE, totalRows));
+                chunk.forEach((row, idx) => {
+                  result += '  <row id="' + (i + idx) + '">\\n';
+                  columns.forEach(col => {
+                    const value = row[col.key];
+                    const stringValue = String(value ?? '')
+                      .replace(/&/g, '&amp;')
+                      .replace(/</g, '&lt;')
+                      .replace(/>/g, '&gt;');
+                    result += '    <' + col.key + '>' + stringValue + '</' + col.key + '>\\n';
+                  });
+                  result += '  </row>\\n';
+                });
+                self.postMessage({ type: 'progress', progress: Math.round(((i + CHUNK_SIZE) / totalRows) * 100) });
+              }
+              result += '</data>';
+              return result;
+            }
+
+            return result;
+          }
+
+          self.onmessage = function(e) {
+            const { format, data, columns } = e.data;
+            try {
+              const content = processWithProgress(data, columns, format);
+              self.postMessage({ type: 'success', content });
+            } catch (error) {
+              self.postMessage({ type: 'error', error: error.message || 'Unknown error' });
+            }
+          };
+        `, f = new Blob([p], { type: "application/javascript" }), c = URL.createObjectURL(f), u = new Worker(c);
+      E.current = u, u.onmessage = (I) => {
+        const { type: A, content: J, progress: $, error: K } = I.data;
+        if (A === "progress")
+          y($);
+        else if (A === "success") {
+          let C, W;
+          switch (n) {
+            case "csv":
+              C = "text/csv;charset=utf-8;", W = "csv";
+              break;
+            case "json":
+              C = "application/json", W = "json";
+              break;
+            case "xml":
+              C = "application/xml", W = "xml";
+              break;
+            default:
+              C = "text/plain", W = "txt";
+          }
+          const Y = new Blob([J], { type: C }), X = document.createElement("a");
+          X.href = URL.createObjectURL(Y), X.download = `${o}.${W}`, X.click(), URL.revokeObjectURL(X.href), u.terminate(), URL.revokeObjectURL(c), E.current = null, m(!1), y(0), r();
+        } else A === "error" && (u.terminate(), URL.revokeObjectURL(c), E.current = null, m(!1), y(0), a(new Error(K)));
+      }, u.onerror = (I) => {
+        u.terminate(), URL.revokeObjectURL(c), E.current = null, m(!1), y(0), a(new Error(I.message));
+      };
+      const L = S();
+      u.postMessage({
+        format: n,
+        data: t,
+        columns: L
+      });
+    } catch (p) {
+      m(!1), y(0), a(p);
+    }
+  }), [S]), D = d((t, n) => {
+    if (!t.length) return;
+    const o = e.filter((u) => g(u)), r = o.map((u) => k(u)).join(","), a = t.map((u) => o.map((L) => {
+      const I = v(u, L), A = String(I ?? "");
+      return A.includes(",") || A.includes('"') || A.includes(`
+`) ? `"${A.replace(/"/g, '""')}"` : A;
+    }).join(",")), p = [r, ...a].join(`
+`), f = new Blob([p], { type: "text/csv;charset=utf-8;" }), c = document.createElement("a");
+    c.href = URL.createObjectURL(f), c.download = `${n || w.filename}.csv`, c.click(), URL.revokeObjectURL(c.href);
+  }, [e, w.filename, g, k, v]), U = d((t, n) => {
+    const o = JSON.stringify(t, null, 2), r = new Blob([o], { type: "application/json" }), a = document.createElement("a");
+    a.href = URL.createObjectURL(r), a.download = `${n || w.filename}.json`, a.click(), URL.revokeObjectURL(a.href);
+  }, [w.filename]), R = d(async (t, n) => {
+    try {
+      if (typeof window > "u")
+        throw new Error("XLSX export not available in server environment");
+      let o;
+      try {
+        o = await import("xlsx");
+      } catch {
+        throw new Error(
+          "La dépendance 'xlsx' est requise pour l'export Excel. Installez-la avec: pnpm add xlsx (version >=0.18.0)"
+        );
+      }
+      const r = e.filter((u) => g(u)), p = [
+        r.map((u) => k(u)),
+        ...t.map(
+          (u) => r.map((L) => v(u, L))
+        )
+      ], f = o.utils.aoa_to_sheet(p), c = o.utils.book_new();
+      o.utils.book_append_sheet(c, f, "Sheet1"), o.writeFile(c, `${n || w.filename}.xlsx`);
+    } catch (o) {
+      throw M(o, {
+        code: F.DATATABLE_EXPORT_FAILED,
+        context: "DataTable.exportToXLSX",
+        onError: x
+      });
+    }
+  }, [e, w.filename, g, k, v, x]), V = d(async (t, n) => {
+    try {
+      if (typeof window > "u")
+        throw new Error("PDF export not available in server environment");
+      let o;
+      try {
+        o = await import("jspdf");
+      } catch {
+        throw new Error(
+          "La dépendance 'jspdf' est requise pour l'export PDF. Installez-la avec: pnpm add jspdf (version >=2.5.0)"
+        );
+      }
+      try {
+        await import("jspdf-autotable");
+      } catch {
+        throw new Error(
+          "La dépendance 'jspdf-autotable' est requise pour l'export PDF. Installez-la avec: pnpm add jspdf-autotable (version >=3.5.0)"
+        );
+      }
+      const r = new o.default(), a = e.filter((c) => g(c)), p = a.map((c) => k(c)), f = t.map(
+        (c) => a.map((u) => v(c, u))
+      );
+      r.autoTable({
+        head: [p],
+        body: f,
+        startY: 20,
+        styles: { fontSize: 8 },
+        headStyles: { fillColor: [66, 139, 202] }
+      }), r.save(`${n || w.filename}.pdf`);
+    } catch (o) {
+      throw M(o, {
+        code: F.DATATABLE_EXPORT_FAILED,
+        context: "DataTable.exportToPDF",
+        onError: x
+      });
+    }
+  }, [e, w.filename, g, k, v, x]), P = d((t, n) => {
+    const o = e.filter((f) => g(f));
+    let r = `<?xml version="1.0" encoding="UTF-8"?>
+<data>
+`;
+    t.forEach((f, c) => {
+      r += `  <row id="${c}">
+`, o.forEach((u) => {
+        const L = g(u);
+        if (L) {
+          const I = v(f, u), A = String(I ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+          r += `    <${L}>${A}</${L}>
+`;
+        }
+      }), r += `  </row>
+`;
+    }), r += "</data>";
+    const a = new Blob([r], { type: "application/xml" }), p = document.createElement("a");
+    p.href = URL.createObjectURL(a), p.download = `${n || w.filename}.xml`, p.click(), URL.revokeObjectURL(p.href);
+  }, [e, w.filename, g, v]), N = d(async (t, n, o) => {
+    const r = n || h, a = o || w.filename;
+    if (w.onExport) {
+      w.onExport(r, t);
+      return;
+    }
+    const p = ["csv", "json", "xml"];
+    if (w.useWorker && r.length >= w.workerThreshold && p.includes(t.toLowerCase()) && typeof Worker < "u") {
+      await O(
+        r,
+        t.toLowerCase(),
+        a
+      );
+      return;
+    }
+    switch (t.toLowerCase()) {
+      case "csv":
+        D(r, a);
+        break;
+      case "json":
+        U(r, a);
+        break;
+      case "xlsx":
+        await R(r, a);
+        break;
+      case "pdf":
+        await V(r, a);
+        break;
+      case "xml":
+        P(r, a);
+        break;
+      default:
+        throw new Error(`Format d'export non supporté: ${t}`);
+    }
+  }, [h, w, O, D, U, R, V, P]), B = d(async (t) => N(t), [N]), i = d(async (t, n) => N(t, n), [N]), l = d(() => {
+    E.current && (E.current.terminate(), E.current = null, m(!1), y(0));
+  }, []);
+  return {
+    exportData: N,
+    exportAll: B,
+    exportSelected: i,
+    cancelExport: l,
+    exportProgress: T,
+    isExporting: b,
+    supportedFormats: w.formats,
+    isExportSupported: (t) => w.formats.includes(t)
+  };
+}
+const G = 5e3, j = 1e3;
+function me({
+  importConfig: h,
+  onError: e
+}) {
+  const [s, x] = H(0), [T, y] = H(!1), b = Z(null), m = q(() => ({
+    accept: ".csv,.xlsx,.json,.xml",
+    ...h
+  }), [h]), E = d((i, l = ",") => {
+    const t = i.split(`
+`).filter((r) => r.trim());
+    if (t.length === 0) return [];
+    const n = t[0].split(l).map((r) => r.trim().replace(/"/g, ""));
+    return t.slice(1).map((r) => {
+      const a = r.split(l).map((f) => f.trim().replace(/"/g, "")), p = {};
+      return n.forEach((f, c) => {
+        p[f] = a[c] || "";
+      }), p;
+    });
+  }, []), w = d(async (i, l = ",", t, n) => {
+    const o = i.split(`
+`).filter((c) => c.trim());
+    if (o.length === 0) return [];
+    const r = o[0].split(l).map((c) => c.trim().replace(/"/g, "")), a = o.slice(1), p = a.length, f = [];
+    for (let c = 0; c < p; c += j) {
+      if (n?.aborted)
+        throw new Error("Import annulé");
+      const u = a.slice(c, c + j), L = u.map((A) => {
+        const J = A.split(l).map((K) => K.trim().replace(/"/g, "")), $ = {};
+        return r.forEach((K, C) => {
+          $[K] = J[C] || "";
+        }), $;
+      });
+      f.push(...L);
+      const I = Math.min(100, Math.round((c + u.length) / p * 100));
+      t?.(I), await new Promise((A) => setTimeout(A, 0));
+    }
+    return f;
+  }, []), g = d(async (i, l, t) => {
+    const n = JSON.parse(i), o = Array.isArray(n) ? n : [n];
+    if (o.length < G)
+      return l?.(100), o;
+    const r = [], a = o.length;
+    for (let p = 0; p < a; p += j) {
+      if (t?.aborted)
+        throw new Error("Import annulé");
+      const f = o.slice(p, p + j);
+      r.push(...f);
+      const c = Math.min(100, Math.round((p + f.length) / a * 100));
+      l?.(c), await new Promise((u) => setTimeout(u, 0));
+    }
+    return r;
+  }, []), k = d((i) => {
+    try {
+      const l = JSON.parse(i);
+      return Array.isArray(l) ? l : [l];
+    } catch {
+      throw new Error("Format JSON invalide");
+    }
+  }, []), v = d((i) => {
+    try {
+      const n = new DOMParser().parseFromString(i, "text/xml").querySelectorAll("row");
+      return Array.from(n).map((o) => {
+        const r = {};
+        return Array.from(o.children).forEach((a) => {
+          r[a.tagName] = a.textContent || "";
+        }), r;
+      });
+    } catch {
+      throw new Error("Format XML invalide");
+    }
+  }, []), S = d(async (i) => {
+    try {
+      if (typeof window > "u")
+        throw new Error("XLSX parsing not available in server environment");
+      let l;
+      try {
+        l = await import("xlsx");
+      } catch {
+        throw new Error(
+          "La dépendance 'xlsx' est requise pour l'import Excel. Installez-la avec: pnpm add xlsx (version >=0.18.0)"
+        );
+      }
+      const t = await i.arrayBuffer(), n = l.read(t, { type: "array" }), o = n.SheetNames[0], r = n.Sheets[o], a = l.utils.sheet_to_json(r, { header: 1 });
+      if (a.length === 0) return [];
+      const p = a[0];
+      return a.slice(1).map((f) => {
+        const c = f, u = {};
+        return p.forEach((L, I) => {
+          u[L] = c[I] ?? "";
+        }), u;
+      });
+    } catch {
+      throw new Error("Erreur lors du parsing du fichier XLSX");
+    }
+  }, []), O = d((i) => m.validate ? m.validate(i) : Array.isArray(i) ? i.length === 0 ? { valid: !1, errors: ["Aucune donnée trouvée"] } : { valid: !0, errors: [] } : { valid: !1, errors: ["Les données doivent être un tableau"] }, [m.validate]), D = d((i) => m.columnMapping ? i.map((l) => {
+    const t = {};
+    return Object.entries(m.columnMapping).forEach(([n, o]) => {
+      l[n] !== void 0 && (t[o] = l[n]);
+    }), t;
+  }) : i, [m.columnMapping]), U = d(async (i) => {
+    const l = i.name.split(".").pop()?.toLowerCase();
+    let t = [];
+    try {
+      const n = await i.text();
+      switch (l) {
+        case "csv":
+          t = E(n, m.parseOptions?.csv?.delimiter);
+          break;
+        case "json":
+          t = k(n);
+          break;
+        case "xml":
+          t = v(n);
+          break;
+        case "xlsx":
+          t = await S(i);
+          break;
+        default:
+          throw new Error(`Format de fichier non supporté: ${l}`);
+      }
+      const o = O(t);
+      if (!o.valid)
+        throw new Error(`Données invalides: ${o.errors.join(", ")}`);
+      const r = D(t);
+      return m.onImport && m.onImport(r), r;
+    } catch (n) {
+      throw M(n, {
+        code: F.DATATABLE_IMPORT_FAILED,
+        context: `DataTable.importData(${i.name})`,
+        onError: e
+      });
+    }
+  }, [m, E, k, v, S, O, D, e]), R = d(() => {
+    const i = document.createElement("input");
+    return i.type = "file", i.accept = m.accept, i.multiple = !1, i;
+  }, [m.accept]), V = d(() => new Promise((i, l) => {
+    const t = R();
+    t.onchange = async (n) => {
+      const o = n.target.files?.[0];
+      if (!o) {
+        l(new Error("Aucun fichier sélectionné"));
+        return;
+      }
+      try {
+        const r = await U(o);
+        i(r);
+      } catch (r) {
+        l(r);
+      }
+    }, t.click();
+  }), [R, U]), P = d(async (i, l) => {
+    const t = i.name.split(".").pop()?.toLowerCase();
+    b.current = new AbortController();
+    const n = b.current.signal;
+    y(!0), x(0);
+    const o = (r) => {
+      x(r), l?.onProgress?.(r);
+    };
+    try {
+      const r = await i.text();
+      let a = [];
+      const p = r.split(`
+`).length;
+      switch (t) {
+        case "csv":
+          p > G ? a = await w(
+            r,
+            m.parseOptions?.csv?.delimiter,
+            o,
+            n
+          ) : (a = E(r, m.parseOptions?.csv?.delimiter), o(100));
+          break;
+        case "json":
+          a = await g(r, o, n);
+          break;
+        case "xml":
+          a = v(r), o(100);
+          break;
+        case "xlsx":
+          a = await S(i), o(100);
+          break;
+        default:
+          throw new Error(`Format de fichier non supporté: ${t}`);
+      }
+      if (n.aborted)
+        throw new Error("Import annulé");
+      const f = O(a);
+      if (!f.valid)
+        throw new Error(`Données invalides: ${f.errors.join(", ")}`);
+      let c;
+      if (a.length > G && m.columnMapping) {
+        c = [];
+        for (let u = 0; u < a.length; u += j) {
+          if (n.aborted)
+            throw new Error("Import annulé");
+          const L = a.slice(u, u + j), I = D(L);
+          c.push(...I), l?.onChunk?.(I, c.length), await new Promise((A) => setTimeout(A, 0));
+        }
+      } else
+        c = D(a);
+      return m.onImport && m.onImport(c), c;
+    } catch (r) {
+      throw M(r, {
+        code: F.DATATABLE_IMPORT_FAILED,
+        context: `DataTable.importDataStreaming(${i.name})`,
+        onError: e
+      });
+    } finally {
+      y(!1), b.current = null;
+    }
+  }, [m, E, w, k, g, v, S, O, D, e]), N = d(() => {
+    b.current && (b.current.abort(), y(!1), x(0));
+  }, []), B = d((i) => new Promise((l, t) => {
+    const n = R();
+    n.onchange = async (o) => {
+      const r = o.target.files?.[0];
+      if (!r) {
+        t(new Error("Aucun fichier sélectionné"));
+        return;
+      }
+      try {
+        const a = await P(r, i);
+        l(a);
+      } catch (a) {
+        t(a);
+      }
+    }, n.click();
+  }), [R, P]);
+  return {
+    // Import standard (synchrone)
+    importData: U,
+    importWithUI: V,
+    // Import streaming (pour fichiers volumineux)
+    importDataStreaming: P,
+    importWithUIStreaming: B,
+    cancelImport: N,
+    // État du streaming
+    importProgress: s,
+    isImporting: T,
+    // Utilitaires
+    supportedFormats: m.accept?.split(",") || [],
+    isFormatSupported: (i) => {
+      const l = i.split(".").pop()?.toLowerCase();
+      return m.accept?.includes(l || "") || !1;
+    }
+  };
+}
+export {
+  F as E,
+  ee as L,
+  _ as W,
+  me as a,
+  ae as b,
+  ce as c,
+  ie as d,
+  le as e,
+  M as h,
+  te as i,
+  z as l,
+  ue as r,
+  oe as t,
+  pe as u,
+  se as w
+};