fuse-importer 0.0.1-staging

package/lib/esm/styled/utils.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import { appCss } from "./theme";
+export declare const themeProps: import("styled-components").FlattenInterpolation<import("styled-components").ThemeProps<import("styled-components").DefaultTheme>>;
+export type CSSProps = {
+    [K in keyof typeof appCss]?: any;
+};
+export type CSSAnyProps = CSSProps | {
+    [key: string]: any;
+};
+export declare const Div: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, CSSProps, never>;
+export declare const HTMLButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, CSSProps, never>;
+export declare const Span: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, CSSProps, never>;
+export declare const Label: import("styled-components").StyledComponent<"label", import("styled-components").DefaultTheme, CSSProps, never>;
+export declare const P: import("styled-components").StyledComponent<"p", import("styled-components").DefaultTheme, CSSProps, never>;
+export declare const BaseButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, CSSProps, never>;
+export type DivProps = React.HTMLAttributes<HTMLDivElement>;
+export type HTMLButtonProps = React.HTMLAttributes<HTMLButtonElement>;
+export type HTMLInputProps = React.InputHTMLAttributes<HTMLInputElement>;
+export type HTMLLabelProps = React.InputHTMLAttributes<HTMLLabelElement>;
+export type DivCSSProps = DivProps & CSSProps;
+export type HTMLButtonCSSProps = HTMLButtonProps & CSSProps;
+export type HTMLInputCSSProps = HTMLInputProps & CSSProps;

package/lib/esm/styled/utils.js

@@ -0,0 +1,17 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+import styled, { css } from "styled-components";
+export var themeProps = css(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), function (props) {
+    return Object.keys(props)
+        .map(function (p) { return props.theme.css[p]; })
+        .filter(function (c) { return c; });
+});
+export var Div = styled.div(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), themeProps);
+export var HTMLButton = styled.button(templateObject_3 || (templateObject_3 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), themeProps);
+export var Span = styled.span(templateObject_4 || (templateObject_4 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), themeProps);
+export var Label = styled.label(templateObject_5 || (templateObject_5 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), themeProps);
+export var P = styled.p(templateObject_6 || (templateObject_6 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), themeProps);
+export var BaseButton = styled.button(templateObject_7 || (templateObject_7 = __makeTemplateObject(["\n  ", ";\n  outline: none;\n  margin: none;\n  padding: none;\n  background: transparent;\n  border: none;\n"], ["\n  ", ";\n  outline: none;\n  margin: none;\n  padding: none;\n  background: transparent;\n  border: none;\n"])), themeProps);
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6, templateObject_7;

package/lib/esm/types.d.ts

@@ -0,0 +1,209 @@
+import { ImporterStylePreferences } from "./Importer/common/theme";
+declare const EnvironmentTypes: readonly ["local", "development", "production", "test"];
+export type EnvironmentType = typeof EnvironmentTypes[number];
+export type SpreadsheetOptions = {
+    batchValidationDelayMs?: number;
+    batchValidationSize?: number;
+    showCheckboxColumn?: boolean;
+    firstRowIsHeader?: boolean;
+};
+export type ImporterOptions = {
+    zIndex?: number;
+    env?: EnvironmentType;
+    previewMode?: boolean;
+    loadingComponent?: () => JSX.Element;
+    disableSubmitIfInvalid?: boolean;
+    records?: Record[];
+    language?: string;
+} & SpreadsheetOptions;
+export declare enum FieldTypes {
+    boolean = "boolean",
+    integer = "integer",
+    float = "float",
+    string = "string",
+    email = "email",
+    enum = "enum",
+    url = "url",
+    date = "date",
+    datetime = "datetime",
+    time = "time"
+}
+export type FieldTypesAsUnion = keyof typeof FieldTypes;
+export type SpreadsheetValidationErrors = {
+    [rowId: string]: ValidationErrors;
+};
+export type Meta = {
+    id: string;
+    rowIndex: number;
+    isInvalid?: boolean;
+    hasWarning?: boolean;
+    touched?: boolean;
+    uploadedRow?: any;
+    backendErrors?: ValidationErrors;
+};
+export type Record = {
+    [key: string]: any;
+    _meta?: Meta;
+};
+export type RecordDataSet = {
+    [key: string]: Record;
+};
+export type ValidationResult = {
+    errors: ValidationErrors;
+    warnings: ValidationErrors;
+};
+export type ValidationErrors = {
+    [k: string]: string;
+};
+export type OnValidateRecord = (record: Record) => Promise<ValidationResult | ValidationErrors>;
+export type FormatRecord = (record: Record) => Record;
+export type RowValidationError = {
+    rowId: string;
+    errors: ValidationErrors;
+};
+export type BatchValidationErrors = {
+    [rowId: string]: ValidationErrors;
+};
+export type AppResponse = {
+    recordsToDisplay?: Record[];
+    errors?: SpreadsheetValidationErrors;
+    message?: string;
+};
+export type OnSubmit = (reviewedData: Record[]) => Promise<AppResponse>;
+export type ValidationOptionKeys = "pattern" | "max_length" | "min_length" | "length" | "max" | "min";
+export declare const validationTypesBase: readonly ["cannot_contain", "contain", "max_length", "min_length", "length_exactly", "unique_case_sensitive", "unique_case_insensitive", "regex", "integer", "less_than", "greater_than", "even", "odd", "float", "email", "url", "boolean", "before_date", "after_date"];
+export declare const mutableValidationTypes: ("boolean" | "max_length" | "min_length" | "cannot_contain" | "contain" | "length_exactly" | "unique_case_sensitive" | "unique_case_insensitive" | "regex" | "integer" | "less_than" | "greater_than" | "even" | "odd" | "float" | "email" | "url" | "before_date" | "after_date")[];
+export type ValidationTypes = typeof validationTypesBase[number];
+export type TransformationOptionKeys = "prefix" | "number_of_decimals";
+export declare const transformationTypesBase: readonly ["sentence_case", "capitalize", "uppercase", "lowercase", "trim_whitespace", "autoformat", "prefix", "number_of_decimals", "round", "floor", "ceiling", "autodetect"];
+export declare const mutableTransformationTypes: ("prefix" | "number_of_decimals" | "sentence_case" | "capitalize" | "uppercase" | "lowercase" | "trim_whitespace" | "autoformat" | "round" | "floor" | "ceiling" | "autodetect")[];
+export type TransformationTypes = typeof transformationTypesBase[number];
+export interface FieldValidation {
+    id?: number;
+    validation_type?: ValidationTypes;
+    is_default?: boolean;
+    message?: string;
+    options?: {
+        [key in ValidationOptionKeys]?: any;
+    };
+}
+export interface FieldTransformation {
+    id?: number;
+    transformation_type?: TransformationTypes;
+    options?: {
+        [key in TransformationOptionKeys]?: any;
+    };
+}
+export type TemplateHeader = {
+    label: string;
+    required: boolean;
+    unique: boolean;
+    column_type: string;
+    internal_key: string;
+    values: string[];
+    pattern: string;
+    validations: FieldValidation[];
+    transformations: FieldTransformation[];
+    position: number;
+};
+export type Organization = {
+    id: number;
+    name: string;
+    trial_mode: boolean;
+    plan: {
+        title: string;
+        allow_style_customization: boolean;
+        has_records_limit: boolean;
+        allowed_records: number;
+    };
+};
+export type Integration = {
+    url: string;
+    trigger_type: string;
+    active: boolean;
+    provider: string;
+};
+export type TemplateInfo = {
+    columns: TemplateHeader[];
+    integrations: Integration[];
+    importer_style_preferences: ImporterStylePreferences;
+    organization: Organization;
+    name: string;
+    preview_first_time: boolean;
+};
+export type Field = {
+    name: string;
+    label: string;
+    type: FieldTypes;
+    isRequired?: boolean;
+    options?: any;
+    pattern?: string;
+    validations?: FieldValidation[];
+    transformations?: FieldTransformation[];
+};
+export type ColumnRequiredProps<T extends FieldTypesAsUnion> = {
+    internal_key: string;
+    label: string;
+    column_type: T;
+    required: boolean;
+    options?: ColumnOptions<T>;
+};
+export type ValidationTypesRules<T extends FieldTypesAsUnion> = T extends "integer" ? IntegerValidationRule : T extends "float" ? FloatValidationRule : T extends "string" ? StringValidationRule : T extends "email" ? EmailValidationRule : T extends "enum" ? EnumValidationRule : T extends "url" ? UrlValidationRule : T extends "boolean" ? BooleanValidationRule : T extends "date" ? DateValidationRule : T extends "datetime" ? DateTimeValidationRule : T extends "time" ? TimeValidationRule : never;
+export type TransformationTypesRules<T extends FieldTypesAsUnion> = T extends "integer" ? IntegerTransformationRule : T extends "float" ? FloatTransformationRule : T extends "string" ? StringTransformationRule : T extends "enum" ? EnumTransformationRule : T extends "url" ? UrlTransformationRule : T extends "date" | "datetime" | "time" ? DateDateTimesAndTimesTransformationRule : never;
+export type ValidationTypeOptions<T extends ValidationTypesRules<FieldTypesAsUnion>> = T extends "cannot_contain" | "contain" | "regex" ? {
+    pattern: string;
+} : T extends "max_length" ? {
+    max_length: number;
+} : T extends "min_length" ? {
+    min_length: number;
+} : T extends "length_exactly" ? {
+    length: number;
+} : T extends "less_than" | "before_date" ? {
+    max: string | number;
+} : T extends "greater_than" | "after_date" ? {
+    min: string | number;
+} : never;
+export type TransformationTypeOptions<T extends TransformationTypesRules<FieldTypesAsUnion>> = T extends "prefix" ? {
+    prefix: string;
+} : T extends "number_of_decimals" ? {
+    number_of_decimals: number;
+} : never;
+export interface ColumnValidations<T extends FieldTypesAsUnion> {
+    validation_type: ValidationTypesRules<T>;
+    message: string;
+    options?: ValidationTypeOptions<ValidationTypesRules<T>>;
+}
+export interface ColumnTransformations<T extends FieldTypesAsUnion> {
+    transformation_type: TransformationTypesRules<T>;
+    options?: TransformationTypeOptions<TransformationTypesRules<T>>;
+}
+type EnumOptions = {
+    values: string[];
+};
+type TimeOptions = {
+    values?: never;
+};
+type OtherOptions = {
+    values?: never;
+};
+export type ColumnOptions<T extends FieldTypesAsUnion> = Partial<Pick<TemplateHeader, "unique" | "position" | "pattern">> & {
+    validations?: ColumnValidations<T>[];
+    transformations?: ColumnTransformations<T>[];
+} & (T extends "enum" ? EnumOptions : T extends "time" ? TimeOptions : OtherOptions);
+type StringValidationRule = "cannot_contain" | "contain" | "max_length" | "min_length" | "length_exactly" | "unique_case_sensitive" | "unique_case_insensitive" | "regex";
+type StringTransformationRule = "sentence_case" | "capitalize" | "uppercase" | "lowercase" | "trim_whitespace";
+type IntegerValidationRule = "less_than" | "greater_than" | "even" | "odd" | "unique_case_sensitive" | "unique_case_insensitive" | "regex";
+type IntegerTransformationRule = "round" | "floor" | "ceiling";
+type FloatValidationRule = "less_than" | "greater_than" | "even" | "odd" | "unique_case_sensitive" | "unique_case_insensitive" | "regex";
+type FloatTransformationRule = "number_of_decimals";
+type EmailValidationRule = "cannot_contain" | "contain" | "max_length" | "min_length" | "length_exactly" | "unique_case_sensitive" | "unique_case_insensitive" | "regex";
+type EnumValidationRule = "unique_case_sensitive" | "unique_case_insensitive";
+type EnumTransformationRule = "autodetect";
+type UrlValidationRule = "cannot_contain" | "contain" | "max_length" | "min_length" | "length_exactly" | "unique_case_sensitive" | "unique_case_insensitive" | "regex";
+type UrlTransformationRule = "prefix";
+type BooleanValidationRule = "boolean";
+type DateValidationRule = "unique_case_sensitive" | "unique_case_insensitive" | "before_date" | "after_date";
+type DateTimeValidationRule = "unique_case_sensitive" | "unique_case_insensitive" | "before_date" | "after_date";
+type TimeValidationRule = "unique_case_sensitive" | "unique_case_insensitive";
+type DateDateTimesAndTimesTransformationRule = "autoformat";
+export {};

package/lib/esm/types.js

@@ -0,0 +1,65 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var EnvironmentTypes = [
+    "local",
+    "development",
+    "production",
+    "test",
+];
+export var FieldTypes;
+(function (FieldTypes) {
+    FieldTypes["boolean"] = "boolean";
+    FieldTypes["integer"] = "integer";
+    FieldTypes["float"] = "float";
+    FieldTypes["string"] = "string";
+    FieldTypes["email"] = "email";
+    FieldTypes["enum"] = "enum";
+    FieldTypes["url"] = "url";
+    FieldTypes["date"] = "date";
+    FieldTypes["datetime"] = "datetime";
+    FieldTypes["time"] = "time";
+})(FieldTypes || (FieldTypes = {}));
+export var validationTypesBase = [
+    "cannot_contain",
+    "contain",
+    "max_length",
+    "min_length",
+    "length_exactly",
+    "unique_case_sensitive",
+    "unique_case_insensitive",
+    "regex",
+    "integer",
+    "less_than",
+    "greater_than",
+    "even",
+    "odd",
+    "float",
+    "email",
+    "url",
+    "boolean",
+    "before_date",
+    "after_date",
+];
+export var mutableValidationTypes = __spreadArray([], validationTypesBase, true);
+export var transformationTypesBase = [
+    "sentence_case",
+    "capitalize",
+    "uppercase",
+    "lowercase",
+    "trim_whitespace",
+    "autoformat",
+    "prefix",
+    "number_of_decimals",
+    "round",
+    "floor",
+    "ceiling",
+    "autodetect",
+];
+export var mutableTransformationTypes = __spreadArray([], transformationTypesBase, true);

package/lib/esm/utils/hooks/useWindowSize.d.ts

@@ -0,0 +1,11 @@
+type WindowDimentions = {
+    width: number | undefined;
+    height: number | undefined;
+};
+type IsOnMobileDevice = boolean;
+interface UseWindowDimensions {
+    isOnSmallScreens: IsOnMobileDevice;
+    windowDimensions: WindowDimentions;
+}
+declare const useWindowDimensions: () => UseWindowDimensions;
+export default useWindowDimensions;

package/lib/esm/utils/hooks/useWindowSize.js

@@ -0,0 +1,23 @@
+import { useEffect, useState } from "react";
+var useWindowDimensions = function () {
+    var _a = useState({
+        width: undefined,
+        height: undefined,
+    }), windowDimensions = _a[0], setWindowDimensions = _a[1];
+    useEffect(function () {
+        var handleResize = function () {
+            setWindowDimensions({
+                width: window.innerWidth,
+                height: window.innerHeight,
+            });
+        };
+        handleResize();
+        window.addEventListener("resize", handleResize);
+        return function () { return window.removeEventListener("resize", handleResize); };
+    }, []);
+    var isOnSmallScreens = windowDimensions.width
+        ? windowDimensions.width <= 1050
+        : false;
+    return { windowDimensions: windowDimensions, isOnSmallScreens: isOnSmallScreens };
+};
+export default useWindowDimensions;

package/lib/esm/utils/hooks.d.ts

@@ -0,0 +1 @@
+export * from "./hooks/useWindowSize";

package/lib/esm/utils/hooks.js

@@ -0,0 +1 @@
+export * from "./hooks/useWindowSize";

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

@@ -0,0 +1,12 @@
+import { ValidationTypes } from "../types";
+export declare const isString: (variable: any) => boolean;
+export declare const sleep: (n: number) => Promise<unknown>;
+export declare const addLinkToHead: (document: Document, head: HTMLHeadElement, href: string, rel: string, crossOrigin?: string) => void;
+export declare const addValidation: (value: ValidationTypes, label: string) => {
+    validation_type: any;
+    message: string;
+};
+export declare const getDefaultValidations: (columnType: string) => {
+    validation_type: any;
+    message: string;
+}[];

package/lib/esm/utils/index.js

@@ -0,0 +1,37 @@
+export var isString = function (variable) {
+    return typeof variable === "string" || variable instanceof String;
+};
+export var sleep = function (n) {
+    return new Promise(function (resolve) { return setTimeout(resolve, n); });
+};
+export var addLinkToHead = function (document, head, href, rel, crossOrigin) {
+    if (crossOrigin === void 0) { crossOrigin = ""; }
+    var link = document.createElement("link");
+    link.href = href;
+    link.rel = rel;
+    link.crossOrigin = crossOrigin;
+    head.appendChild(link);
+};
+// Add dynamic columns
+export var addValidation = function (value, label) {
+    return {
+        validation_type: value,
+        message: label,
+    };
+};
+export var getDefaultValidations = function (columnType) {
+    switch (columnType) {
+        case "email":
+            return [addValidation("email", "Must be an email")];
+        case "url":
+            return [addValidation("url", "Must be a URL")];
+        case "boolean":
+            return [addValidation("boolean", "Must be True or False")];
+        case "integer":
+            return [addValidation("integer", "Must be an integer")];
+        case "float":
+            return [addValidation("float", "Must be a float")];
+        default:
+            return [];
+    }
+};