@m4l/components 7.0.0 → 7.1.2

package/components/DynamicFilter/DynamicFIlter.styles.js

@@ -0,0 +1,379 @@
+import { alpha } from "@mui/material";
+import { c as containerQuery } from "../../utils/containerQuery.js";
+const CONTAINER_QUERY_NAME = "dynamic";
+const dynamicFilterStyles = {
+  root: {
+    containerName: CONTAINER_QUERY_NAME,
+    containerType: "inline-size",
+    width: "100%",
+    height: "auto",
+    padding: 0
+  },
+  /**
+   * TODO: Documentar
+   */
+  innerContainer: ({ theme, ownerState }) => ({
+    display: "grid",
+    gridTemplateColumns: "auto 1fr auto",
+    gridTemplateAreas: '"input-filter applied-filters actions-filter"',
+    alignItems: "center",
+    justifyContent: "flex-start",
+    width: "100%",
+    height: "fit-content",
+    border: "1px solid",
+    borderRadius: "4px",
+    borderColor: theme.vars.palette.border?.default,
+    background: theme.vars.palette.background.default,
+    [containerQuery(theme.breakpoints, CONTAINER_QUERY_NAME)]: {
+      minHeight: "auto",
+      height: "auto",
+      gridTemplateColumns: "1fr auto",
+      gridTemplateAreas: `"input-filter  actions-filter"
+                          "applied-filters applied-filters"`
+    },
+    "&:focus-within": {
+      borderColor: !ownerState.isValid ? theme.vars.palette.error.main : theme.vars.palette.primary.focusActive
+    },
+    ...ownerState.isValid === false ? {
+      borderColor: theme.vars.palette.error.main
+    } : {}
+  }),
+  /**
+   * TODO: Documentar
+   */
+  inputFilter: ({ theme }) => ({
+    gridArea: "input-filter",
+    display: "flex",
+    flexDirection: "row",
+    gap: "8px",
+    padding: "4px 6px 4px 4px",
+    height: "100%",
+    maxWidth: "135px",
+    width: "100%",
+    alignItems: "center",
+    borderTopLeftRadius: "4px",
+    borderBottomLeftRadius: "4px",
+    borderRight: "1px solid",
+    borderColor: theme.vars.palette.border?.default,
+    [containerQuery(theme.breakpoints, CONTAINER_QUERY_NAME)]: {
+      height: "32px",
+      width: "100%",
+      maxWidth: "100%",
+      borderRight: "none"
+    },
+    [theme.breakpoints.down("sm")]: {
+      height: "44px",
+      justifyContent: "center"
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  inputFilterInput: ({ theme }) => ({
+    ...theme.typography.body,
+    background: theme.vars.palette.background.default,
+    color: theme.vars.palette.text.secondary,
+    border: "1px solid",
+    borderColor: "transparent",
+    padding: "4px 8px",
+    width: "100%",
+    height: "100%",
+    "&::placeholder": {
+      color: theme.vars.palette.text.secondary
+    },
+    "&:focus-visible": {
+      color: theme.vars.palette.text.secondary,
+      border: "1px solid",
+      borderColor: theme.vars.palette.primary.opacity,
+      background: theme.vars.palette.primary.opacity,
+      BorderRadius: "2px",
+      outline: "none!important"
+    },
+    "&:hover": {
+      borderColor: theme.vars.palette.primary?.toneOpacity,
+      background: theme.vars.palette.background?.hover
+    }
+  }),
+  inputFilterIcon: {
+    visibility: "visible"
+  },
+  /**
+   * TODO: Documentar
+   */
+  appliedFilters: ({ theme }) => ({
+    gridArea: "applied-filters",
+    width: "100%",
+    height: "fit-content",
+    paddingLeft: theme.spacing(1),
+    borderLeft: "none",
+    margin: "0px",
+    padding: "0px 4px",
+    [containerQuery(theme.breakpoints, CONTAINER_QUERY_NAME)]: {
+      height: "auto",
+      padding: "4px",
+      display: "flex",
+      borderTop: "1px solid ",
+      borderColor: theme.vars.palette.border?.secondary,
+      "&:has(div[class*=appliedFilterInnerContainer]:empty), &:empty": {
+        display: "none"
+      }
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  appliedFilterInnerContainer: ({ theme }) => ({
+    padding: "2px",
+    gap: "4px",
+    height: "fit-content",
+    display: "flex",
+    flexWrap: "nowrap",
+    width: "100%",
+    justifyContent: "flex-start",
+    alignItems: "center",
+    [containerQuery(theme.breakpoints, CONTAINER_QUERY_NAME)]: {
+      height: "32px",
+      padding: 0,
+      margin: 0,
+      border: 0
+    },
+    [theme.breakpoints.down("sm")]: {
+      padding: 0,
+      height: "44px"
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  appliedFilterChip: ({ theme }) => ({
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center",
+    overflow: "visible",
+    width: "auto",
+    height: "24px",
+    minHeight: theme.spacing(3),
+    paddingLeft: theme.spacing(1),
+    borderColor: alpha(`${theme.colorSchemes.finalTheme.palette.divider}`, 0.1),
+    border: "none",
+    borderRadius: "4px",
+    backgroundColor: theme.vars.palette.background?.surface,
+    color: theme.vars.palette.text.secondary,
+    ...theme.typography.body,
+    [theme.breakpoints.down("sm")]: {
+      height: "fit-content"
+    }
+  }),
+  appliedFilterChipIcon: {
+    visibility: "visible"
+  },
+  /**
+   * TODO: Documentar
+   */
+  appliedFilterChipInfo: ({ theme }) => ({
+    ...theme.typography.body2,
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center",
+    width: "auto",
+    height: "100%",
+    marginRight: theme.spacing(1),
+    marginLeft: theme.spacing(1),
+    whiteSpace: "nowrap",
+    border: "none",
+    backgroundColor: "transparent"
+  }),
+  /**
+   * TODO: Documentar
+   */
+  appliedFilterChipInfoFieldName: ({ theme }) => ({
+    ...theme.typography.subtitle2,
+    color: theme.vars.palette.text.secondary
+  }),
+  /**
+   * TODO: Documentar
+   */
+  appliedFilterChipInfoOperator: ({ theme }) => ({
+    ...theme.typography.body2,
+    marginLeft: theme.spacing(1.5),
+    fontStyle: "italic",
+    color: theme.vars.palette.text.secondary
+  }),
+  /**
+   * TODO: Documentar
+   */
+  appliedFilterChipInfoOperands: ({ theme }) => ({
+    ...theme.typography.body2,
+    marginLeft: theme.spacing(1.5),
+    color: theme.vars.palette.text.secondary
+  }),
+  appliedFilterChipRemoveButton: {
+    visibility: "visible"
+  },
+  /**
+   * TODO: Documentar
+   */
+  actions: ({ theme }) => ({
+    gridArea: "actions-filter",
+    display: "flex",
+    flexDirection: "row",
+    gap: "8px",
+    padding: "4px",
+    height: "100%",
+    alignItems: "center",
+    borderTopRightRadius: "4px",
+    borderBottomRightRadius: "4px",
+    borderLeft: "1px solid",
+    borderColor: theme.vars.palette.border?.default
+  }),
+  actionsSkeletonButton: {
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center",
+    width: "24px",
+    height: "24px"
+  },
+  actionsClearButton: {
+    visibility: "visible"
+  },
+  /**
+   * TODO: Documentar
+   */
+  actionsSubmitButton: ({ theme, ownerState }) => ({
+    ...ownerState.isValid === false ? { border: `1px dashed ${theme.vars.palette.error.main}` } : {
+      visibility: "visible"
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  popoverMenu: ({ theme }) => ({
+    "& .MuiPaper-root": {
+      display: "flex",
+      flexDirection: "column",
+      padding: "8px !important",
+      gap: "4px",
+      borderRadius: "6px",
+      [theme.breakpoints.down("md")]: {
+        gap: "4px"
+      },
+      "& .M4LPopover-arrowStyle": {
+        display: "none"
+      }
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  popoverMenuItem: ({ theme }) => ({
+    paddingLeft: "4px",
+    paddingRight: "4px",
+    borderRadius: "4px",
+    "&:hover": {
+      ...theme.typography.body,
+      color: theme.vars.palette.primary?.hover,
+      background: theme.vars.palette.background?.surface,
+      borderRadius: "4px",
+      padding: "4px 12px 4px 8px"
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  popoverMenuItemLabel: ({ theme }) => ({
+    ...theme.typography.body,
+    color: theme.vars.palette.text.primary
+  }),
+  popoverMenuItemIcon: {
+    visibility: "visible"
+  },
+  /**
+   * TODO: Documentar
+   */
+  popoverFilter: ({ theme }) => ({
+    width: "auto",
+    "& .MuiPaper-root": {
+      padding: "0 !important",
+      minWidth: "220px",
+      maxWidth: "100%",
+      minHeight: "auto",
+      boxShadow: theme.vars.customShadows?.z3,
+      "& .M4LPopover-arrowStyle": {
+        display: "none"
+      },
+      "& .M4LRHFormProvider-root": {
+        gap: "0px",
+        width: "max-content",
+        minWidth: "220px",
+        maxWidth: "420px",
+        height: "fit-content"
+      }
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  popoverFilterHeader: ({ theme }) => ({
+    backgroundColor: theme.vars.palette.background?.surface,
+    display: "flex",
+    alignItems: "center",
+    gap: "8px",
+    padding: "4px 4px 4px 8px",
+    borderTopLeftRadius: "4px",
+    borderTopRightRadius: "4px",
+    borderBottom: "0px",
+    height: "28px",
+    [theme.breakpoints.down("sm")]: {
+      height: "36px"
+    }
+  }),
+  popoverFilterHeaderIcon: {
+    visibility: "visible"
+  },
+  /**
+   * TODO: Documentar
+   */
+  popoverFilterHeaderTitle: ({ theme }) => ({
+    ...theme.typography.paragraphDens,
+    color: theme.vars.palette.text.primary
+  }),
+  /**
+   * TODO: Documentar
+   */
+  popoverFilterContainerFields: ({ theme }) => ({
+    height: "fit-content",
+    "& > div": {
+      display: "flex",
+      height: "auto",
+      flexDirection: "column",
+      padding: "12px 12px 0 12px",
+      gap: "8px",
+      [theme.breakpoints.down("sm")]: {
+        padding: "16px 16px 0 16px",
+        gap: "12px"
+      }
+    }
+  }),
+  /**
+   * TODO: Documentar
+   */
+  popoverFilterActions: ({ theme }) => ({
+    display: "flex",
+    flexDirection: "row",
+    gap: "16px",
+    padding: "16px 12px 12px 12px !important",
+    [theme.breakpoints.down("sm")]: {
+      padding: "24px 16px 16px 16px !important"
+    },
+    "& > .M4LButton-root": {
+      height: "24px",
+      minHeight: "24px",
+      [theme.breakpoints.down("sm")]: {
+        height: "36px"
+      }
+    }
+  })
+};
+export {
+  dynamicFilterStyles as d
+};

package/components/DynamicFilter/DynamicFilter.d.ts

@@ -1,2 +1,5 @@
-import type { DynamicFilterProps } from './types';
+import { DynamicFilterProps } from './types';
+/**
+ * TODO: Documentar
+ */
 export declare function DynamicFilter(props: DynamicFilterProps): import("react/jsx-runtime").JSX.Element | null;

package/components/DynamicFilter/DynamicFilter.js

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+import { useFlagsPresent, CommonFlags } from "@m4l/core";
+import { D as DynamicFilterProvider } from "./store/DynamicFilterContext.js";
+import { D as DynamicFilterBase } from "./subcomponents/DynamicFilterBase/DynamicFilterBase.js";
+function DynamicFilter(props) {
+  const hasPresentFlags = useFlagsPresent([CommonFlags.FLAG_DICTIONARY_LOADED]);
+  if (!hasPresentFlags) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(DynamicFilterProvider, { ...props, children: /* @__PURE__ */ jsx(DynamicFilterBase, {}) });
+}
+export {
+  DynamicFilter as D
+};

package/components/DynamicFilter/DynamicFilter.stories.d.ts

@@ -0,0 +1,29 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { DynamicFilter } from './DynamicFilter';
+declare const meta: Meta<typeof DynamicFilter>;
+export default meta;
+type Story = StoryObj<typeof DynamicFilter>;
+/**
+ * Base DynamicFilter component
+ */
+export declare const Base: Story;
+/**
+ * DynamicFilter With props `automatic=true`
+ */
+export declare const WithAutomatic: Story;
+/**
+ * DynamicFilter With props `withAllField=true`
+ */
+export declare const WithAllField: Story;
+/**
+ * DynamicFilter With fixed field
+ */
+export declare const WithFixedField: Story;
+/**
+ * DynamicFilter in skeleton mode
+ */
+export declare const WithSkeleton: Story;
+/**
+ * DynamicFilter with errors
+ */
+export declare const WithErrors: Story;

package/components/DynamicFilter/__tests__/DynamicFilter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/DynamicFilter/constants.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanOperator, DateTimeOperator, Field, NumberOperator, SelectOperator, StringOperator } from './types';
+import { BooleanOperator, DateTimeOperator, Field, NumberOperator, SelectOperator, StringOperator } from './types';
 export declare const DYNAMIC_FILTER_KEY_COMPONENT = "M4LDynamicFilter";
 export declare const ALL_FIELD: Field;
 export declare const STRING_OPERATORS: Array<StringOperator>;

package/components/DynamicFilter/constants.js

@@ -0,0 +1,31 @@
+const DYNAMIC_FILTER_KEY_COMPONENT = "M4LDynamicFilter";
+const ALL_FIELD = {
+  name: "all",
+  dictionaryId: "dynamic_filter.all_fields",
+  urlIcon: "",
+  type: "string",
+  multiple: true,
+  presence: "optional"
+};
+const STRING_OPERATORS = ["c", "nc"];
+const NUMBER_OPERATORS = ["b", "e", "ne", "gt", "gte", "lt", "lte"];
+const BOOLEAN_OPERATORS = ["e", "ne"];
+const SELECT_OPERATORS = ["in", "nin"];
+const DATE_TIME_OPERATORS = [
+  "b",
+  "e",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+];
+export {
+  ALL_FIELD as A,
+  BOOLEAN_OPERATORS as B,
+  DYNAMIC_FILTER_KEY_COMPONENT as D,
+  NUMBER_OPERATORS as N,
+  SELECT_OPERATORS as S,
+  DATE_TIME_OPERATORS as a,
+  STRING_OPERATORS as b
+};

package/components/DynamicFilter/dictionary.d.ts

@@ -1,4 +1,7 @@
 export declare const DYNAMIC_FILTER_DICTIONARY_ID = "dynamic_filter";
+/**
+ * TODO: Documentar
+ */
 export declare function getDynamicFilterComponentsDictionary(): string[];
 export declare const DICCTIONARY: {
     readonly input_placeholder: "input_placeholder";
@@ -35,5 +38,5 @@ export declare const DICCTIONARY: {
     readonly label_select_operands_array: "label_select_operands_array";
     readonly error_operand_required: "error_operand_required";
 };
-export declare type TypeDictionary = typeof DICCTIONARY;
+export type TypeDictionary = typeof DICCTIONARY;
 export declare const getDynamicFilterDictionary: (key: keyof TypeDictionary) => string;

package/components/DynamicFilter/dictionary.js

@@ -0,0 +1,51 @@
+import { g as getCommonActionsDictionary } from "../CommonActions/dictionary.js";
+import { g as getRHFAutocompleteComponentsDictionary } from "../hook-form/RHFAutocomplete/dictionary.js";
+const DYNAMIC_FILTER_DICTIONARY_ID = "dynamic_filter";
+function getDynamicFilterComponentsDictionary() {
+  return [DYNAMIC_FILTER_DICTIONARY_ID].concat(
+    getCommonActionsDictionary().concat(getRHFAutocompleteComponentsDictionary())
+  );
+}
+const DICCTIONARY = {
+  input_placeholder: "input_placeholder",
+  operand_true: "operand_true",
+  operand_false: "operand_false",
+  filter_tooltip_refresh: "filter_tooltip_refresh",
+  filter_tooltip_dirty: "filter_tooltip_dirty",
+  filter_tooltip_invalid: "filter_tooltip_invalid",
+  operator_b: "operator_b",
+  operator_e: "operator_e",
+  operator_ne: "operator_ne",
+  operator_gt: "operator_gt",
+  operator_gte: "operator_gte",
+  operator_lt: "operator_lt",
+  operator_lte: "operator_lte",
+  operator_c: "operator_c",
+  operator_nc: "operator_nc",
+  operator_in: "operator_in",
+  operator_nin: "operator_nin",
+  label_boolean_operator: "label_boolean_operator",
+  label_boolean_operand1: "label_boolean_operand1",
+  label_operator_date_time: "label_operator_date_time",
+  label_operand1_date_time: "label_operand1_date_time",
+  label_operand2_date_time: "label_operand2_date_time",
+  label_operator_number: "label_operator_number",
+  label_operand1_number: "label_operand1_number",
+  label_operand2_number: "label_operand2_number",
+  label_operator_string: "label_operator_string",
+  label_operand1_string: "label_operand1_string",
+  operator_required: "operator_required",
+  error_invalid_date: "error_invalid_date",
+  error_less_than_start: "error_less_than_start",
+  label_select_operator: "label_select_operator",
+  label_select_operands_array: "label_select_operands_array",
+  error_operand_required: "error_operand_required"
+};
+const getDynamicFilterDictionary = (key) => {
+  return `${DYNAMIC_FILTER_DICTIONARY_ID}.${key}`;
+};
+export {
+  DICCTIONARY as D,
+  getDynamicFilterComponentsDictionary as a,
+  getDynamicFilterDictionary as g
+};

package/components/DynamicFilter/helpers/formatToInitialFilters.d.ts

@@ -1,6 +1,6 @@
-import type { FilterFieldApplied, InitialFilterApplied } from '../types';
+import { FilterFieldApplied, InitialFilterApplied } from '../types';
 /**
- * @description Función formateadora filtros como el DynamicFilter los usa a nivel interno a como se guardan en las cookies
+ * Función formateadora filtros como el DynamicFilter los usa a nivel interno a como se guardan en las cookies
  * @param appliedFilters Filtros actualmente aplicados
  * @returns
  */

package/components/DynamicFilter/helpers/formatToInitialFilters.js

@@ -0,0 +1,31 @@
+import { f as filterValidOperandsArraySelect } from "../subcomponents/FieldTypes/SelectFilter/helpers.js";
+function formatToInitialFilters(appliedFilters) {
+  return appliedFilters.map((appliedFilter) => {
+    const ret = {
+      name: appliedFilter.field.name,
+      operator: appliedFilter.operator,
+      operand1: appliedFilter.operand1,
+      operand2: appliedFilter.operator === "b" ? appliedFilter.operand2 : void 0
+    };
+    if (appliedFilter.fieldType === "datetime") {
+      ret.operand1 = appliedFilter.operand1.toISOString();
+      ret.operand2 = appliedFilter.operator === "b" ? appliedFilter.operand2.toISOString() : void 0;
+    }
+    if (appliedFilter.fieldType === "select") {
+      const validOperandsArray = filterValidOperandsArraySelect(
+        appliedFilter.operandsArray,
+        appliedFilter.field
+      );
+      if (validOperandsArray && validOperandsArray?.length > 0) {
+        ret.operandsArray = validOperandsArray;
+      }
+    }
+    if (ret.operand2 === void 0) {
+      delete ret.operand2;
+    }
+    return ret;
+  });
+}
+export {
+  formatToInitialFilters as f
+};

package/components/DynamicFilter/helpers/formatToRowFilter.d.ts

@@ -1,6 +1,6 @@
-import type { FilterFieldApplied, RawFilterFieldApply } from '../types';
+import { FilterFieldApplied, RawFilterFieldApply } from '../types';
 /**
- * @description Función formateadora filtros como el DynamicFilter los usa a nivel interno a como se envían a la API
+ * Función formateadora filtros como el DynamicFilter los usa a nivel interno a como se envían a la API
  * @param appliedFilters Filtros actualmente aplicados
  * @returns
  */

package/components/DynamicFilter/helpers/formatToRowFilter.js

@@ -0,0 +1,18 @@
+const formatToRawFilter = (appliedFilters) => {
+  return appliedFilters.map((af) => {
+    let oa = void 0;
+    if (af.field.type === "select" && af.operandsArray) {
+      oa = Array.isArray(af.operandsArray) ? af.operandsArray.map(af.field.selectOptions.getOptionId) : [af.field.selectOptions.getOptionId(af.operandsArray)];
+    }
+    return {
+      n: af.field.name,
+      o: af.operator,
+      o1: af.operand1,
+      o2: af.operator === "b" ? af.operand2 : void 0,
+      oa
+    };
+  });
+};
+export {
+  formatToRawFilter as f
+};

package/components/DynamicFilter/helpers/getPurgedInitialFiltersApplied.d.ts

@@ -1,8 +1,6 @@
-import type { Field, FilterFieldApplied, InitialFilterApplied } from '../types';
+import { Field, FilterFieldApplied, InitialFilterApplied } from '../types';
 /**
- * @name getPurgedInitialFiltersApplied
- * @description Función encargada de purgar cualquier error que pueda venir del endpoint, por algun cambio de versión
- *
+ * Función encargada de purgar cualquier error que pueda venir del endpoint, por algun cambio de versión
  * @param fields todos los campos que pueden aparecer en el filtro no Inclute el AllField
  * @param initialFilters Filtros que van a ser purgados (Eliminados si tienen errores)
  * @param getFieldByName Funcion para obtener el Field a través del nombre

package/components/DynamicFilter/helpers/getPurgedInitialFiltersApplied.js

@@ -0,0 +1,61 @@
+import { f as fieldFactory } from "../subcomponents/FieldTypes/fieldFactory.js";
+function getPurgedInitialFiltersApplied(fields, initialFilters, getFieldByName) {
+  const newFilters = [];
+  const fixedFields = [];
+  for (let index = 0; index < initialFilters.length; index++) {
+    try {
+      const initialFilter = initialFilters[index];
+      const field = getFieldByName(initialFilter.name);
+      const filter = {
+        id: 0,
+        isSet: true,
+        fixed: false,
+        field,
+        fieldType: field.type,
+        operator: initialFilters[index].operator,
+        operand1: initialFilters[index].operand1,
+        operand2: initialFilters[index].operand2,
+        operandsArray: initialFilters[index].operandsArray
+      };
+      if (!field) {
+        continue;
+      }
+      const canAddField = fieldFactory(field.type).verifyFilter(initialFilter, field);
+      if (canAddField) {
+        if (filter.fieldType === "datetime") {
+          filter.operand1 = /* @__PURE__ */ new Date(filter.operand1 + "");
+          filter.operand2 = /* @__PURE__ */ new Date(filter.operand2 + "");
+        }
+        if (field.presence === "fixed") {
+          if (fixedFields.findIndex((f) => f === field.name) === -1) {
+            filter.fixed = true;
+            fixedFields.push(field.name);
+          } else {
+            filter.fixed = false;
+          }
+        }
+        filter.isSet = true;
+        filter.id = newFilters.length + 1;
+        newFilters.push(filter);
+      }
+    } catch (_e) {
+    }
+  }
+  for (let index = 0; index < fields.length; index++) {
+    const field = fields[index];
+    if (field.presence === "initialized" || field.presence === "fixed") {
+      if (!initialFilters.find((f) => f.name === field.name)) {
+        const newFilter = fieldFactory(field.type).getDefaultFilter(
+          field,
+          field.presence === "fixed"
+        );
+        newFilter.id = newFilters.length + 1;
+        newFilters.push(newFilter);
+      }
+    }
+  }
+  return newFilters;
+}
+export {
+  getPurgedInitialFiltersApplied as g
+};

package/components/DynamicFilter/index.js

@@ -0,0 +1 @@
+