fuse-importer 0.0.8-testing → 0.1.1-testing

package/lib/esm/common/buttons.js

@@ -0,0 +1,97 @@
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+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, Fragment as _Fragment } from "react/jsx-runtime";
+import { get } from "lodash";
+import styled, { css } from "styled-components";
+import { Div, HTMLButton } from "../styled/utils";
+var types = ["primary", "secondary", "tertiary", "link"];
+var getBgColor = function (props) {
+    return get(props, "backgroundColor", get(props.theme, "colors.pink500"));
+};
+var getBorderColor = function (props) {
+    return get(props, "backgroundColor", get(props.theme, "colors.pink700"));
+};
+var getSvgFillColorForNormalState = function (props) {
+    return get(props, "svgNormalFillColorOverride", get(props.theme, "colors.black"));
+};
+var getSvgFillColorForActiveState = function (props) {
+    return get(props, "svgActiveFillColorOverride", get(props.theme, "colors.white"));
+};
+var getSvgFillColorForDisabledState = function (props) {
+    return get(props, "svgDisabledFillColorOverride", get(props.theme, "colors.gray390"));
+};
+var getSvgStrokeColorForNormalState = function (props) {
+    return get(props, "svgNormalStrokeColorOverride", get(props.theme, "colors.black"));
+};
+var getSvgStrokeColorForActiveState = function (props) {
+    return get(props, "svgActiveStrokeColorOverride", get(props.theme, "colors.white"));
+};
+var getSvgStrokeColorForDisabledState = function (props) {
+    return get(props, "svgDisabledStrokeColorOverride", get(props.theme, "colors.black"));
+};
+var withoutBrandingCSS = css(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n  text-decoration: underline;\n"], ["\n  text-decoration: underline;\n"])));
+var withBrandingCSS = css(templateObject_2 || (templateObject_2 = __makeTemplateObject(["\n  :hover {\n    background: transparent;\n    text-decoration: underline;\n  }\n"], ["\n  :hover {\n    background: transparent;\n    text-decoration: underline;\n  }\n"])));
+var styles = {
+    primary: css(templateObject_4 || (templateObject_4 = __makeTemplateObject(["\n    color: ", ";\n    background: ", ";\n\n    border: solid 4px ", ";\n    box-sizing: border-box;\n\n    :hover {\n      background: ", ";\n      /* a3 at the end adds 0.64 opacity */\n      box-shadow: 0px 0px 8px ", "a3;\n    }\n    :active {\n      background: ", ";\n      border: 4px solid ", ";\n    }\n    :focus {\n      background: ", ";\n      /* a3 at the end adds 0.64 opacity */\n      box-shadow: 0px 0px 8px ", "a3;\n    }\n    ", "\n  "], ["\n    color: ", ";\n    background: ", ";\n\n    border: solid 4px ", ";\n    box-sizing: border-box;\n\n    :hover {\n      background: ", ";\n      /* a3 at the end adds 0.64 opacity */\n      box-shadow: 0px 0px 8px ", "a3;\n    }\n    :active {\n      background: ", ";\n      border: 4px solid ", ";\n    }\n    :focus {\n      background: ", ";\n      /* a3 at the end adds 0.64 opacity */\n      box-shadow: 0px 0px 8px ", "a3;\n    }\n    ", "\n  "])), function (props) { return props.theme.colors.white; }, getBgColor, getBgColor, getBgColor, getBgColor, getBgColor, getBorderColor, getBgColor, getBgColor, function (props) {
+        return props.isDisabled && css(templateObject_3 || (templateObject_3 = __makeTemplateObject(["\n        background: ", " !important;\n        opacity: 0.4;\n        box-shadow: none !important;\n        border: none !important;\n        cursor: not-allowed !important;\n      "], ["\n        background: ", " !important;\n        opacity: 0.4;\n        box-shadow: none !important;\n        border: none !important;\n        cursor: not-allowed !important;\n      "])), getBgColor);
+    }),
+    secondary: css(templateObject_6 || (templateObject_6 = __makeTemplateObject(["\n    background: ", ";\n    box-sizing: border-box;\n    border: solid 1px ", ";\n    color: ", ";\n    & > svg {\n      & > path {\n        fill: ", ";\n        stroke: ", ";\n      }\n    }\n    :active {\n      border: 1px solid ", ";\n      background: ", ";\n      color: ", ";\n      & > svg {\n        & > path {\n          fill: ", ";\n          stroke: ", ";\n        }\n      }\n    }\n    :focus {\n      box-shadow: 0px 0px 8px rgba(0, 0, 0, 0.24);\n    }\n    ", "\n  "], ["\n    background: ", ";\n    box-sizing: border-box;\n    border: solid 1px ", ";\n    color: ", ";\n    & > svg {\n      & > path {\n        fill: ", ";\n        stroke: ", ";\n      }\n    }\n    :active {\n      border: 1px solid ", ";\n      background: ", ";\n      color: ", ";\n      & > svg {\n        & > path {\n          fill: ", ";\n          stroke: ", ";\n        }\n      }\n    }\n    :focus {\n      box-shadow: 0px 0px 8px rgba(0, 0, 0, 0.24);\n    }\n    ", "\n  "])), function (props) { return props.theme.colors.white; }, function (props) { return props.theme.colors.black; }, function (props) { return props.theme.colors.black; }, getSvgFillColorForNormalState, getSvgStrokeColorForNormalState, function (props) { return props.theme.colors.black; }, function (props) { return props.theme.colors.black; }, function (props) { return props.theme.colors.white; }, getSvgFillColorForActiveState, getSvgStrokeColorForActiveState, function (props) {
+        return props.isDisabled && css(templateObject_5 || (templateObject_5 = __makeTemplateObject(["\n        border: 2px solid ", ";\n        color: ", ";\n        & > svg {\n          & > path {\n            fill: ", ";\n            stroke: ", ";\n          }\n        }\n      "], ["\n        border: 2px solid ", ";\n        color: ", ";\n        & > svg {\n          & > path {\n            fill: ", ";\n            stroke: ", ";\n          }\n        }\n      "])), function (props) { return props.theme.colors.gray390; }, function (props) { return props.theme.colors.gray390; }, getSvgFillColorForDisabledState, getSvgStrokeColorForDisabledState);
+    }),
+    tertiary: css(templateObject_8 || (templateObject_8 = __makeTemplateObject(["\n    background: transparent;\n    border: solid 1px transparent;\n    color: ", ";\n    :hover {\n      background: ", ";\n    }\n    :active {\n      background: ", ";\n      color: ", ";\n    }\n    ", "\n  "], ["\n    background: transparent;\n    border: solid 1px transparent;\n    color: ", ";\n    :hover {\n      background: ", ";\n    }\n    :active {\n      background: ", ";\n      color: ", ";\n    }\n    ", "\n  "])), function (props) { return props.theme.colors.text; }, function (props) { return props.theme.colors.white50; }, function (props) { return props.theme.colors.black; }, function (props) { return props.theme.colors.white; }, function (props) {
+        return props.isDisabled && css(templateObject_7 || (templateObject_7 = __makeTemplateObject(["\n        color: ", ";\n      "], ["\n        color: ", ";\n      "])), function (props) { return props.theme.colors.gray300; });
+    }),
+    link: css(templateObject_10 || (templateObject_10 = __makeTemplateObject(["\n    background: transparent;\n    border: solid 1px transparent;\n    color: ", ";\n\n    :hover {\n      background: ", ";\n    }\n\n    ", "\n\n    ", "\n\n    :active {\n      background: ", ";\n      color: ", ";\n    }\n  "], ["\n    background: transparent;\n    border: solid 1px transparent;\n    color: ", ";\n\n    :hover {\n      background: ", ";\n    }\n\n    ", "\n\n    ", "\n\n    :active {\n      background: ", ";\n      color: ", ";\n    }\n  "])), function (props) { return props.theme.colors.black; }, function (props) { return props.theme.colors.white50; }, function (props) {
+        return props.isDisabled && css(templateObject_9 || (templateObject_9 = __makeTemplateObject(["\n        color: ", ";\n      "], ["\n        color: ", ";\n      "])), function (props) { return props.theme.colors.gray300; });
+    }, function (_a) {
+        var theme = _a.theme;
+        return theme.colors.black === "black"
+            ? withoutBrandingCSS
+            : withBrandingCSS;
+    }, function (props) { return props.theme.colors.black; }, function (props) { return props.theme.colors.white; }),
+};
+var commonButtonStyle = css(templateObject_13 || (templateObject_13 = __makeTemplateObject(["\n  padding: 12px 24px;\n  user-select: none;\n  width: fit-content;\n\n  ", "\n\n  border: solid 1px black;\n  border-radius: 4px;\n\n  font-family: DM Sans;\n\n  :focus {\n    outline: none;\n  }\n  :hover {\n    cursor: pointer;\n  }\n\n  ", "\n  ", ";\n\n  ", ";\n"], ["\n  padding: 12px 24px;\n  user-select: none;\n  width: fit-content;\n\n  ", "\n\n  border: solid 1px black;\n  border-radius: 4px;\n\n  font-family: DM Sans;\n\n  :focus {\n    outline: none;\n  }\n  :hover {\n    cursor: pointer;\n  }\n\n  ", "\n  ", ";\n\n  ", ";\n"])), function (props) {
+    return props.isSmall && css(templateObject_11 || (templateObject_11 = __makeTemplateObject(["\n      padding: 6px 20px;\n    "], ["\n      padding: 6px 20px;\n    "])));
+}, function (props) {
+    return props.isDisabled && css(templateObject_12 || (templateObject_12 = __makeTemplateObject(["\n      pointer-events: none;\n    "], ["\n      pointer-events: none;\n    "])));
+}, function (props) {
+    var c = props.theme.css;
+    return [c.centered, c.buttonText];
+}, function (props) { return styles[props.variant || "primary"]; });
+export var ButtonWrapper = styled(Div)(templateObject_14 || (templateObject_14 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), commonButtonStyle);
+export var ButtonElementWrapper = styled(HTMLButton)(templateObject_15 || (templateObject_15 = __makeTemplateObject(["\n  ", ";\n"], ["\n  ", ";\n"])), commonButtonStyle);
+export var Button = function (_a) {
+    var _b = _a.onClick, onClick = _b === void 0 ? null : _b, _c = _a.isDisabled, isDisabled = _c === void 0 ? false : _c, _d = _a.variant, variant = _d === void 0 ? "primary" : _d, _e = _a.isSmall, isSmall = _e === void 0 ? false : _e, children = _a.children, _f = _a.isButtonElement, isButtonElement = _f === void 0 ? false : _f, props = __rest(_a, ["onClick", "isDisabled", "variant", "isSmall", "children", "isButtonElement"]);
+    return (_jsx(_Fragment, { children: isButtonElement ? (_jsx(ButtonElementWrapper, __assign({ isSmall: isSmall, isDisabled: isDisabled, disabled: isDisabled, variant: variant, type: "submit" }, props, { children: children }))) : (_jsx(ButtonWrapper, __assign({ role: "button", w: "fit-content", p: 12, isSmall: isSmall, onClick: isDisabled ? null : onClick, onKeyDown: function (_a) {
+                var code = _a.code;
+                if ((code === "Space" || (code === "Enter" && onClick)) &&
+                    !isDisabled) {
+                    onClick();
+                }
+            }, tabIndex: 0 }, __assign({ variant: variant, isDisabled: isDisabled, onClick: onClick, disabled: isDisabled }, props), { children: _jsx(_Fragment, { children: children }) }))) }));
+};
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6, templateObject_7, templateObject_8, templateObject_9, templateObject_10, templateObject_11, templateObject_12, templateObject_13, templateObject_14, templateObject_15;

package/lib/esm/common/columnsTransformations.js

@@ -0,0 +1,94 @@
+var commonDateAndTimeTransformations = [
+    {
+        value: "autoformat",
+        label: "Autoformat (e.g. 02-13-2020 -> 02/13/2020",
+        isDefaultTransformation: true,
+    },
+];
+var stringTransformations = [
+    {
+        value: "sentence_case",
+        label: "Sentence Case (e.g. hello world -> Hello world)",
+    },
+    {
+        value: "capitalize",
+        label: "Capitalize (e.g. hello world -> Hello World)",
+    },
+    {
+        value: "uppercase",
+        label: "Uppercase (e.g. hello world -> HELLO WORLD)",
+    },
+    {
+        value: "lowercase",
+        label: "Lowercase (e.g. Hello World -> hello world)",
+    },
+    {
+        value: "trim_whitespace",
+        label: "Trim Whitespace (e.g. '  hello world ' -> 'hello world')",
+    },
+];
+var urlTransformations = [
+    {
+        value: "prefix",
+        label: "Prefix",
+        options: [
+            {
+                key: "prefix",
+                type: "text",
+                tooltip: "Add Prefix (e.g., 'example.com' becomes 'https://example.com')",
+            },
+        ],
+    },
+];
+var floatTransformations = [
+    {
+        value: "number_of_decimals",
+        label: "Number of Decimals",
+        options: [
+            {
+                key: "number_of_decimals",
+                type: "number",
+                tooltip: "Set Number of Decimals (e.g., '10.567' becomes '10.57' with 2 decimals)",
+            },
+        ],
+    },
+];
+var integerTransformations = [
+    {
+        value: "round",
+        label: "Round (e.g. 3.19 -> 3)",
+    },
+    {
+        value: "floor",
+        label: "Floor (e.g. 3.99 -> 3)",
+    },
+    {
+        value: "ceiling",
+        label: "Ceiling (e.g. 3.01 -> 4)",
+    },
+];
+var enumTransformations = [
+    {
+        value: "autodetect",
+        label: "Autodetect (e.g. 0/1 -> true/false)",
+        isDefaultTransformation: true,
+    },
+];
+export var transformationsByColumnType = {
+    string: stringTransformations,
+    integer: integerTransformations,
+    float: floatTransformations,
+    enum: enumTransformations,
+    url: urlTransformations,
+    date: commonDateAndTimeTransformations,
+    datetime: commonDateAndTimeTransformations,
+    time: commonDateAndTimeTransformations,
+};
+// the final object will look like this:
+// { autodetect: { value: "autodetect", label: "Autodetect" }, ... }
+export var transformationsByType = Object.values(transformationsByColumnType)
+    .reduce(function (acc, arr) { return acc.concat(arr); }, [])
+    .reduce(function (result, p) {
+    result[p.value] = p;
+    return result;
+}, {});

package/lib/esm/common/columnsValidations.d.ts

@@ -15,31 +15,5 @@ export declare const validationsByColumnType: {
 };
 export declare const validationsByType: {};
 export declare const availableColumnTypes: string[];
-export declare const datePatterns: {
-    value: string;
-    label: string;
-}[];
-export declare const dateTimePatterns: {
-    value: string;
-    label: string;
-}[];
-export declare const timePatterns: {
-    value: string;
-    label: string;
-}[];
-export declare const allowedPatterns: {
-    date: {
-        value: string;
-        label: string;
-    }[];
-    datetime: {
-        value: string;
-        label: string;
-    }[];
-    time: {
-        value: string;
-        label: string;
-    }[];
-};
 export declare const patternsColumnTypes: string[];
-export declare const validateColumn: <T extends "string" | "boolean" | "time" | "integer" | "float" | "email" | "enum" | "url" | "date" | "datetime">(columnData: ColumnRequiredProps<T>) => Promise<void>;
+export declare const validateColumn: <T extends "string" | "boolean" | "time" | "integer" | "float" | "email" | "url" | "enum" | "date" | "datetime">(columnData: ColumnRequiredProps<T>) => Promise<void>;

package/lib/esm/common/columnsValidations.js

@@ -0,0 +1,401 @@
+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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+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));
+};
+import * as yup from "yup";
+import { FieldTypes, mutableValidationTypes, mutableTransformationTypes, } from "../types";
+import { allowedPatterns, datePatterns, dateTimePatterns, timePatterns, } from "./datePatterns";
+var commonValidations = [
+    {
+        value: "regex",
+        label: "Must Match Regex",
+        options: [
+            {
+                type: "text",
+                key: "pattern",
+                tooltip: "Regex Pattern",
+            },
+        ],
+    },
+];
+var uniqueValidation = [
+    { value: "unique_case_sensitive", label: "Must be Unique (case sensitive)" },
+    {
+        value: "unique_case_insensitive",
+        label: "Must be Unique (case insensitive)",
+    },
+];
+var containsValidations = [
+    {
+        value: "cannot_contain",
+        label: "Cannot Contain",
+        options: [
+            {
+                type: "text",
+                key: "pattern",
+                tooltip: "It must be a word that you want to exclude",
+            },
+        ],
+    },
+    {
+        value: "contain",
+        label: "Must Contain",
+        options: [
+            {
+                type: "text",
+                key: "pattern",
+                tooltip: "It must be a word to be included mandatorily",
+            },
+        ],
+    },
+];
+var stringValidations = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], containsValidations, true), [
+    {
+        value: "max_length",
+        label: "Length (shorter than)",
+        options: [
+            {
+                type: "number",
+                key: "max_length",
+                tooltip: "Number of characters",
+            },
+        ],
+    },
+    {
+        value: "min_length",
+        label: "Length (longer than)",
+        options: [
+            {
+                type: "number",
+                key: "min_length",
+                tooltip: "Number of characters",
+            },
+        ],
+    },
+    {
+        value: "length_exactly",
+        label: "Length (exactly)",
+        options: [
+            {
+                type: "number",
+                key: "length",
+                tooltip: "Number of characters",
+            },
+        ],
+    }
+], false), uniqueValidation, true), commonValidations, true);
+var numericValidations = __spreadArray(__spreadArray([
+    {
+        value: "less_than",
+        label: "Must Be Less Than",
+        options: [
+            {
+                type: "number",
+                key: "max",
+                tooltip: "The max allowed value",
+            },
+        ],
+    },
+    {
+        value: "greater_than",
+        label: "Must Be Greater Than",
+        options: [
+            {
+                type: "number",
+                key: "min",
+                tooltip: "The minimum allowed value",
+            },
+        ],
+    },
+    { value: "even", label: "Must be Even" },
+    { value: "odd", label: "Must be Odd" }
+], uniqueValidation, true), commonValidations, true);
+var emailValidations = __spreadArray([
+    { value: "email", label: "Must be an email", isDefaultValidation: true }
+], stringValidations, true);
+var urlValidations = __spreadArray([
+    { value: "url", label: "Must be a URL", isDefaultValidation: true }
+], stringValidations, true);
+var booleanValidations = [
+    {
+        value: "boolean",
+        label: "Must be True or False",
+        isDefaultValidation: true,
+    },
+];
+var structuredDataValidations = __spreadArray([], uniqueValidation, true);
+var dateValidations = __spreadArray(__spreadArray([], uniqueValidation, true), [
+    {
+        value: "before_date",
+        label: "Must Be Before Date",
+        options: [
+            {
+                type: "date",
+                key: "max",
+                tooltip: "The maximum allowed date",
+            },
+        ],
+    },
+    {
+        value: "after_date",
+        label: "Must Be After Date",
+        options: [
+            {
+                type: "date",
+                key: "min",
+                tooltip: "The minimum allowed date",
+            },
+        ],
+    },
+], false);
+export var validationsByColumnType = {
+    string: stringValidations,
+    integer: __spreadArray([
+        {
+            value: "integer",
+            label: "Must be an integer",
+            isDefaultValidation: true,
+        }
+    ], numericValidations, true),
+    float: __spreadArray([
+        {
+            value: "float",
+            label: "Must be a float",
+            isDefaultValidation: true,
+        }
+    ], numericValidations, true),
+    email: emailValidations,
+    enum: structuredDataValidations,
+    url: urlValidations,
+    boolean: booleanValidations,
+    date: dateValidations,
+    datetime: dateValidations,
+    time: uniqueValidation,
+};
+export var validationsByType = Object.values(validationsByColumnType)
+    .reduce(function (acc, arr) { return acc.concat(arr); }, [])
+    .reduce(function (result, p) {
+    result[p.value] = p;
+    return result;
+}, {});
+export var availableColumnTypes = Object.keys(validationsByColumnType);
+export var patternsColumnTypes = Object.keys(allowedPatterns);
+var iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var validationsSchema = yup
+    .mixed()
+    .test("validations", "Invalid validations", function (value) {
+    var isAnArray = Array.isArray(value);
+    if (isAnArray) {
+        for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+            var validation = value_1[_i];
+            var validation_type = validation.validation_type, options = validation.options;
+            var optionsPropertyIsNotRequiredFor = [
+                "unique_case_insensitive",
+                "unique_case_sensitive",
+                "integer",
+                "boolean",
+                "odd",
+                "even",
+                "email",
+                "url",
+                "float",
+            ];
+            if (mutableValidationTypes.includes(validation_type)) {
+                if (optionsPropertyIsNotRequiredFor.includes(validation_type)) {
+                    continue;
+                }
+                if (!options) {
+                    return this.createError({
+                        path: "validations",
+                        message: "Options is required for this validation type",
+                    });
+                }
+                var min = options.min, max = options.max;
+                var minOptionDoesNotMatchISO = min && !min.match(iso8601Regex);
+                var maxOptionDoesNotMatchISO = max && !max.match(iso8601Regex);
+                if (minOptionDoesNotMatchISO || maxOptionDoesNotMatchISO) {
+                    return this.createError({
+                        path: "validations",
+                        message: "Invalid ISO 8601 format for min or max",
+                    });
+                }
+            }
+            else {
+                return this.createError({
+                    path: "validations",
+                    message: "".concat(validation_type, " is not a valid validation type. Please check the values you inserted."),
+                });
+            }
+        }
+        return true;
+    }
+    var arrayIsNotDefined = !["undefined", "null"].includes(typeof value);
+    if (arrayIsNotDefined && !isAnArray) {
+        return this.createError({
+            path: "validations",
+            message: "Validations must be an array",
+        });
+    }
+    return true;
+});
+var transformationsOptionsPropIsRequiredFor = [
+    "prefix",
+    "number_of_decimals",
+];
+var transformationsSchema = yup
+    .array()
+    .of(yup.object().shape({
+    transformation_type: yup
+        .string()
+        .oneOf(mutableTransformationTypes)
+        .required(),
+    options: yup.mixed().when("transformation_type", {
+        is: function (type) {
+            return transformationsOptionsPropIsRequiredFor.includes(type);
+        },
+        then: yup
+            .object()
+            .required("Options is required for this transformation type"),
+    }),
+}))
+    .test("transformations", "Invalid transformations", function (value, context) {
+    var isAnArray = Array.isArray(value);
+    if (isAnArray) {
+        for (var _i = 0, value_2 = value; _i < value_2.length; _i++) {
+            var transformation = value_2[_i];
+            var transformation_type = transformation.transformation_type;
+            // if user is selecting autoformat (for date, datetime and time) but has not
+            // defined pattern, it should throw an error
+            if (transformation_type === "autoformat") {
+                var parentRecord = context.parent;
+                if (!(parentRecord === null || parentRecord === void 0 ? void 0 : parentRecord.pattern)) {
+                    var columnType = parentRecord.column_type;
+                    var availablePatternsForColumnType = null;
+                    var getAvailablePatterns = function (patterns) {
+                        var patternValues = patterns.map(function (pattern) { return pattern.value; });
+                        return patternValues.join(", ");
+                    };
+                    switch (columnType) {
+                        case "date":
+                            availablePatternsForColumnType = getAvailablePatterns(datePatterns);
+                            break;
+                        case "datetime":
+                            availablePatternsForColumnType = getAvailablePatterns(dateTimePatterns);
+                            break;
+                        case "time":
+                            availablePatternsForColumnType = getAvailablePatterns(timePatterns);
+                            break;
+                    }
+                    return this.createError({
+                        path: "transformations",
+                        message: "The selected transformation type requires you to specify a pattern to your column. Available patterns for your column_type: ".concat(availablePatternsForColumnType),
+                    });
+                }
+            }
+            if (!mutableTransformationTypes.includes(transformation_type)) {
+                return this.createError({
+                    path: "transformations",
+                    message: "".concat(transformation_type, " is not a valid transformation type. Please check the values you inserted."),
+                });
+            }
+        }
+        return true;
+    }
+    var arrayIsNotDefined = !["undefined", "null"].includes(typeof value);
+    if (arrayIsNotDefined && !isAnArray) {
+        return this.createError({
+            path: "validations",
+            message: "Validations must be an array",
+        });
+    }
+    return true;
+});
+var columnSchema = yup.object().shape({
+    column_type: yup.string().oneOf(availableColumnTypes).required(),
+    internal_key: yup.string().required(),
+    label: yup.string().required(),
+    required: yup.boolean().required(),
+    validations: validationsSchema,
+    transformations: transformationsSchema,
+});
+var dateColumnSchema = columnSchema.shape({
+    pattern: yup.string().oneOf(datePatterns.map(function (p) { return p.value; })),
+});
+var dateTimeColumnSchema = columnSchema.shape({
+    pattern: yup.string().oneOf(dateTimePatterns.map(function (p) { return p.value; })),
+});
+var timeColumnSchema = columnSchema.shape({
+    pattern: yup.string().oneOf(timePatterns.map(function (p) { return p.value; })),
+});
+var enumColumnSchema = columnSchema.shape({
+    values: yup.array().of(yup.string()).min(1).required(),
+});
+export var validateColumn = function (columnData) { return __awaiter(void 0, void 0, void 0, function () {
+    var schema, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                schema = columnData.column_type === FieldTypes.date
+                    ? dateColumnSchema
+                    : columnData.column_type === FieldTypes.datetime
+                        ? dateTimeColumnSchema
+                        : columnData.column_type === FieldTypes.time
+                            ? timeColumnSchema
+                            : columnData.column_type === FieldTypes.enum
+                                ? enumColumnSchema
+                                : columnSchema;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, schema.validate(columnData, { abortEarly: true })];
+            case 2:
+                _a.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                error_1 = _a.sent();
+                throw new Error("Error on custom column creation: ".concat(error_1.message));
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };

package/lib/esm/common/datePatterns.d.ts

@@ -0,0 +1,26 @@
+export declare const datePatterns: {
+    value: string;
+    label: string;
+}[];
+export declare const dateTimePatterns: {
+    value: string;
+    label: string;
+}[];
+export declare const timePatterns: {
+    value: string;
+    label: string;
+}[];
+export declare const allowedPatterns: {
+    date: {
+        value: string;
+        label: string;
+    }[];
+    datetime: {
+        value: string;
+        label: string;
+    }[];
+    time: {
+        value: string;
+        label: string;
+    }[];
+};