fuse-importer 0.0.1-staging

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

@@ -0,0 +1,17 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { colors } from "../../styled/theme/colorPalette";
+import { Div } from "../../styled/utils";
+import { logoIcon } from "./icons";
+var Footer = function () { return (_jsx(Div, __assign({ centered: true, c: colors.gray600, pt: 65, pb: 50 }, { children: logoIcon }))); };
+export { Footer };

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

@@ -0,0 +1,12 @@
+import { EnvironmentType } from "../../types";
+import { AxiosRequestConfig, AxiosResponse } from "axios";
+export declare class FuseApi {
+    environment: EnvironmentType;
+    apiToken: string;
+    constructor(environment: any, apiToken: any);
+    get<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+    post<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    patch<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    put<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    delete<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
+}

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

@@ -0,0 +1,48 @@
+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 { api } from "../../api";
+import { baseUrls } from "./index";
+// copies the axios request config from axios.AxiosInstance type and adds
+// baseUrl based on environment and api key
+var FuseApi = /** @class */ (function () {
+    function FuseApi(environment, apiToken) {
+        this.environment = environment;
+        this.apiToken = apiToken;
+    }
+    FuseApi.prototype.get = function (url, config) {
+        return api.get(url, __assign(__assign({}, config), { toPublicApi: true, baseURL: baseUrls[this.environment], params: {
+                api_token: this.apiToken,
+            } }));
+    };
+    FuseApi.prototype.post = function (url, data, config) {
+        return api.post(url, data, __assign(__assign({}, config), { toPublicApi: true, baseURL: baseUrls[this.environment], params: {
+                api_token: this.apiToken,
+            } }));
+    };
+    FuseApi.prototype.patch = function (url, data, config) {
+        return api.patch(url, data, __assign(__assign({}, config), { toPublicApi: true, baseURL: baseUrls[this.environment], params: {
+                api_token: this.apiToken,
+            } }));
+    };
+    FuseApi.prototype.put = function (url, data, config) {
+        return api.put(url, data, __assign(__assign({}, config), { toPublicApi: true, baseURL: baseUrls[this.environment], params: {
+                api_token: this.apiToken,
+            } }));
+    };
+    FuseApi.prototype.delete = function (url, config) {
+        return api.delete(url, __assign(__assign({}, config), { toPublicApi: true, baseURL: baseUrls[this.environment], params: {
+                api_token: this.apiToken,
+            } }));
+    };
+    return FuseApi;
+}());
+export { FuseApi };

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

@@ -0,0 +1 @@
+export declare const GlobalStyle: import("styled-components").GlobalStyleComponent<{}, import("styled-components").DefaultTheme>;

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

@@ -0,0 +1,7 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import { createGlobalStyle } from "styled-components";
+export var GlobalStyle = createGlobalStyle(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  #fuse-importer-root > *,\n  body > * {\n    font-size: 17px;\n    margin: 0;\n    padding: 0;\n    top: 0;\n    left: 0;\n    font-family: DM Sans;\n    color-scheme: normal;\n    color: black;\n  }\n"], ["\n  #fuse-importer-root > *,\n  body > * {\n    font-size: 17px;\n    margin: 0;\n    padding: 0;\n    top: 0;\n    left: 0;\n    font-family: DM Sans;\n    color-scheme: normal;\n    color: black;\n  }\n"])));
+var templateObject_1;

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

@@ -0,0 +1 @@
+export declare const ImporterFonts: () => JSX.Element;

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

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Helmet } from "react-helmet";
+export var ImporterFonts = function () {
+    return (_jsxs(Helmet, { children: [_jsx("link", { rel: "preconnect", href: "https://fonts.googleapis.com" }), _jsx("link", { rel: "preconnect", href: "https://fonts.gstatic.com", crossOrigin: "" }), _jsx("link", { href: "https://fonts.googleapis.com/css?family=Montserrat:300,400,500,600&display=swap", rel: "stylesheet" }), _jsx("link", { href: "https://fonts.googleapis.com/css?family=DM+Serif+Text:300,400,500,600&display=swap", rel: "stylesheet" }), _jsx("link", { href: "https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&family=DM+Serif+Display&family=DM+Serif+Text&display=swap", rel: "stylesheet" }), _jsx("link", { href: "https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&family=DM+Serif+Text&display=swap", rel: "stylesheet" })] }));
+};

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/filterMethods.d.ts

@@ -0,0 +1,5 @@
+import { BatchValidationErrors, RecordDataSet } from "../../../../types";
+import { SpreadsheetFilter } from "./useSpreadsheetFilter";
+export declare const filterRecordsBySearchValue: (obj: RecordDataSet, value: string) => RecordDataSet;
+export declare const filterRecordsByType: (obj: RecordDataSet, filterType: SpreadsheetFilter["byRow"]) => RecordDataSet;
+export declare const filterRecordsByError: (obj: RecordDataSet, keyToFilter: string, errors: BatchValidationErrors) => RecordDataSet;

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/filterMethods.js

@@ -0,0 +1,67 @@
+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);
+};
+//Filter records by search value
+export var filterRecordsBySearchValue = function (obj, value) {
+    var isObject = function (value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    };
+    var includesSearchValue = function (value, searchValue) {
+        if (typeof value === "string" || typeof value === "number") {
+            var stringValue = String(value).toLowerCase();
+            var searchValueLower = searchValue.toLowerCase();
+            return stringValue.includes(searchValueLower);
+        }
+        return false;
+    };
+    var filteredObj = {};
+    for (var _i = 0, _a = Object.entries(obj); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], currentObj = _b[1];
+        if (!isObject(currentObj)) {
+            continue;
+        }
+        var matches = Object.values(currentObj).some(function (propertyValue) {
+            return includesSearchValue(propertyValue, value);
+        });
+        if (matches) {
+            filteredObj[key] = currentObj;
+        }
+    }
+    return filteredObj;
+};
+export var filterRecordsByType = function (obj, filterType) {
+    var rowIsEmpty = function (row) {
+        return Object.keys(row).every(function (key) {
+            if (key === "_meta")
+                return true;
+            return !row[key];
+        });
+    };
+    var filteredKeys = Object.keys(obj).filter(function (key) {
+        var _a, _b;
+        return filterType === "all" ||
+            (((_b = (_a = obj[key]) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.isInvalid) !== (filterType === "valid") &&
+                !rowIsEmpty(obj[key]));
+    });
+    return filteredKeys.reduce(function (acc, key) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[key] = obj[key], _a)));
+    }, {});
+};
+//Filter records by selected column error
+export var filterRecordsByError = function (obj, keyToFilter, errors) {
+    var filteredObj = {};
+    var filteredKeys = Object.keys(errors).filter(function (key) { var _a, _b; return ((_b = (_a = obj[key]) === null || _a === void 0 ? void 0 : _a._meta) === null || _b === void 0 ? void 0 : _b.isInvalid) && errors[key][keyToFilter]; });
+    for (var i = 0; i < filteredKeys.length; i++) {
+        filteredObj[filteredKeys[i]] = obj[filteredKeys[i]];
+    }
+    return filteredObj;
+};

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/index.d.ts

@@ -0,0 +1,47 @@
+import React from "react";
+import { SpreadsheetOptions } from "../../../..";
+import { BatchValidationErrors, Field, Record, RecordDataSet } from "../../../../types";
+import { SortBy, SpreadsheetProps } from "../common/types";
+import { ValidationState } from "../hooks";
+import { SpreadsheetFilter } from "./useSpreadsheetFilter";
+export type OnDataSetChanged = (dataSet: RecordDataSet) => void;
+export type OnValidationStateChanged = (state: ValidationState) => void;
+type State = {
+    data: Record[];
+    fields: Field[];
+    isLoading: boolean;
+    isReadOnly?: boolean;
+    errors: BatchValidationErrors;
+    warnings: BatchValidationErrors;
+    highlightFirstRow: boolean;
+    options: SpreadsheetOptions;
+    sortByFieldErrors: string;
+    sortByFieldWarnings: string;
+    updateRecord: (record: Record) => void;
+    setIsLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    setSortByFieldErrors: React.Dispatch<React.SetStateAction<string>>;
+    selectedRows: string[];
+    setSelectedRows: React.Dispatch<React.SetStateAction<string[]>>;
+    setSortByFieldWarnings: React.Dispatch<React.SetStateAction<string>>;
+    deleteRecords: (selectedRecords: string[]) => void;
+    lastClickedIndexRef: React.MutableRefObject<number | null>;
+    filteredInputValue: string;
+    setFilteredInputValue: React.Dispatch<React.SetStateAction<string>>;
+    addNewRowsToSpreadsheet: () => void;
+    spreadsheetFilter: SpreadsheetFilter;
+    filterRecordsByRowType: (filterByRow: SpreadsheetFilter["byRow"]) => void;
+    filterRecordsByFieldErrors: (filterByColumn: string) => void;
+    resetSpreadsheetFilter: () => void;
+    recordsWithValuesCount: number;
+    filteredDataCount: number;
+    checkboxColumnWidth: number;
+    isFiltering: boolean;
+    sortBy: SortBy | null;
+    setSortBy: React.Dispatch<React.SetStateAction<SortBy>>;
+} & ValidationState;
+type Props = SpreadsheetProps & {
+    children: JSX.Element;
+};
+export declare const SpreadsheetContextProvider: ({ initialDataSet, fields, options, isReadOnly, highlightFirstRow, children, onValidateRecord, onDataSetChanged, onValidationStateChanged, selectedRows, setSelectedRows, getSortCompareFn, }: Props) => JSX.Element;
+export declare const useSpreadsheetContext: () => State;
+export {};

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/index.js

@@ -0,0 +1,167 @@
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { get } from "lodash";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { addMeta } from "../../../data";
+import { useValidationState } from "../hooks";
+import { useSpreadsheetFilter, } from "./useSpreadsheetFilter";
+import { filterRecordsByType, filterRecordsByError, filterRecordsBySearchValue, } from "./filterMethods";
+import { hasValueInAnyField } from "./utils";
+var getDefaultSortCompareFn = function (sortBy) {
+    return function (a, b) {
+        var aField = get(a, sortBy.field);
+        var bField = get(b, sortBy.field);
+        if (aField === bField)
+            return a._meta.rowIndex > b._meta.rowIndex ? 1 : -1;
+        if (!aField)
+            return 1;
+        if (!bField)
+            return -1;
+        if (sortBy.direction === "asc")
+            return aField > bField ? 1 : -1;
+        return aField < bField ? 1 : -1;
+    };
+};
+var SpreadsheetContext = createContext({});
+export var SpreadsheetContextProvider = function (_a) {
+    var initialDataSet = _a.initialDataSet, fields = _a.fields, options = _a.options, isReadOnly = _a.isReadOnly, highlightFirstRow = _a.highlightFirstRow, children = _a.children, onValidateRecord = _a.onValidateRecord, onDataSetChanged = _a.onDataSetChanged, onValidationStateChanged = _a.onValidationStateChanged, selectedRows = _a.selectedRows, setSelectedRows = _a.setSelectedRows, _b = _a.getSortCompareFn, getSortCompareFn = _b === void 0 ? getDefaultSortCompareFn : _b;
+    var _c = useState(initialDataSet), dataSet = _c[0], setDataSet = _c[1];
+    var _d = useState(false), isLoading = _d[0], setIsLoading = _d[1];
+    var _e = useState(null), sortByFieldErrors = _e[0], setSortByFieldErrors = _e[1];
+    var _f = useState(null), sortByFieldWarnings = _f[0], setSortByFieldWarnings = _f[1];
+    var _g = useState(""), filteredInputValue = _g[0], setFilteredInputValue = _g[1];
+    var _h = useState(null), sortBy = _h[0], setSortBy = _h[1];
+    var addRowTimeoutRef = useRef(null);
+    var _j = useSpreadsheetFilter(), spreadsheetFilter = _j.spreadsheetFilter, filterRecordsByRowType = _j.filterRecordsByRowType, filterRecordsByFieldErrors = _j.filterRecordsByFieldErrors, resetSpreadsheetFilter = _j.resetSpreadsheetFilter;
+    var _k = useValidationState({
+        dataSet: dataSet,
+        initialDataSet: initialDataSet,
+        fields: fields,
+        options: options,
+        isReadOnly: isReadOnly,
+        setDataSet: setDataSet,
+        setIsLoading: setIsLoading,
+        onValidateRecord: onValidateRecord,
+    }), updateRecordAndRevalidate = _k.updateRecordAndRevalidate, deleteRecords = _k.deleteRecords, warnings = _k.warnings, errors = _k.errors, validationState = __rest(_k, ["updateRecordAndRevalidate", "deleteRecords", "warnings", "errors"]);
+    var addNewRowsToSpreadsheet = function () {
+        addRowTimeoutRef.current = setTimeout(function () {
+            var highestRowIndex = Math.max.apply(Math, Object.values(dataSet).map(function (obj) { return obj._meta.rowIndex; }));
+            var newRow = addMeta({}, highestRowIndex + 1);
+            setDataSet(function (oldValues) {
+                var _a;
+                return (__assign(__assign({}, oldValues), (_a = {}, _a[newRow._meta.id] = newRow, _a)));
+            });
+            addRowTimeoutRef.current = null;
+        }, 300);
+    };
+    var handleDeleteErrors = function (selectedRows) {
+        deleteRecords(selectedRows, errors, warnings);
+    };
+    var dataSnapshot = useMemo(function () {
+        var filteredData = spreadsheetFilter.type === "rowBased"
+            ? filterRecordsByType(dataSet, spreadsheetFilter.byRow)
+            : filterRecordsByError(dataSet, spreadsheetFilter.byColumn.field, errors);
+        var filteredDatasetByString = filteredInputValue
+            ? filterRecordsBySearchValue(filteredData, filteredInputValue)
+            : filteredData;
+        var dataSetValues = Object.values(filteredDatasetByString);
+        if (sortBy) {
+            return dataSetValues.sort(getSortCompareFn(sortBy));
+        }
+        else if (!!sortByFieldErrors || !!sortByFieldWarnings)
+            return dataSetValues.sort(function (a, b) {
+                var aHasErrors = !!get(sortByFieldErrors ? errors : warnings, "".concat(get(a, "_meta.id"), ".").concat(sortByFieldErrors || sortByFieldWarnings), false);
+                var bHasErrors = !!get(sortByFieldErrors ? errors : warnings, "".concat(get(b, "_meta.id"), ".").concat(sortByFieldErrors || sortByFieldWarnings), false);
+                if (aHasErrors === bHasErrors) {
+                    return a._meta.rowIndex > b._meta.rowIndex ? 1 : -1;
+                }
+                return bHasErrors ? 1 : -1;
+            });
+        return dataSetValues;
+    }, [
+        filteredInputValue,
+        spreadsheetFilter,
+        sortBy,
+        Object.keys(dataSet).length,
+        sortByFieldErrors,
+        sortByFieldWarnings,
+    ]);
+    var recordsWithValuesCount = useMemo(function () {
+        return Object.values(dataSet).filter(hasValueInAnyField).length;
+    }, [dataSet]);
+    var filteredDataCount = useMemo(function () {
+        return Object.values(dataSnapshot).filter(hasValueInAnyField).length;
+    }, [dataSnapshot]);
+    var isFiltering = useMemo(function () { return !!filteredInputValue; }, [filteredInputValue]);
+    useEffect(function () {
+        onDataSetChanged && onDataSetChanged(dataSet);
+        if (addRowTimeoutRef.current) {
+            // avoid adding new rows when the user is typing
+            clearTimeout(addRowTimeoutRef.current);
+        }
+        var dataSetKeys = Object.keys(dataSet);
+        var latestDataSet = dataSet[dataSetKeys[dataSetKeys.length - 1]];
+        var latestDataSetValuesWithoutMeta = Object.values(latestDataSet).filter(function (key) { return key !== "_meta"; });
+        var hasValueInTheLastObject = latestDataSetValuesWithoutMeta
+            .filter(function (value) {
+            return value !== null && value !== undefined && typeof value !== "object";
+        })
+            .some(function (value) { return value !== "null" && value !== "undefined"; });
+        if (hasValueInTheLastObject) {
+            addNewRowsToSpreadsheet();
+        }
+    }, [dataSet]);
+    useEffect(function () {
+        onValidationStateChanged &&
+            onValidationStateChanged(__assign(__assign({}, validationState), { errors: errors, warnings: warnings }));
+    }, [validationState, onValidationStateChanged]);
+    var handleSortByFieldErrors = useCallback(function (field) {
+        setSortByFieldErrors(field === sortByFieldErrors ? null : field);
+        setSortByFieldWarnings(null);
+        setSortBy(null);
+    }, [sortByFieldErrors]);
+    var handleSortByFieldWarnings = useCallback(function (field) {
+        setSortByFieldWarnings(field === sortByFieldWarnings ? null : field);
+        setSortByFieldErrors(null);
+        setSortBy(null);
+    }, [sortByFieldWarnings]);
+    var lastClickedIndexRef = useRef(null);
+    var checkboxColumnWidth = useMemo(function () {
+        var lastRowIndexLength = dataSnapshot.length.toString().length;
+        var singleLetterWidth = 15;
+        var horizontalSpacing = 8;
+        var baseCheckboxColumnWidth = lastRowIndexLength * singleLetterWidth + horizontalSpacing;
+        return baseCheckboxColumnWidth < 40 ? 40 : baseCheckboxColumnWidth;
+    }, [dataSnapshot]);
+    var updatedDataSnapshot = useMemo(function () {
+        return dataSnapshot.map(function (data) {
+            var _a;
+            var updatedData = dataSet[(_a = data._meta) === null || _a === void 0 ? void 0 : _a.id];
+            return updatedData;
+        });
+    }, [dataSet, dataSnapshot]);
+    var value = __assign(__assign({ data: updatedDataSnapshot, fields: fields, isLoading: isLoading }, validationState), { isReadOnly: isReadOnly, sortByFieldErrors: sortByFieldErrors, sortByFieldWarnings: sortByFieldWarnings, highlightFirstRow: highlightFirstRow, options: options, recordsWithValuesCount: recordsWithValuesCount, filteredDataCount: filteredDataCount, sortBy: sortBy, warnings: warnings, errors: errors, setIsLoading: setIsLoading, setSortByFieldErrors: handleSortByFieldErrors, setSortByFieldWarnings: handleSortByFieldWarnings, onValidateRecord: onValidateRecord, updateRecord: updateRecordAndRevalidate, selectedRows: selectedRows, setSelectedRows: setSelectedRows, deleteRecords: handleDeleteErrors, filteredInputValue: filteredInputValue, setFilteredInputValue: setFilteredInputValue, lastClickedIndexRef: lastClickedIndexRef, addNewRowsToSpreadsheet: addNewRowsToSpreadsheet, spreadsheetFilter: spreadsheetFilter, resetSpreadsheetFilter: resetSpreadsheetFilter, filterRecordsByRowType: filterRecordsByRowType, filterRecordsByFieldErrors: filterRecordsByFieldErrors, checkboxColumnWidth: checkboxColumnWidth, setSortBy: setSortBy, isFiltering: isFiltering });
+    return (_jsx(SpreadsheetContext.Provider, __assign({ value: value }, { children: children })));
+};
+export var useSpreadsheetContext = function () { return useContext(SpreadsheetContext); };

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/useSpreadsheetFilter.d.ts

@@ -0,0 +1,14 @@
+export type SpreadsheetFilter = {
+    type: "rowBased" | "columnBased";
+    byRow?: "all" | "invalid" | "valid";
+    byColumn?: {
+        type: "fieldWithErrors";
+        field: string;
+    };
+};
+export declare const useSpreadsheetFilter: () => {
+    spreadsheetFilter: SpreadsheetFilter;
+    filterRecordsByRowType: (filterByRow: SpreadsheetFilter["byRow"]) => void;
+    filterRecordsByFieldErrors: (filterByColumn: string) => void;
+    resetSpreadsheetFilter: () => void;
+};

package/lib/esm/Importer/common/Spreadsheet/SpreadsheetContextProvider/useSpreadsheetFilter.js

@@ -0,0 +1,45 @@
+import { useReducer } from "react";
+export var useSpreadsheetFilter = function () {
+    var filtersInitialState = {
+        type: "rowBased",
+        byRow: "all",
+    };
+    function reducer(state, action) {
+        switch (action.type) {
+            case "FILTER_BY_ROW_TYPE":
+                return { type: "rowBased", byRow: action.payload, byColumn: null };
+            case "FILTER_BY_FIELD_ERRORS":
+                return {
+                    type: "columnBased",
+                    byColumn: {
+                        type: "fieldWithErrors",
+                        field: action.payload,
+                    },
+                    byRow: null,
+                };
+            case "RESTORE_FILTERS":
+                return filtersInitialState;
+            default:
+                return state;
+        }
+    }
+    var _a = useReducer(reducer, filtersInitialState), spreadsheetFilter = _a[0], filtersDispatch = _a[1];
+    var resetSpreadsheetFilter = function () {
+        filtersDispatch({ type: "RESTORE_FILTERS" });
+    };
+    var filterRecordsByRowType = function (filterByRow) {
+        filtersDispatch({ type: "FILTER_BY_ROW_TYPE", payload: filterByRow });
+    };
+    var filterRecordsByFieldErrors = function (filterByColumn) {
+        filtersDispatch({
+            type: "FILTER_BY_FIELD_ERRORS",
+            payload: filterByColumn,
+        });
+    };
+    return {
+        spreadsheetFilter: spreadsheetFilter,
+        filterRecordsByRowType: filterRecordsByRowType,
+        filterRecordsByFieldErrors: filterRecordsByFieldErrors,
+        resetSpreadsheetFilter: resetSpreadsheetFilter,
+    };
+};

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

@@ -0,0 +1,2 @@
+import { Record } from "../../../../types";
+export declare const hasValueInAnyField: (record: Record) => boolean;

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

@@ -0,0 +1,14 @@
+export var hasValueInAnyField = function (record) {
+    return Object.entries(record)
+        .filter(function (_a) {
+        var key = _a[0];
+        return key !== "_meta";
+    })
+        .some(function (_a) {
+        var key = _a[0], value = _a[1];
+        if (typeof value === "string") {
+            return value.trim() !== "";
+        }
+        return value !== null && value !== undefined;
+    });
+};

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

@@ -0,0 +1,16 @@
+import { Record, Field, FieldTypes } from "../../../../types";
+export declare const spreadsheetRowHeightPx = 40;
+export declare const spreadsheetHeaderHeightPx = 40;
+export declare const isNullOrUndefined: (value: any) => boolean;
+export declare const isEmpty: (value: string) => boolean;
+export declare const isEmail: (value: string) => boolean;
+export declare const isUrl: (value: string) => boolean;
+export declare const isTrue: (value: string) => boolean;
+export declare const isFalse: (value: string) => boolean;
+export declare const isBoolean: (value: string) => boolean;
+export declare const isInteger: (value: string) => boolean;
+export declare const isFloat: (value: string) => boolean;
+export declare const isEven: (value: number) => boolean;
+export declare const ignoreNullOrUndefinedKeyValues: (obj: any) => {};
+export declare const isRecordEmpty: (record: Record, fields: Field[]) => boolean;
+export declare const parseValue: (fieldType: FieldTypes, value: any, enumSet?: any) => any;

package/lib/esm/Importer/common/Spreadsheet/common/index.js

@@ -0,0 +1,63 @@
+import { FieldTypes } from "../../../../types";
+export var spreadsheetRowHeightPx = 40;
+export var spreadsheetHeaderHeightPx = 40;
+export var isNullOrUndefined = function (value) {
+    return value === null || value === undefined;
+};
+export var isEmpty = function (value) {
+    return (value === undefined ||
+        value === null ||
+        (typeof value === "object" && Object.keys(value).length === 0) ||
+        (typeof value === "string" && value.trim().length === 0));
+};
+export var isEmail = function (value) {
+    var emailRegex = /^[\w+.-]+@([\w-]+\.)+[\w-]{2,4}$/;
+    return emailRegex.test(value);
+};
+export var isUrl = function (value) {
+    var urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/g;
+    return urlRegex.test(value);
+};
+export var isTrue = function (value) {
+    var _a;
+    var _value = (_a = value === null || value === void 0 ? void 0 : value.toString()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    return ["true", "yes", "1", "y", "on", "t"].includes(_value);
+};
+export var isFalse = function (value) {
+    var _a;
+    var _value = (_a = value === null || value === void 0 ? void 0 : value.toString()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    return ["false", "no", "0", "n", "off", "f"].includes(_value);
+};
+export var isBoolean = function (value) {
+    return isTrue(value) || isFalse(value);
+};
+export var isInteger = function (value) { return /^-?[0-9]+$/.test(value + ""); };
+export var isFloat = function (value) {
+    return /^-?[0-9]+(?:\.[0-9]+)?$/.test(value + "");
+};
+export var isEven = function (value) { return value % 2 === 0; };
+export var ignoreNullOrUndefinedKeyValues = function (obj) {
+    var result = {};
+    Object.keys(obj || {})
+        .filter(function (key) { return obj[key] !== null && obj[key] !== undefined; })
+        .forEach(function (key) {
+        result[key] = obj[key];
+    });
+    return result;
+};
+export var isRecordEmpty = function (record, fields) {
+    return fields.reduce(function (isEmptyRecord, f) { return isEmptyRecord && isEmpty(record[f.name]); }, true);
+};
+export var parseValue = function (fieldType, value, enumSet) {
+    if (isEmpty(value))
+        return value;
+    if (fieldType === FieldTypes.float)
+        return isFloat(value) ? parseFloat(value) : value;
+    if (fieldType === FieldTypes.integer)
+        return isInteger(value) ? parseInt(value) : value;
+    if (fieldType === FieldTypes.boolean)
+        return isTrue(value) ? true : false;
+    if (fieldType === FieldTypes.enum && enumSet)
+        return enumSet[value];
+    return value;
+};

package/lib/esm/Importer/common/Spreadsheet/common/types.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { RecordDataSet, Field, SpreadsheetOptions, OnValidateRecord, Record } from "../../../../types";
+import { OnDataSetChanged, OnValidationStateChanged } from "../SpreadsheetContextProvider";
+export declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+export type SortBy = {
+    field: string;
+    direction: SortOrder;
+};
+export type SpreadsheetProps = {
+    initialDataSet: RecordDataSet;
+    isReadOnly?: boolean;
+    fields?: Field[];
+    highlightFirstRow?: boolean;
+    options?: SpreadsheetOptions;
+    onValidateRecord?: OnValidateRecord;
+    onDataSetChanged?: OnDataSetChanged;
+    onValidationStateChanged?: OnValidationStateChanged;
+    selectedRows?: string[];
+    setSelectedRows?: React.Dispatch<React.SetStateAction<string[]>>;
+    getSortCompareFn?: (sortBy: SortBy) => (a: Record, b: Record) => number;
+};

package/lib/esm/Importer/common/Spreadsheet/common/types.js

@@ -0,0 +1,5 @@
+export var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASC"] = "asc";
+    SortOrder["DESC"] = "desc";
+})(SortOrder || (SortOrder = {}));

package/lib/esm/Importer/common/Spreadsheet/components/FieldHeader.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { Field } from "../../../../types";
+import { SortOrder } from "../common/types";
+type SortIndicatorProps = {
+    direction: SortOrder;
+};
+export declare const SortIndicator: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../../../styled/utils").CSSProps & SortIndicatorProps, never>;
+export type FieldHeaderProps = {
+    field: Field;
+    sortByFieldErrors: (name: string) => void;
+    sortByFieldWarnings: (name: string) => void;
+};
+export declare const FieldHeader: React.FC<FieldHeaderProps>;
+export declare const chevronDown: JSX.Element;
+export {};