@updog/data-editor-wc 0.1.74 → 0.1.76

package/index.d.ts

@@ -483,6 +483,8 @@ declare var export_default = {
         csvWarning_one: "{{count}} row had formatting issues (row {{rows}})",
         csvWarning_other:
           "{{count}} rows had formatting issues (rows {{rows}})",
+        customEmpty: "No tables were found in this file",
+        customFailed: "Could not process the file",
         downloadExample: "Download sample file",
         fileInputLabel: "Choose files to upload",
         fileTooLarge: "The file is too large to process",
@@ -529,6 +531,7 @@ declare var export_default = {
           "Unmatched columns won't be imported. Match this column to keep the data. You can transform columns after importing.",
       },
       sheetPreview: {
+        cancel: "Cancel processing",
         emptySheet: "Empty sheet",
         rowCount_one: "{{count}} row",
         rowCount_other: "{{count}} rows",
@@ -1147,8 +1150,13 @@ type DataEditorResult<TRow extends DataEditorRow = DataEditorRow> = {
         invalid: number;
     };
     /**
-     * Import mappings the user confirmed that weren't already known, split into
-     * `columns` and `values`. Persist and feed back through `synonyms` so repeat
+     * Import mappings the user changed **by hand** in the wizard, split into
+     * `columns` (header → column title) and `values` (imported value → option).
+     * Mappings the SDK matched on its own are excluded, as are mappings returned
+     * by `onColumnMatch` / `onValueMatch` and pairs the synonym tables already
+     * cover. A cancelled import contributes nothing.
+     *
+     * Persist and feed back through `synonyms` — the shapes line up — so repeat
      * imports auto-match. Each list is `[]` when nothing new was learned.
      */
     learnedSynonyms: LearnedSynonyms;
@@ -1256,6 +1264,47 @@ type RemoteSource = {
      */
     fetch: () => Promise<File | Record<string, unknown>[]>;
 };
+/** One table returned by a custom format handler. */
+type CustomImportTable = {
+    /** Table name, shown on the preview card. */
+    name: string;
+    rows: Record<string, unknown>[];
+};
+/**
+ * A file format the SDK cannot read, handled by client code.
+ *
+ * The SDK accepts the file, hands it to `handle()`, and stages whatever comes
+ * back. You own the processing; nothing about the file reaches Updog.
+ *
+ * @example
+ * ```ts
+ * const pdf: CustomImportFormat = {
+ *   label: "PDF",
+ *   extensions: [".pdf"],
+ *   handle: async (file, { signal }) => {
+ *     const body = new FormData();
+ *     body.append("file", file);
+ *     const res = await fetch("/api/extract", { method: "POST", body, signal });
+ *     return res.json(); // Record<string, unknown>[]
+ *   },
+ * };
+ * ```
+ */
+type CustomImportFormat = {
+    /** Shown in the format hint under the drop zone, e.g. "PDF". */
+    label: string;
+    /** Extensions this handler claims, leading dot included. */
+    extensions: string[];
+    /** Optional MIME match, wildcards allowed: `["image/*"]`. */
+    mimeTypes?: string[];
+    /**
+     * Returns rows, named tables, or a `File` in a format the SDK already reads.
+     * Throw to fail the import; the thrown message is shown to the user.
+     */
+    handle: (file: File, ctx: {
+        signal: AbortSignal;
+    }) => Promise<File | Record<string, unknown>[] | CustomImportTable[]>;
+};
 /**
  * Controls the initial view when the editor opens.
  *
@@ -1371,6 +1420,11 @@ type DataEditorBaseProps<TRow extends DataEditorRow = DataEditorRow> = {
      * the result of `fetch()`.
      */
     remoteSources?: RemoteSource[];
+    /**
+     * File formats the SDK cannot read, handled by your own code. The SDK accepts
+     * the file and stages whatever `handle()` returns.
+     */
+    customFormats?: CustomImportFormat[];
     /**
      * Which file formats the user can export to. `undefined` allows all
      * formats, `false` disables export entirely.
@@ -1420,24 +1474,31 @@ type DataEditorBaseProps<TRow extends DataEditorRow = DataEditorRow> = {
      */
     onValueMatch?: (valuesToMatch: Record<string, ValueMatchInput>) => ValueMatchOutput | Promise<ValueMatchOutput>;
     /**
-     * Extra synonyms layered on top of the built-ins for both column matching
-     * (header vs column) and value matching (imported value vs select option).
-     * Each key is the canonical target (a column ID/title, or a select option
-     * value); the array lists aliases the matching engine should treat as
-     * equivalent. Merged with the built-ins as a union per key.
+     * Extra synonyms layered on top of the built-ins, in two tables that stay
+     * apart: `columns` scores a file header against your columns, `values`
+     * scores an imported cell against a select option. Each key is the canonical
+     * target (a column ID/title, or an option value); the array lists aliases the
+     * matching engine treats as equivalent. Merged with the built-ins per key.
+     *
+     * Feed `result.learnedSynonyms` straight back — it comes out in this shape.
      *
      * @example
      * ```ts
      * synonyms={{
-     *   // column aliases
-     *   productSku: ["sku", "article_no", "item_code"],
-     *   firstName: ["first", "given_name", "fname"],
-     *   // value aliases (e.g. for a "status" select)
-     *   Active: ["live", "enabled"],
+     *   columns: {
+     *     productSku: ["sku", "article_no", "item_code"],
+     *     firstName: ["first", "given_name", "fname"],
+     *   },
+     *   values: {
+     *     Active: ["live", "enabled"],
+     *   },
      * }}
      * ```
      */
-    synonyms?: Record<string, string[]>;
+    synonyms?: {
+        columns?: Record<string, string[]>;
+        values?: Record<string, string[]>;
+    };
     /**
      * Sample rows included in the "Download Example" file. When the user clicks
      * "Download Example" in the import wizard, the SDK generates a template