fuse-importer 0.23.8 → 0.24.0

package/lib/esm/Importer/{theme.d.ts → common/theme.d.ts}

@@ -1,4 +1,4 @@
-import { theme } from "../styled/theme";
+import { theme } from "../../styled/theme";
 export declare type ImporterStylePreferences = {
     id: number;
     background: string;
@@ -13,7 +13,7 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
     theme: {
         readonly colors: {
             backgroundInterface: string;
-            interactiveDisabled: string;
+            interactiveDisabled: "#FEB0BD";
             error: string;
             warning01: string;
             highlight01: string;
@@ -112,6 +112,7 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             buttonText: import("styled-components").FlattenSimpleInterpolation;
             buttonTextSmall: import("styled-components").FlattenSimpleInterpolation;
             link: import("styled-components").FlattenSimpleInterpolation;
+            stepper: import("styled-components").FlattenSimpleInterpolation;
         };
         readonly css: {
             pt: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
@@ -134,6 +135,9 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             yscroll: import("styled-components").FlattenSimpleInterpolation;
             overflowHidden: import("styled-components").FlattenSimpleInterpolation;
             rotate180: import("styled-components").FlattenSimpleInterpolation;
+            rotate180If: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<{
+                rotate180If: boolean;
+            }, any>>;
             forMobile: import("styled-components").FlattenSimpleInterpolation;
             forDesktop: import("styled-components").FlattenSimpleInterpolation;
             mcontainer: import("styled-components").FlattenSimpleInterpolation;
@@ -148,6 +152,7 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             bgred: import("styled-components").FlattenSimpleInterpolation;
             bgblue: import("styled-components").FlattenSimpleInterpolation;
             opacity5: import("styled-components").FlattenSimpleInterpolation;
+            divider: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
             semiBold: import("styled-components").FlattenSimpleInterpolation;
             bold: import("styled-components").FlattenSimpleInterpolation;
             extraBold: import("styled-components").FlattenSimpleInterpolation;
@@ -175,6 +180,7 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             buttonText: import("styled-components").FlattenSimpleInterpolation;
             buttonTextSmall: import("styled-components").FlattenSimpleInterpolation;
             link: import("styled-components").FlattenSimpleInterpolation;
+            stepper: import("styled-components").FlattenSimpleInterpolation;
             truncateText: import("styled-components").FlattenSimpleInterpolation;
             dInline: import("styled-components").FlattenSimpleInterpolation;
             flexWrap: import("styled-components").FlattenSimpleInterpolation;
@@ -204,12 +210,16 @@ declare const getCustomTheme: (importerStylePreferences: ImporterStylePreference
             pSticky: import("styled-components").FlattenSimpleInterpolation;
             floatLeft: import("styled-components").FlattenSimpleInterpolation;
             w50: import("styled-components").FlattenSimpleInterpolation;
-            w100: import("styled-components").FlattenSimpleInterpolation;
+            w100: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<{
+                w100: boolean;
+            }, any>>;
             h100: import("styled-components").FlattenSimpleInterpolation;
             w: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
             h: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
             dim: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
-            maxw: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
+            maxw: import("styled-components").FlattenInterpolation<import("styled-components").ThemedStyledProps<{
+                maxw?: number;
+            }, any>>;
             maxh: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
             minw: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;
             minh: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<any>>;

package/lib/esm/Importer/{theme.js → common/theme.js}

@@ -9,7 +9,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { theme } from "../styled/theme";
+import { theme } from "../../styled/theme";
 var getCustomTheme = function (importerStylePreferences) {
     var primary_color = importerStylePreferences.primary_color, secondary_color = importerStylePreferences.secondary_color, highlight1 = importerStylePreferences.highlight1, highlight2 = importerStylePreferences.highlight2, background = importerStylePreferences.background;
     var customTheme = __assign(__assign({}, theme), { colors: __assign(__assign({}, theme.colors), { pink500: primary_color, black: secondary_color, blue500: highlight1, blue100: highlight2, backgroundInterface: background }) });

package/lib/esm/Importer/common/utils.d.ts

@@ -1,11 +1,9 @@
-import { AppResponse, BatchValidationErrors, Record, RowValidationError } from "../../types";
-import { TemplateHeader } from "../ImporterContextProvider";
+import { Integration, Record, TemplateHeader } from "../../types";
 export declare const getSpreadsheetRowWidth: (fields: any, visibleRowsOnTableViewport: any) => number;
-export declare const getUnsubmittedData: (data: Record[], appResponse: AppResponse) => Record[];
 declare type IsEnumFieldArgs = {
     templateLabel: string;
     templateHeaders: TemplateHeader[];
 };
 export declare const getColumnType: ({ templateLabel, templateHeaders, }: IsEnumFieldArgs) => string;
-export declare const formatBatchErrors: (errors: RowValidationError[]) => BatchValidationErrors;
+export declare const sendRecordsToIntegrations: (reviewedData: Record[], integrations: Integration[]) => Promise<void>;
 export {};

package/lib/esm/Importer/common/utils.js

@@ -1,34 +1,89 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
 };
+import axios from "axios";
 export var getSpreadsheetRowWidth = function (fields, visibleRowsOnTableViewport) {
     var res = fields.length / visibleRowsOnTableViewport;
     return res > 1 ? res : 1;
 };
-export var getUnsubmittedData = function (data, appResponse) {
-    var unsubmittedData = data;
-    if (appResponse === null || appResponse === void 0 ? void 0 : appResponse.errors)
-        unsubmittedData = data.filter(function (r) { return !!r._meta.appValidationErrors; });
-    return unsubmittedData;
-};
 export var getColumnType = function (_a) {
     var _b;
     var templateLabel = _a.templateLabel, templateHeaders = _a.templateHeaders;
     return (_b = templateHeaders.find(function (th) { return th.label === templateLabel; })) === null || _b === void 0 ? void 0 : _b.column_type;
 };
-export var formatBatchErrors = function (errors) {
-    var res = errors.reduce(function (prevState, curr) {
-        var newState = __assign({}, prevState);
-        newState[curr.rowId] = curr.errors;
-        return newState;
-    }, {});
-    return res;
-};
+export var sendRecordsToIntegrations = function (reviewedData, integrations) { return __awaiter(void 0, void 0, void 0, function () {
+    var _i, reviewedData_1, record, _a, integrations_1, integration, url, trigger_type, instance, error_1;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _i = 0, reviewedData_1 = reviewedData;
+                _b.label = 1;
+            case 1:
+                if (!(_i < reviewedData_1.length)) return [3 /*break*/, 8];
+                record = reviewedData_1[_i];
+                _a = 0, integrations_1 = integrations;
+                _b.label = 2;
+            case 2:
+                if (!(_a < integrations_1.length)) return [3 /*break*/, 7];
+                integration = integrations_1[_a];
+                url = integration.url, trigger_type = integration.trigger_type;
+                if (!(trigger_type === "webhook")) return [3 /*break*/, 6];
+                _b.label = 3;
+            case 3:
+                _b.trys.push([3, 5, , 6]);
+                instance = axios.create({
+                    baseURL: url,
+                    timeout: 1000,
+                    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                });
+                return [4 /*yield*/, instance.post("", record)];
+            case 4:
+                _b.sent();
+                return [3 /*break*/, 6];
+            case 5:
+                error_1 = _b.sent();
+                console.log(error_1);
+                return [3 /*break*/, 6];
+            case 6:
+                _a++;
+                return [3 /*break*/, 2];
+            case 7:
+                _i++;
+                return [3 /*break*/, 1];
+            case 8: return [2 /*return*/];
+        }
+    });
+}); };

package/lib/esm/Importer/{ImporterContextProvider.d.ts → contexts/ImporterContextProvider.d.ts}

@@ -1,8 +1,7 @@
 import Fuse from "fuse.js";
 import React from "react";
-import { ImporterOptions, OnValidateBatch, OnValidateRecord, FormatRecord } from "../types";
-import { ImporterStylePreferences } from "./theme";
-import { FuseApi } from "./FuseApi";
+import { FormatRecord, ImporterOptions, Integration, OnSubmit, OnValidateRecord, TemplateHeader } from "../../types";
+import { FuseApi } from "../common/FuseApi";
 export declare const fusejsOptions: Fuse.IFuseOptions<string>;
 export declare type HeaderMatchings = {
     [templateHeaderLabel: string]: string;
@@ -15,80 +14,46 @@ export declare type EnumFieldValueMatchings = {
 export declare type UploadedDataEnumFieldValues = {
     [templateHeaderLabel: string]: string[];
 };
-export declare type TemplateHeader = {
-    label: string;
-    required: boolean;
-    unique: boolean;
-    column_type: string;
-    internal_key: string;
-    values: string[];
-    pattern: string;
-};
-export declare type Organization = {
-    id: number;
-    name: string;
-    trial_mode: boolean;
-    plan: {
-        title: string;
-        allow_style_customization: boolean;
-        has_records_limit: boolean;
-        allowed_records: number;
-    };
-};
-export declare type Column = {
-    column_type: string;
-    internal_key: string;
-    label: string;
-    pattern: string;
-    required: boolean;
-    unique: boolean;
-    values: string[];
-};
 export declare type State = {
-    resetImport: () => void;
     currentStepIndex: number;
-    setCurrentStepIndex: React.Dispatch<number>;
     templateError: string | null;
     uploadedData: any[];
     enumFieldValueMatchings: EnumFieldValueMatchings;
-    setEnumFieldValueMatchings: React.Dispatch<React.SetStateAction<EnumFieldValueMatchings>>;
-    setUploadedData: React.Dispatch<any[]>;
     templateHeaders: TemplateHeader[];
     templateHeaderMatchings: HeaderMatchings;
-    setTemplateHeaderMatchings: React.Dispatch<React.SetStateAction<HeaderMatchings>>;
     uploadedDataHeaders: string[];
-    onValidateRecord?: OnValidateRecord;
-    onValidateBatch?: OnValidateBatch;
     matcherSubstep: number;
-    setMatcherSubstep: React.Dispatch<number>;
     uploadedDataEnumFieldValues: UploadedDataEnumFieldValues;
     templateSlug: string;
     apiToken: string;
     inTrialMode: boolean;
-    onClose: () => void;
+    previewFirstTime: boolean;
     fuseApi: FuseApi;
-    formatRecord: FormatRecord;
     importerOptions: ImporterOptions;
     theme: any;
     logoURL: string;
-    isSpreadsheetValid: boolean;
-    setIsSpreadsheetValid: React.Dispatch<boolean>;
+    integrations: Integration[];
+    onSubmit: OnSubmit;
+    resetImport: () => void;
+    onClose: () => void;
+    setCurrentStepIndex: React.Dispatch<number>;
+    setEnumFieldValueMatchings: React.Dispatch<React.SetStateAction<EnumFieldValueMatchings>>;
+    setUploadedData: React.Dispatch<any[]>;
+    setTemplateHeaderMatchings: React.Dispatch<React.SetStateAction<HeaderMatchings>>;
+    setPreviewFirstTime: React.Dispatch<boolean>;
+    formatRecord: FormatRecord;
+    onValidateRecord?: OnValidateRecord;
+    setMatcherSubstep: React.Dispatch<number>;
 };
 export declare type Props = {
     templateSlug: string;
     apiToken: string;
     options: ImporterOptions;
-    onClose: () => void;
     children: JSX.Element;
+    onClose: () => void;
+    onSubmit: OnSubmit;
     formatRecord: FormatRecord;
     onValidateRecord?: OnValidateRecord;
-    onValidateBatch?: OnValidateBatch;
-};
-export declare type TemplateInfo = {
-    columns: Column[];
-    importer_style_preferences: ImporterStylePreferences;
-    organization: Organization;
-    name: string;
 };
-export declare const ImporterContextProvider: ({ templateSlug, apiToken, children, options, onClose, formatRecord, onValidateBatch, onValidateRecord, }: Props) => JSX.Element;
+export declare const ImporterContextProvider: ({ templateSlug, apiToken, children, options, onSubmit, onClose, formatRecord, onValidateRecord, }: Props) => JSX.Element;
 export declare const useImporterContext: () => State;

package/lib/esm/Importer/{ImporterContextProvider.js → contexts/ImporterContextProvider.js}

@@ -48,31 +48,32 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import { jsx as _jsx } from "react/jsx-runtime";
 import Fuse from "fuse.js";
 import { createContext, useContext, useEffect, useMemo, useState, } from "react";
-import { FieldTypes, } from "../types";
-import { getColumnType } from "./common/utils";
-import { theme, getCustomTheme, } from "./theme";
-import { FuseApi } from "./FuseApi";
+import { FieldTypes, } from "../../types";
+import { FuseApi } from "../common/FuseApi";
+import { getCustomTheme, theme } from "../common/theme";
+import { getColumnType } from "../common/utils";
 export var fusejsOptions = {
     includeScore: true,
     threshold: 0.35,
 };
 var ImporterContext = createContext({});
 export var ImporterContextProvider = function (_a) {
-    var templateSlug = _a.templateSlug, apiToken = _a.apiToken, children = _a.children, options = _a.options, onClose = _a.onClose, formatRecord = _a.formatRecord, onValidateBatch = _a.onValidateBatch, onValidateRecord = _a.onValidateRecord;
+    var templateSlug = _a.templateSlug, apiToken = _a.apiToken, children = _a.children, options = _a.options, onSubmit = _a.onSubmit, onClose = _a.onClose, formatRecord = _a.formatRecord, onValidateRecord = _a.onValidateRecord;
     var _b = useState(0), currentStepIndex = _b[0], setCurrentStepIndex = _b[1];
     var _c = useState(0), matcherSubstep = _c[0], setMatcherSubstep = _c[1];
     var _d = useState(null), templateError = _d[0], setTemplateError = _d[1];
     var _e = useState(null), templateHeaders = _e[0], setTemplateHeaders = _e[1];
-    var _f = useState(null), uploadedData = _f[0], setUploadedData = _f[1];
-    var _g = useState(null), organization = _g[0], setOrganization = _g[1];
-    var _h = useState({
+    var _f = useState(null), integrations = _f[0], setIntegrations = _f[1];
+    var _g = useState(null), uploadedData = _g[0], setUploadedData = _g[1];
+    var _h = useState(null), organization = _h[0], setOrganization = _h[1];
+    var _j = useState(null), previewFirstTime = _j[0], setPreviewFirstTime = _j[1];
+    var _k = useState({
         theme: theme,
         logoURL: null,
-    }), style = _h[0], setStyle = _h[1];
-    var _j = useState(null), templateHeaderMatchings = _j[0], setTemplateHeaderMatchings = _j[1];
-    var _k = useState(null), enumFieldValueMatchings = _k[0], setEnumFieldValueMatchings = _k[1];
-    var _l = useState(null), uploadedDataEnumFieldValues = _l[0], setUploadedDataEnumFieldValues = _l[1];
-    var _m = useState(false), isSpreadsheetValid = _m[0], setIsSpreadsheetValid = _m[1];
+    }), style = _k[0], setStyle = _k[1];
+    var _l = useState(null), templateHeaderMatchings = _l[0], setTemplateHeaderMatchings = _l[1];
+    var _m = useState(null), enumFieldValueMatchings = _m[0], setEnumFieldValueMatchings = _m[1];
+    var _o = useState(null), uploadedDataEnumFieldValues = _o[0], setUploadedDataEnumFieldValues = _o[1];
     var fuseApi = useMemo(function () { return new FuseApi(options.env, apiToken); }, [
         options.env,
         apiToken,
@@ -113,7 +114,7 @@ export var ImporterContextProvider = function (_a) {
     }, [uploadedData]);
     useEffect(function () {
         (function () { return __awaiter(void 0, void 0, void 0, function () {
-            var _a, organization_1, columns, importer_style_preferences, error_1, errorMsg;
+            var _a, organization_1, columns, importer_style_preferences, integrations_1, preview_first_time, error_1, errorMsg;
             var _b, _c;
             return __generator(this, function (_d) {
                 switch (_d.label) {
@@ -121,9 +122,11 @@ export var ImporterContextProvider = function (_a) {
                         _d.trys.push([0, 2, , 3]);
                         return [4 /*yield*/, fuseApi.get("/api/v1/importer/templates/".concat(templateSlug))];
                     case 1:
-                        _a = (_d.sent()).data, organization_1 = _a.organization, columns = _a.columns, importer_style_preferences = _a.importer_style_preferences;
+                        _a = (_d.sent()).data, organization_1 = _a.organization, columns = _a.columns, importer_style_preferences = _a.importer_style_preferences, integrations_1 = _a.integrations, preview_first_time = _a.preview_first_time;
                         setOrganization(organization_1);
                         setTemplateHeaders(columns);
+                        setIntegrations(integrations_1);
+                        setPreviewFirstTime(preview_first_time);
                         if (organization_1.plan && organization_1.plan.allow_style_customization) {
                             setStyle(getCustomTheme(importer_style_preferences));
                         }
@@ -155,34 +158,35 @@ export var ImporterContextProvider = function (_a) {
     };
     var inTrialMode = organization === null || organization === void 0 ? void 0 : organization.trial_mode;
     var value = {
-        setUploadedData: setUploadedData,
         currentStepIndex: currentStepIndex,
-        formatRecord: formatRecord,
-        setCurrentStepIndex: setCurrentStepIndex,
         templateHeaders: templateHeaders,
         enumFieldValueMatchings: enumFieldValueMatchings,
-        setEnumFieldValueMatchings: setEnumFieldValueMatchings,
         templateHeaderMatchings: templateHeaderMatchings,
         uploadedDataEnumFieldValues: uploadedDataEnumFieldValues,
         importerOptions: options,
-        setTemplateHeaderMatchings: setTemplateHeaderMatchings,
-        resetImport: resetImport,
         uploadedData: uploadedData,
         uploadedDataHeaders: uploadedDataHeaders,
         templateError: templateError,
-        onValidateBatch: onValidateBatch,
-        onValidateRecord: onValidateRecord,
         matcherSubstep: matcherSubstep,
-        setMatcherSubstep: setMatcherSubstep,
         apiToken: apiToken,
         templateSlug: templateSlug,
         inTrialMode: inTrialMode,
-        onClose: onClose,
         fuseApi: fuseApi,
         theme: style.theme,
         logoURL: style.logoURL,
-        isSpreadsheetValid: isSpreadsheetValid,
-        setIsSpreadsheetValid: setIsSpreadsheetValid,
+        integrations: integrations,
+        previewFirstTime: previewFirstTime,
+        setUploadedData: setUploadedData,
+        formatRecord: formatRecord,
+        setCurrentStepIndex: setCurrentStepIndex,
+        setEnumFieldValueMatchings: setEnumFieldValueMatchings,
+        setTemplateHeaderMatchings: setTemplateHeaderMatchings,
+        resetImport: resetImport,
+        onValidateRecord: onValidateRecord,
+        setMatcherSubstep: setMatcherSubstep,
+        onClose: onClose,
+        setPreviewFirstTime: setPreviewFirstTime,
+        onSubmit: onSubmit,
     };
     return (_jsx(ImporterContext.Provider, __assign({ value: value }, { children: children })));
 };

package/lib/esm/Importer/data/index.d.ts

@@ -0,0 +1,28 @@
+import { Field, FieldTypes, FormatRecord, Record, RecordDataSet, TemplateHeader } from "../../types";
+import { EnumFieldValueMatchings, HeaderMatchings } from "../contexts/ImporterContextProvider";
+export declare const addMeta: (record: any, index: number) => Record;
+export declare const recordListToDataSet: (data: Record[], fields: Field[]) => RecordDataSet;
+declare type transformToRecordsArgs = {
+    templateHeaderMatchings: HeaderMatchings;
+    enumFieldValueMatchings: EnumFieldValueMatchings;
+    uploadedDataHeaders: string[];
+    uploadedData: any[];
+    templateHeaders: TemplateHeader[];
+    formatRecord: FormatRecord;
+};
+export declare const getPreviewDataSet: ({ uploadedData, }: {
+    uploadedData: any[];
+}) => {
+    fields: {
+        label: string;
+        name: string;
+        type: FieldTypes;
+        isRequired: boolean;
+    }[];
+    initialDataSet: RecordDataSet;
+};
+export declare const getReviewDataSet: ({ templateHeaderMatchings, enumFieldValueMatchings, templateHeaders, uploadedDataHeaders, uploadedData, formatRecord, }: transformToRecordsArgs) => {
+    fields: Field[];
+    initialDataSet: RecordDataSet;
+};
+export {};

package/lib/esm/Importer/data/index.js

@@ -0,0 +1,134 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { FieldTypes, } from "../../types";
+import { parseValue } from "../common/Spreadsheet/common";
+var MINIMUM_ROW_COUNT = 20;
+var getRowId = function (index) {
+    var uniqueTimestamp = new Date().getTime();
+    return "r".concat(index, "-").concat(uniqueTimestamp);
+};
+var addEmptyRows = function (data, fields) {
+    var emptyRecord = fields.reduce(function (obj, f) {
+        var _a;
+        return (__assign(__assign({}, obj), (_a = {}, _a[f.name] = null, _a)));
+    }, {});
+    for (var i = data.length; i < MINIMUM_ROW_COUNT; i++) {
+        data.push(__assign(__assign({}, emptyRecord), { _meta: {
+                id: getRowId(i),
+                rowIndex: i,
+            } }));
+    }
+    return data;
+};
+export var addMeta = function (record, index) {
+    var _a;
+    var rId = getRowId(index);
+    var meta = (_a = record._meta) !== null && _a !== void 0 ? _a : {};
+    return __assign(__assign({}, record), { _meta: __assign(__assign({}, meta), { id: rId, rowIndex: index, touched: false }) });
+};
+export var recordListToDataSet = function (data, fields) {
+    var initialData = data;
+    if (data.length < MINIMUM_ROW_COUNT) {
+        initialData = addEmptyRows(data, fields);
+    }
+    return initialData.reduce(function (dataSet, record, i) {
+        var recordWithMeta = addMeta(record, i);
+        dataSet[recordWithMeta._meta.id] = recordWithMeta;
+        return dataSet;
+    }, {});
+};
+var transformToRecords = function (_a) {
+    var templateHeaderMatchings = _a.templateHeaderMatchings, enumFieldValueMatchings = _a.enumFieldValueMatchings, templateHeaders = _a.templateHeaders, uploadedDataHeaders = _a.uploadedDataHeaders, uploadedData = _a.uploadedData, formatRecord = _a.formatRecord;
+    var matchedColumnsLabels = Object.keys(templateHeaderMatchings)
+        .filter(function (label) { return !!templateHeaderMatchings[label]; })
+        .map(function (label) { return ({
+        label: label,
+        index: uploadedDataHeaders.indexOf(templateHeaderMatchings[label]),
+    }); });
+    var templateHeadersByLabel = templateHeaders.reduce(function (byLabel, header) {
+        var _a;
+        return (__assign(__assign({}, byLabel), (_a = {}, _a[header.label] = header, _a)));
+    }, {});
+    var getRecord = function (row, index) {
+        var record = addMeta({}, index);
+        matchedColumnsLabels.forEach(function (_a) {
+            var label = _a.label, index = _a.index;
+            var enumSet = enumFieldValueMatchings
+                ? enumFieldValueMatchings[label]
+                : null;
+            var header = templateHeadersByLabel[label];
+            if (!header)
+                return;
+            var key = header.internal_key;
+            var value = row[index];
+            if (value === undefined)
+                return;
+            record[key] = parseValue(FieldTypes[header.column_type], value, enumSet);
+        });
+        return formatRecord ? formatRecord(record) : record;
+    };
+    return uploadedData.slice(1).map(getRecord);
+};
+export var getPreviewDataSet = function (_a) {
+    var uploadedData = _a.uploadedData;
+    var getFirstRowLen = function () {
+        if (uploadedData.length > 0 && Array.isArray(uploadedData[0])) {
+            return uploadedData[0].length;
+        }
+        return 0;
+    };
+    var fields = new Array(getFirstRowLen()).fill(null).map(function (_, i) {
+        var key = String.fromCharCode(65 + i);
+        return {
+            label: key,
+            name: key,
+            type: FieldTypes.string,
+            isRequired: false,
+        };
+    });
+    var getInitialDataSet = function () {
+        //Showing only the first 100 rows to improve performance
+        //TODO: Check with Mike
+        var data = uploadedData.slice(0, 100).map(function (row, index) {
+            var entry = addMeta({}, index);
+            fields.forEach(function (field, index) {
+                entry[field.name] = row[index];
+            });
+            return entry;
+        });
+        return recordListToDataSet(data, fields);
+    };
+    return { fields: fields, initialDataSet: getInitialDataSet() };
+};
+export var getReviewDataSet = function (_a) {
+    var templateHeaderMatchings = _a.templateHeaderMatchings, enumFieldValueMatchings = _a.enumFieldValueMatchings, templateHeaders = _a.templateHeaders, uploadedDataHeaders = _a.uploadedDataHeaders, uploadedData = _a.uploadedData, formatRecord = _a.formatRecord;
+    var fields = templateHeaders.map(function (templateHeader) { return ({
+        label: templateHeader.label,
+        name: templateHeader.internal_key,
+        type: FieldTypes[templateHeader.column_type] || FieldTypes.string,
+        isRequired: templateHeader.required,
+        isUnique: templateHeader.unique,
+        options: templateHeader.values,
+        pattern: templateHeader.pattern,
+        validations: templateHeader.validations,
+    }); });
+    var records = transformToRecords({
+        templateHeaderMatchings: templateHeaderMatchings,
+        enumFieldValueMatchings: enumFieldValueMatchings,
+        templateHeaders: templateHeaders,
+        uploadedDataHeaders: uploadedDataHeaders,
+        uploadedData: uploadedData,
+        formatRecord: formatRecord,
+    });
+    var initialDataSet = recordListToDataSet(addEmptyRows(records, fields), fields);
+    return { fields: fields, initialDataSet: initialDataSet };
+};

package/lib/esm/Importer/index.d.ts

@@ -1,22 +1,22 @@
 /// <reference types="react" />
-import { FormatRecord, ImporterOptions, OnSubmit, OnValidateBatch, OnValidateRecord } from "../types";
-declare type LayoutProps = {
-    zIndex: number;
+import { FormatRecord, ImporterOptions, OnSubmit, OnValidateRecord } from "../types";
+export declare const ACCOUNT_ROUTES: {
+    TEMPLATES: string;
 };
-export declare const Layout: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../styled/utils").CSSProps & LayoutProps, never>;
-declare type Props = {
+export declare const ACCOUNT_VIEW_PATH = "/account";
+export declare const TEMPLATES_ROUTE: string;
+declare type ImporterProps = {
     templateSlug: string;
     apiToken: string;
     options: ImporterOptions;
+    previewMode?: boolean;
     formatRecord: FormatRecord;
     onValidateRecord?: OnValidateRecord;
-    onValidateBatch?: OnValidateBatch;
     onSubmit?: OnSubmit;
-    onClose: any;
-    previewMode?: boolean;
+    onClose: () => void;
 };
-declare const Importer: ({ templateSlug, apiToken, onSubmit, onValidateRecord, onValidateBatch, formatRecord, options, onClose, }: Props) => JSX.Element;
+declare const Importer: ({ templateSlug, apiToken, options, formatRecord, onValidateRecord, onSubmit, onClose, }: ImporterProps) => JSX.Element;
 export * from "./common/Spreadsheet";
 export * from "./common/utils";
-export * from "./SpreadsheetReviewContextProvider";
+export * from "./Review/ReviewContextProvider";
 export { Importer };