@multiplatform.one/table 6.0.0

package/dist/cjs/components/DataTableFilters/DataTableFilters.spec.cjs

@@ -0,0 +1,687 @@
+var import_test_utils = require("@multiplatform.one/test-utils");
+var import_vitest = require("vitest");
+var import_index = require("./index.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+(0, import_vitest.describe)("DataTableFilters", () => {
+  const sampleColumns = [{
+    id: "name",
+    label: "Name",
+    type: "text"
+  }, {
+    id: "age",
+    label: "Age",
+    type: "number"
+  }, {
+    id: "status",
+    label: "Status",
+    type: "select",
+    options: [{
+      label: "Active",
+      value: "active"
+    }, {
+      label: "Inactive",
+      value: "inactive"
+    }]
+  }, {
+    id: "date",
+    label: "Date",
+    type: "date"
+  }];
+  const sampleFilters = [{
+    id: "filter1",
+    columnId: "name",
+    value: {
+      operator: "contains",
+      value: "John"
+    }
+  }, {
+    id: "filter2",
+    columnId: "age",
+    value: {
+      operator: "isGreaterThanOrEqual",
+      value: 25
+    }
+  }];
+  const defaultProps = {
+    filters: [],
+    onFiltersChange: import_vitest.vi.fn(),
+    onAddFilter: import_vitest.vi.fn(),
+    onRemoveFilter: import_vitest.vi.fn(),
+    onClearFilters: import_vitest.vi.fn(),
+    availableColumns: sampleColumns,
+    maxFilters: 10,
+    showFilterCount: true,
+    compact: false
+  };
+  (0, import_vitest.describe)("basic rendering", () => {
+    (0, import_vitest.it)("should render filters component with no filters", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should render filters component with existing filters", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should display filter count when showFilterCount is true", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        showFilterCount: true
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should not display filter count when showFilterCount is false", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        showFilterCount: false
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("filter management", () => {
+    (0, import_vitest.it)("should call onAddFilter when adding a new filter", () => {
+      const onAddFilter = import_vitest.vi.fn();
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        onAddFilter
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should call onRemoveFilter when removing a filter", () => {
+      const onRemoveFilter = import_vitest.vi.fn();
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        onRemoveFilter
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should call onClearFilters when clearing all filters", () => {
+      const onClearFilters = import_vitest.vi.fn();
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        onClearFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should call onFiltersChange when filters are updated", () => {
+      const onFiltersChange = import_vitest.vi.fn();
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        onFiltersChange
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should prevent adding filters beyond maxFilters limit", () => {
+      const onAddFilter = import_vitest.vi.fn();
+      const manyFilters = Array.from({
+        length: 10
+      }, (_, i) => ({
+        id: `filter${i}`,
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: `value${i}`
+        }
+      }));
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: manyFilters,
+        maxFilters: 10,
+        onAddFilter
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("filter types", () => {
+    (0, import_vitest.it)("should handle text filters", () => {
+      const textFilters = [{
+        id: "text1",
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: "search term"
+        }
+      }, {
+        id: "text2",
+        columnId: "name",
+        value: {
+          operator: "is",
+          value: "exact match"
+        }
+      }, {
+        id: "text3",
+        columnId: "name",
+        value: {
+          operator: "startsWith",
+          value: "prefix"
+        }
+      }];
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: textFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle number filters", () => {
+      const numberFilters = [{
+        id: "num1",
+        columnId: "age",
+        value: {
+          operator: "is",
+          value: 25
+        }
+      }, {
+        id: "num2",
+        columnId: "age",
+        value: {
+          operator: "isGreaterThanOrEqual",
+          value: 18
+        }
+      }, {
+        id: "num3",
+        columnId: "age",
+        value: {
+          operator: "isLessThanOrEqual",
+          value: 65
+        }
+      }, {
+        id: "num4",
+        columnId: "age",
+        value: {
+          operator: "isBetween",
+          value: 20,
+          values: [20, 30]
+        }
+      }];
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: numberFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle select filters", () => {
+      const selectFilters = [{
+        id: "select1",
+        columnId: "status",
+        value: {
+          operator: "is",
+          value: "active"
+        }
+      }, {
+        id: "select2",
+        columnId: "status",
+        value: {
+          operator: "isAnyOf",
+          value: "active",
+          values: ["active", "inactive"]
+        }
+      }];
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: selectFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle date filters", () => {
+      const dateFilters = [{
+        id: "date1",
+        columnId: "date",
+        value: {
+          operator: "is",
+          value: /* @__PURE__ */new Date("2024-01-01")
+        }
+      }, {
+        id: "date2",
+        columnId: "date",
+        value: {
+          operator: "isBefore",
+          value: /* @__PURE__ */new Date("2024-12-31")
+        }
+      }, {
+        id: "date3",
+        columnId: "date",
+        value: {
+          operator: "isAfter",
+          value: /* @__PURE__ */new Date("2024-01-01")
+        }
+      }, {
+        id: "date4",
+        columnId: "date",
+        value: {
+          operator: "isBetween",
+          value: /* @__PURE__ */new Date("2024-01-01"),
+          values: [/* @__PURE__ */new Date("2024-01-01"), /* @__PURE__ */new Date("2024-12-31")]
+        }
+      }];
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: dateFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("compact mode", () => {
+    (0, import_vitest.it)("should render in compact mode when compact is true", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        compact: true
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should render in normal mode when compact is false", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        compact: false
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("filter builder", () => {
+    (0, import_vitest.it)("should show filter builder dialog", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle column selection in filter builder", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle operator selection in filter builder", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle value input in filter builder", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("filter display", () => {
+    (0, import_vitest.it)("should display active filters", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should show filter badges with descriptions", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should allow removing individual filters", () => {
+      const onRemoveFilter = import_vitest.vi.fn();
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        onRemoveFilter
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should show clear all filters button", () => {
+      const onClearFilters = import_vitest.vi.fn();
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters,
+        onClearFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("responsive behavior", () => {
+    (0, import_vitest.it)("should adapt to different screen sizes", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should show sheet on mobile devices", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("accessibility", () => {
+    (0, import_vitest.it)("should have proper ARIA labels for filter buttons", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should have proper ARIA labels for filter inputs", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should support keyboard navigation", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should announce filter changes to screen readers", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("edge cases", () => {
+    (0, import_vitest.it)("should handle empty filters array", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: []
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle empty availableColumns array", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        availableColumns: []
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle filters with invalid column references", () => {
+      const invalidFilters = [{
+        id: "invalid",
+        columnId: "nonexistent",
+        value: {
+          operator: "is",
+          value: "test"
+        }
+      }];
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: invalidFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle filters with null/undefined values", () => {
+      const nullFilters = [{
+        id: "null1",
+        columnId: "name",
+        value: {
+          operator: "is",
+          value: null
+        }
+      }, {
+        id: "undefined1",
+        columnId: "name",
+        value: {
+          operator: "is",
+          value: void 0
+        }
+      }];
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: nullFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle maximum number of filters", () => {
+      const maxFilters = Array.from({
+        length: 10
+      }, (_, i) => ({
+        id: `filter${i}`,
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: `value${i}`
+        }
+      }));
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: maxFilters,
+        maxFilters: 10
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("performance", () => {
+    (0, import_vitest.it)("should handle large number of filters", () => {
+      const largeFilters = Array.from({
+        length: 50
+      }, (_, i) => ({
+        id: `filter${i}`,
+        columnId: "name",
+        value: {
+          operator: "contains",
+          value: `search term ${i}`
+        }
+      }));
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: largeFilters
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle large number of available columns", () => {
+      const largeColumns = Array.from({
+        length: 100
+      }, (_, i) => ({
+        id: `column${i}`,
+        label: `Column ${i}`,
+        type: "text"
+      }));
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        availableColumns: largeColumns
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("error handling", () => {
+    (0, import_vitest.it)("should handle missing onFiltersChange callback", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        onFiltersChange: void 0
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle missing onAddFilter callback", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        onAddFilter: void 0
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle missing onRemoveFilter callback", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        onRemoveFilter: void 0
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle missing onClearFilters callback", () => {
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        onClearFilters: void 0
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("filter validation", () => {
+    (0, import_vitest.it)("should validate filter values based on column type", () => {
+      const invalidNumberFilter = {
+        id: "invalid",
+        columnId: "age",
+        value: {
+          operator: "is",
+          value: "not-a-number"
+        }
+      };
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: [invalidNumberFilter]
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should validate date filter values", () => {
+      const invalidDateFilter = {
+        id: "invalid-date",
+        columnId: "date",
+        value: {
+          operator: "is",
+          value: "not-a-date"
+        }
+      };
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: [invalidDateFilter]
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+    (0, import_vitest.it)("should validate select filter values", () => {
+      const invalidSelectFilter = {
+        id: "invalid-select",
+        columnId: "status",
+        value: {
+          operator: "is",
+          value: "invalid-option"
+        }
+      };
+      const {
+        container
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: [invalidSelectFilter]
+      }));
+      (0, import_vitest.expect)(container).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("state management", () => {
+    (0, import_vitest.it)("should update when filters prop changes", () => {
+      const {
+        rerender
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: []
+      }));
+      rerender(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        filters: sampleFilters
+      }));
+      (0, import_vitest.expect)(true).toBe(true);
+    });
+    (0, import_vitest.it)("should update when availableColumns prop changes", () => {
+      const {
+        rerender
+      } = (0, import_test_utils.renderWithProviders)(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps
+      }));
+      const newColumns = [...sampleColumns, {
+        id: "newColumn",
+        label: "New Column",
+        type: "text"
+      }];
+      rerender(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_index.DataTableFilters, {
+        ...defaultProps,
+        availableColumns: newColumns
+      }));
+      (0, import_vitest.expect)(true).toBe(true);
+    });
+  });
+});