@m4l/components 1.0.15 → 1.0.17

package/components/DynamicFilter/subcomponents/FieldTypes/DateTimeFilter/index.2382297a.js

@@ -0,0 +1,169 @@
+import * as Yup from "yup";
+import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../../dictionary.80fc7baf.js";
+import { a as DATE_TIME_OPERATORS } from "../../../constants.095f1dbb.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useFormContext, useWatch } from "react-hook-form";
+import { useModuleDictionary } from "@m4l/core";
+import { R as RHFAutocomplete } from "../../../../hook-form/RHFAutocomplete/index.1efaddc9.js";
+import { R as RHFDateTime } from "../../../../hook-form/RHFDateTime/index.b3d0b2de.js";
+import { i as isValidDate } from "../../../../../utils/index.14912462.js";
+function DateTimeFilter() {
+  const { getLabel } = useModuleDictionary();
+  const { control } = useFormContext();
+  const operator = useWatch({
+    control,
+    name: "formValueOperator"
+  });
+  const operators = useMemo(
+    () => DATE_TIME_OPERATORS.map((o) => ({
+      id: o,
+      label: getLabel(getDynamicFilterDictionary(`operator_${o}`))
+    })),
+    [getLabel]
+  );
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx(
+      RHFAutocomplete,
+      {
+        name: "formValueOperator",
+        autoComplete: "off",
+        options: operators,
+        getOptionLabel: (option) => option.label,
+        isOptionEqualToValue: (option, value) => option.id === value.id,
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operator_date_time))
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      RHFDateTime,
+      {
+        name: "formValueOperand1",
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operand1_date_time))
+      }
+    ),
+    operator && operator.id === "b" && /* @__PURE__ */ jsx(
+      RHFDateTime,
+      {
+        name: "formValueOperand2",
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operand2_date_time))
+      }
+    )
+  ] });
+}
+class DateTimeFilterHelpers {
+  getComponent() {
+    return DateTimeFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultStartDate = new Date();
+    const defaultEndDate = new Date();
+    defaultStartDate.setHours(0, 0, 0, 0);
+    defaultEndDate.setHours(23, 59, 59, 999);
+    const defaultOperand1 = field.defaultOperand1 && field.defaultOperand1 instanceof Date ? field.defaultOperand1 : defaultStartDate;
+    const defaultOperand2 = field.defaultOperand2 && field.defaultOperand2 instanceof Date ? field.defaultOperand2 : defaultEndDate;
+    return {
+      id: 0,
+      fieldType: "datetime",
+      field,
+      fixed,
+      isSet: true,
+      operator: "b",
+      operand1: defaultOperand1,
+      operand2: defaultOperand2
+    };
+  }
+  getFormValue(field, getLabel, filterValueDateTime) {
+    const filterValue = filterValueDateTime;
+    const operator = filterValue ? filterValue.operator : field.defaultOperator ?? "b";
+    const defaultStartDate = new Date();
+    const defaultEndDate = new Date();
+    const defaultOperand1 = field.defaultOperand1 && field.defaultOperand1 instanceof Date ? field.defaultOperand1 : defaultStartDate;
+    const defaultOperand2 = field.defaultOperand2 && field.defaultOperand2 instanceof Date ? field.defaultOperand2 : defaultEndDate;
+    const formValueOperand1 = filterValue ? filterValue.operand1 : defaultOperand1;
+    const formValueOperand2 = filterValue && filterValue.operator === "b" ? filterValue.operand2 : defaultOperand2;
+    return {
+      fieldType: "datetime",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1,
+      formValueOperand2
+    };
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1;
+    if (operator === "b") {
+      const operand2 = formFilterValue.formValueOperand2;
+      return {
+        fieldType: "datetime",
+        operator,
+        operand1,
+        operand2
+      };
+    } else {
+      return {
+        fieldType: "datetime",
+        operator,
+        operand1
+      };
+    }
+  }
+  getLabels(filter, getLabel, formatters, _field) {
+    const { dateFormatter } = formatters;
+    let labelOperands;
+    if (filter.operator === "b") {
+      labelOperands = filter.operand1 && filter.operand2 ? `${dateFormatter.formatDate(
+        filter.operand1,
+        dateFormatter.datetimeFormat
+      )} - ${dateFormatter.formatDate(filter.operand2, dateFormatter.datetimeFormat)}` : "";
+    } else {
+      labelOperands = filter.operand1 ? dateFormatter.formatDate(filter.operand1, dateFormatter.datetimeFormat) : "";
+    }
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(getDynamicFilterDictionary(DICCTIONARY.operator_required))),
+      formValueOperand1: Yup.date().required(getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))).typeError(getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))),
+      formValueOperand2: Yup.mixed().when(["formValueOperator.id"], {
+        is: "b",
+        then: Yup.date().typeError(getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))).min(
+          Yup.ref("formValueOperand1"),
+          getLabel(getDynamicFilterDictionary(DICCTIONARY.error_invalid_date))
+        )
+      })
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (DATE_TIME_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (typeof filter.operand1 !== "string") {
+      return false;
+    }
+    if (!isValidDate(new Date(filter.operand1))) {
+      return false;
+    }
+    if (filter.operator === "b") {
+      if (typeof filter.operand2 !== "string") {
+        return false;
+      }
+      if (!isValidDate(new Date(filter.operand1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+export {
+  DateTimeFilterHelpers as D
+};

package/components/DynamicFilter/subcomponents/FieldTypes/NumberFilter/index.7b4dccf7.js

@@ -0,0 +1,151 @@
+import * as Yup from "yup";
+import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../../dictionary.80fc7baf.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useFormContext, useWatch } from "react-hook-form";
+import { useModuleDictionary } from "@m4l/core";
+import { N as NUMBER_OPERATORS } from "../../../constants.095f1dbb.js";
+import { R as RHFAutocomplete } from "../../../../hook-form/RHFAutocomplete/index.1efaddc9.js";
+import { R as RHFTextField } from "../../../../hook-form/RHFTextField/index.97ba17ae.js";
+function NumberFilter() {
+  const { getLabel } = useModuleDictionary();
+  const { control } = useFormContext();
+  const operator = useWatch({
+    control,
+    name: "formValueOperator"
+  });
+  const operators = useMemo(
+    () => NUMBER_OPERATORS.map((o) => ({
+      id: o,
+      label: getLabel(getDynamicFilterDictionary(`operator_${o}`))
+    })),
+    [getLabel]
+  );
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx(
+      RHFAutocomplete,
+      {
+        name: "formValueOperator",
+        autoComplete: "off",
+        options: operators,
+        getOptionLabel: (option) => option.label,
+        isOptionEqualToValue: (option, value) => option.id === value.id,
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operator_number))
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      RHFTextField,
+      {
+        name: "formValueOperand1",
+        type: "number",
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operand1_number))
+      }
+    ),
+    operator && operator.id === "b" && /* @__PURE__ */ jsx(
+      RHFTextField,
+      {
+        name: "formValueOperand2",
+        type: "number",
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operand2_number))
+      }
+    )
+  ] });
+}
+class NumberFilterHelpers {
+  getComponent() {
+    return NumberFilter;
+  }
+  getDefaultFilter(fieldNumber, fixed) {
+    const field = fieldNumber;
+    const dOperator = field.defaultOperator ?? "e";
+    const defaultOperand1 = field.defaultOperand1 ?? null;
+    const defaultOperand2 = field.defaultOperand2 ?? null;
+    return {
+      id: 0,
+      fieldType: "number",
+      field,
+      fixed,
+      isSet: false,
+      operator: dOperator,
+      operand1: defaultOperand1,
+      operand2: defaultOperand2
+    };
+  }
+  getFormValue(field, getLabel, filterValue) {
+    const filterValueNumber = filterValue;
+    const operator = filterValueNumber ? filterValueNumber.operator : field.defaultOperator ?? "e";
+    const formValueOperand1 = filterValueNumber ? filterValueNumber.operand1 : null;
+    const formValueOperand2 = filterValueNumber && filterValueNumber?.operator === "b" ? filterValueNumber.operand2 : null;
+    return {
+      fieldType: "number",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1,
+      formValueOperand2
+    };
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1 ? formFilterValue.formValueOperand1 : 0;
+    if (operator === "b") {
+      const operand2 = formFilterValue.formValueOperand2 ? formFilterValue.formValueOperand2 : 0;
+      return {
+        fieldType: "number",
+        operator,
+        operand1,
+        operand2
+      };
+    } else {
+      return {
+        fieldType: "number",
+        operator,
+        operand1
+      };
+    }
+  }
+  getLabels(filter, getLabel, _formatters, _field) {
+    let labelOperands;
+    if (filter.operator === "b") {
+      labelOperands = filter.operand1 && filter.operand2 ? `${filter.operand1} - ${filter.operand2}` : "";
+    } else {
+      labelOperands = filter.operand1 !== void 0 ? filter.operand1 + "" : "";
+    }
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(`dynamic_filter.error_operator_required`)),
+      formValueOperand1: Yup.number().typeError(
+        getLabel(`dynamic_filter.error_operand_mustbe_number`)
+      ),
+      formValueOperand2: Yup.mixed().when(["formValueOperator.id"], {
+        is: "b",
+        then: Yup.number().typeError(getLabel(`dynamic_filter.error_operand_mustbe_number`)).min(Yup.ref("formValueOperand1"), getLabel(`dynamic_filter.error_less_than_start`))
+      })
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "number") {
+      return false;
+    }
+    if (NUMBER_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (typeof filter.operand1 !== "number") {
+      return false;
+    }
+    if (filter.operator === "b" && typeof filter.operand2 !== "number") {
+      return false;
+    }
+    return true;
+  }
+}
+export {
+  NumberFilterHelpers as N
+};

package/components/DynamicFilter/subcomponents/FieldTypes/SelectFilter/index.2258fceb.js

@@ -0,0 +1,145 @@
+import * as Yup from "yup";
+import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../../dictionary.80fc7baf.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useModuleDictionary } from "@m4l/core";
+import { S as SELECT_OPERATORS } from "../../../constants.095f1dbb.js";
+import { u as useDynamicFilterStore } from "../../../store/index.b9c2fe0b.js";
+import { R as RHFAutocomplete } from "../../../../hook-form/RHFAutocomplete/index.1efaddc9.js";
+import { R as RHFAutocompleteAsync } from "../../../../hook-form/RHFAutocompleteAsync/index.2f123535.js";
+function SelectFilter() {
+  const { getLabel } = useModuleDictionary();
+  const field = useDynamicFilterStore((state) => state.popoverFilterData?.field);
+  if (!field?.selectOptions?.endPoint) {
+    throw new Error("El filtro tipo Select requiere la configuraci\xF3n del Endpoint");
+  }
+  const autocompleteProps = field?.selectOptions;
+  const operators = useMemo(
+    () => SELECT_OPERATORS.map((o) => ({
+      id: o,
+      label: getLabel(getDynamicFilterDictionary(`operator_${o}`))
+    })),
+    [getLabel]
+  );
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx(
+      RHFAutocomplete,
+      {
+        name: "formValueOperator",
+        autoComplete: "off",
+        options: operators,
+        getOptionLabel: (option) => option.label,
+        isOptionEqualToValue: (option, value) => option.id === value.id,
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_select_operator))
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      RHFAutocompleteAsync,
+      {
+        ...autocompleteProps,
+        name: "formValueOperandsArray",
+        autoComplete: "off",
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_select_operands_array))
+      }
+    )
+  ] });
+}
+function filterValidOperandsArraySelect(operandsArray, field) {
+  const operandsArrayFormatted = Array.isArray(operandsArray) ? operandsArray : [operandsArray];
+  const getOptionId = field?.selectOptions?.getOptionId;
+  const getOptionLabel = field?.selectOptions?.getOptionLabel;
+  return operandsArrayFormatted?.filter((operand) => {
+    return typeof operand === "object" && getOptionId?.(operand) && getOptionLabel?.(operand);
+  });
+}
+class SelectFilterHelpers {
+  getComponent() {
+    return SelectFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultOperand = field.defaultOperandsArray;
+    const defaultFilter = {
+      id: 0,
+      fieldType: "select",
+      field,
+      fixed,
+      isSet: true,
+      operator: "in",
+      operandsArray: []
+    };
+    if (defaultOperand !== void 0 && Array.isArray(defaultOperand)) {
+      const validOperandsArray = filterValidOperandsArraySelect(defaultOperand, field);
+      defaultFilter.operandsArray = validOperandsArray || [];
+    }
+    return defaultFilter;
+  }
+  getFormValue(field, getLabel, filterValueSelect) {
+    const filterValue = filterValueSelect ? filterValueSelect : void 0;
+    const isMultiple = field?.selectOptions?.multiple ?? false;
+    const formValueOperandsArray = isMultiple ? filterValueSelect?.operandsArray : filterValueSelect?.operandsArray?.[0] || filterValueSelect?.operandsArray;
+    const operator = filterValue ? filterValue.operator : field.defaultOperator ?? "in";
+    return {
+      fieldType: "select",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperandsArray
+    };
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operandsArray = Array.isArray(formFilterValue.formValueOperandsArray) ? formFilterValue.formValueOperandsArray : [formFilterValue.formValueOperandsArray];
+    return {
+      fieldType: "select",
+      operator,
+      operandsArray
+    };
+  }
+  getLabels(filter, getLabel, _formatters, field) {
+    const operandsArray = filter.operandsArray;
+    const labelOperands = operandsArray?.reduce?.((label, operand) => {
+      const textLabel = field.selectOptions?.getOptionLabel?.(operand) || "";
+      return label ? `${label} | ${textLabel}` : textLabel;
+    }, "")?.toString() || "";
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(`dynamic_filter.error_operator_required`)),
+      formValueOperandsArray: Yup.lazy((value) => {
+        return Array.isArray(value) ? Yup.array().min(1, getLabel(`dynamic_filter.error_operand_required`)).of(Yup.object().nullable()).required(getLabel(`dynamic_filter.error_operand_required`)) : Yup.object().nullable().required(getLabel(`dynamic_filter.error_operand_required`));
+      })
+    });
+  }
+  verifyFilter(filter, field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (!field) {
+      return false;
+    }
+    if (SELECT_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (!filter.operandsArray || typeof filter.operandsArray !== "object") {
+      return false;
+    }
+    const validOperandsArray = filterValidOperandsArraySelect(
+      filter.operandsArray,
+      field
+    );
+    if (!validOperandsArray || validOperandsArray?.length === 0) {
+      return false;
+    }
+    return true;
+  }
+}
+export {
+  SelectFilterHelpers as S,
+  filterValidOperandsArraySelect as f
+};

package/components/DynamicFilter/subcomponents/FieldTypes/StringFilter/index.82ca3e32.js

@@ -0,0 +1,112 @@
+import * as Yup from "yup";
+import { g as getDynamicFilterDictionary, D as DICCTIONARY } from "../../../dictionary.80fc7baf.js";
+import { b as STRING_OPERATORS } from "../../../constants.095f1dbb.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useModuleDictionary } from "@m4l/core";
+import { R as RHFAutocomplete } from "../../../../hook-form/RHFAutocomplete/index.1efaddc9.js";
+import { R as RHFTextField } from "../../../../hook-form/RHFTextField/index.97ba17ae.js";
+function StringFilter() {
+  const { getLabel } = useModuleDictionary();
+  const operators = useMemo(
+    () => STRING_OPERATORS.map((o) => ({
+      id: o,
+      label: getLabel(getDynamicFilterDictionary(`operator_${o}`))
+    })),
+    [getLabel]
+  );
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx(
+      RHFAutocomplete,
+      {
+        name: "formValueOperator",
+        autoComplete: "off",
+        options: operators,
+        getOptionLabel: (option) => option.label,
+        isOptionEqualToValue: (option, value) => option.id === value.id,
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operator_string))
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      RHFTextField,
+      {
+        name: "formValueOperand1",
+        label: getLabel(getDynamicFilterDictionary(DICCTIONARY.label_operand1_string))
+      }
+    )
+  ] });
+}
+class StringFilterHelpers {
+  getComponent() {
+    return StringFilter;
+  }
+  getDefaultFilter(field, fixed) {
+    const defaultOperand1 = field.defaultOperand1;
+    const defaultFilter = {
+      id: 0,
+      fieldType: "string",
+      field,
+      fixed,
+      isSet: false,
+      operator: "c",
+      operand1: ""
+    };
+    if (defaultOperand1 !== void 0 && typeof defaultOperand1 === "string") {
+      defaultFilter.operand1 = defaultOperand1;
+    }
+    return defaultFilter;
+  }
+  getFilterFromFormValue(formFilterValue) {
+    const operator = formFilterValue.formValueOperator.id;
+    const operand1 = formFilterValue.formValueOperand1;
+    return {
+      fieldType: "string",
+      operator,
+      operand1
+    };
+  }
+  getFormValue(field, getLabel, filterValue) {
+    const filterValueString = filterValue;
+    const operator = filterValueString ? filterValueString.operator : field.defaultOperator ?? "c";
+    const formValueOperand1 = filterValueString ? filterValueString.operand1 : "";
+    return {
+      fieldType: "string",
+      formValueOperator: {
+        id: operator,
+        label: getLabel(getDynamicFilterDictionary(`operator_${operator}`))
+      },
+      formValueOperand1
+    };
+  }
+  getLabels(filter, getLabel, _formatters, _field) {
+    const labelOperands = filter.operand1 !== void 0 ? filter.operand1 + "" : "";
+    return {
+      labelField: filter.field.label ?? getLabel(filter.field.dictionaryId),
+      labelOperator: getLabel(getDynamicFilterDictionary(`operator_${filter.operator}`)),
+      labelOperands
+    };
+  }
+  getSchema(getLabel) {
+    return Yup.object({
+      formValueOperator: Yup.object().nullable().required(getLabel(getDynamicFilterDictionary(DICCTIONARY.operator_required))),
+      formValueOperand1: Yup.string().required(
+        getLabel(getDynamicFilterDictionary(DICCTIONARY.error_operand_required))
+      )
+    });
+  }
+  verifyFilter(filter, _field) {
+    if (typeof filter.operator !== "string") {
+      return false;
+    }
+    if (STRING_OPERATORS.findIndex((f) => f === filter.operator) === -1) {
+      return false;
+    }
+    if (typeof filter.operand1 !== "string") {
+      return false;
+    }
+    return true;
+  }
+}
+export {
+  StringFilterHelpers as S
+};

package/components/DynamicFilter/subcomponents/FieldTypes/index.f4457f31.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { useFormContext } from "react-hook-form";
+import { B as BooleanFilterHelpers } from "./BooleanFilter/index.f926af49.js";
+import { S as StringFilterHelpers } from "./StringFilter/index.82ca3e32.js";
+import { D as DateTimeFilterHelpers } from "./DateTimeFilter/index.2382297a.js";
+import { N as NumberFilterHelpers } from "./NumberFilter/index.7b4dccf7.js";
+import { S as SelectFilterHelpers } from "./SelectFilter/index.2258fceb.js";
+const helpersStrategies = {
+  boolean: new BooleanFilterHelpers(),
+  string: new StringFilterHelpers(),
+  number: new NumberFilterHelpers(),
+  datetime: new DateTimeFilterHelpers(),
+  select: new SelectFilterHelpers(),
+  __default__: () => {
+    throw new Error("Type no defined");
+  }
+};
+function fieldFactory(type) {
+  const selectedHelper = helpersStrategies?.[type];
+  if (!selectedHelper) {
+    return helpersStrategies.__default__();
+  }
+  return selectedHelper;
+}
+function DataTypeComponent(props) {
+  const { formFilter, statusLoad } = props;
+  const { setFocus } = useFormContext();
+  const Component = fieldFactory(formFilter.field.type).getComponent();
+  useEffect(() => {
+    setTimeout(() => setFocus("formValueOperand1"), 100);
+  }, [statusLoad]);
+  return /* @__PURE__ */ jsx(Component, {});
+}
+export {
+  DataTypeComponent as D,
+  fieldFactory as f
+};