@qrvey/filters 0.0.44 → 0.1.0

package/tests/classes/FilterResources.test.ts

@@ -1,267 +0,0 @@
-import { COLUMN, FORMULA, IDTimezone } from "@qrvey/utils";
-
-import { FilterResources } from "../../src/classes/FilterResources";
-import { IFilter } from "../../src/resources";
-import {
-  FILTER_GROUPING,
-  FILTER_GROUPING_INFO,
-  FILTER_GROUPING_INFO_BY_COLUMN_TYPE,
-  FILTER_GROUPING_INFO_BY_DATE_TIME,
-  FILTER_GROUPING_INFO_BY_DISTINCT_DATE,
-  FILTER_GROUPING_INFO_BY_DISTINCT_DATE_TIME,
-  FILTER_GROUPING_INFO_LIST,
-  FILTER_GROUPINGS,
-} from "../../src/resources/filter-grouping.resources";
-import {
-  FILTER_VALIDATOR,
-  FILTER_VALIDATOR_INFO,
-  FILTER_VALIDATOR_INFO_LIST,
-  FILTER_VALIDATORS,
-  FILTER_VALIDATORS_INFO_BY_COLUMN_TYPE,
-} from "../../src/resources/filter-validators.resources";
-import {
-  __mockFilter10,
-  __mockFilter11,
-  __mockFilter9,
-  __mockFilters4,
-} from "../mock/filters.mock";
-
-describe("Testing Filter Resources - Grouping", () => {
-  test("getGroupingInfo", () => {
-    expect(FilterResources.getGroupingInfo(FILTER_GROUPING.DAY)).toEqual(
-      FILTER_GROUPING_INFO.day,
-    );
-  });
-
-  test("getGroupingInfoListByColumnType - Undefined", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnType({ type: COLUMN.BUCKET }),
-    ).toBeUndefined();
-  });
-
-  test("getGroupingInfoListByColumnType - Expression", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnType({
-        type: COLUMN.EXPRESSION,
-      }),
-    ).toEqual([]);
-  });
-
-  test("getGroupingInfoListByColumnType - Date", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnType({
-        type: COLUMN.DATE_FORMULA,
-      }),
-    ).toEqual(FILTER_GROUPING_INFO_BY_COLUMN_TYPE.DATE_FORMULA);
-  });
-
-  test("getGroupingInfoListByColumnType - Formula Date", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnType({
-        type: COLUMN.FORMULA,
-        formulaType: FORMULA.DATE,
-      }),
-    ).toEqual(FILTER_GROUPING_INFO_BY_COLUMN_TYPE.DATE_FORMULA);
-  });
-
-  test("getGroupingInfoListByColumnType - Name", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnType({ type: COLUMN.NAME }),
-    ).toEqual(FILTER_GROUPING_INFO_BY_COLUMN_TYPE.NAME);
-  });
-
-  test("getGroupingInfoListByColumnTypes - Name, Address", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnTypes([
-        { type: COLUMN.NAME },
-        { type: COLUMN.ADDRESS },
-      ]),
-    ).toEqual([]);
-  });
-
-  test("getGroupingInfoListByColumnTypes - File Upload, Image upload", () => {
-    expect(
-      FilterResources.getGroupingInfoListByColumnTypes([
-        { type: COLUMN.FILEUPLOAD },
-        { type: COLUMN.IMAGEUPLOAD },
-      ]),
-    ).toEqual([FILTER_GROUPING_INFO.fileSize, FILTER_GROUPING_INFO.fileType]);
-  });
-
-  test("getGroupingInfoListOnDates - empty settings", () => {
-    expect(
-      FilterResources.getGroupingInfoListOnDates(
-        FILTER_GROUPING_INFO_BY_COLUMN_TYPE.DATE,
-        {},
-      ),
-    ).toEqual(FILTER_GROUPING_INFO_BY_COLUMN_TYPE.DATE);
-  });
-
-  test("getGroupingInfoListOnDates - additional settings", () => {
-    expect(
-      FilterResources.getGroupingInfoListOnDates(
-        FILTER_GROUPING_INFO_BY_COLUMN_TYPE.DATE,
-        {
-          hasDateTime: true,
-          hasDistinctDate: true,
-          hasDistinctDateTime: true,
-        },
-      ),
-    ).toEqual([
-      ...FILTER_GROUPING_INFO_BY_COLUMN_TYPE.DATE,
-      ...FILTER_GROUPING_INFO_BY_DATE_TIME,
-      ...FILTER_GROUPING_INFO_BY_DISTINCT_DATE,
-      ...FILTER_GROUPING_INFO_BY_DISTINCT_DATE_TIME,
-    ]);
-  });
-
-  test("getGroupingInfoListOnExpressions - empty settings", () => {
-    expect(
-      FilterResources.getGroupingInfoListOnExpressions(
-        FILTER_GROUPING_INFO_BY_COLUMN_TYPE.EXPRESSION,
-        {},
-      ),
-    ).toEqual([]);
-  });
-
-  test("getGroupingInfoListOnExpressions - additional settings", () => {
-    expect(
-      FilterResources.getGroupingInfoListOnExpressions(
-        FILTER_GROUPING_INFO_BY_COLUMN_TYPE.EXPRESSION,
-        {
-          isExpressionCategorizable: true,
-        },
-      ),
-    ).toEqual(FILTER_GROUPING_INFO_BY_COLUMN_TYPE.EXPRESSION);
-  });
-
-  test("getGroupingInfoListOnImageUploads - empty settings", () => {
-    expect(
-      FilterResources.getGroupingInfoListOnImageUploads(
-        FILTER_GROUPING_INFO_BY_COLUMN_TYPE.IMAGEUPLOAD,
-        {},
-      ),
-    ).toEqual([FILTER_GROUPING_INFO.fileSize, FILTER_GROUPING_INFO.fileType]);
-  });
-
-  test("getGroupingInfoListOnImageUploads - additional settings", () => {
-    expect(
-      FilterResources.getGroupingInfoListOnImageUploads(
-        FILTER_GROUPING_INFO_BY_COLUMN_TYPE.IMAGEUPLOAD,
-        {
-          hasImageUploadAnalysis: true,
-        },
-      ),
-    ).toEqual(FILTER_GROUPING_INFO_BY_COLUMN_TYPE.IMAGEUPLOAD);
-  });
-
-  test("getGroupings", () => {
-    expect(FilterResources.getGroupings()).toEqual(FILTER_GROUPINGS);
-  });
-
-  test("getGroupingsInfoList", () => {
-    expect(FilterResources.getGroupingsInfoList()).toEqual(
-      FILTER_GROUPING_INFO_LIST,
-    );
-  });
-});
-
-describe("Testing Filter Resources - Validator", () => {
-  test("getValidatorInfo", () => {
-    expect(FilterResources.getValidatorInfo(FILTER_VALIDATOR.EQUALS)).toEqual(
-      FILTER_VALIDATOR_INFO.EQUALS,
-    );
-  });
-
-  test("getValidatorInfoList", () => {
-    expect(FilterResources.getValidatorInfoList()).toEqual(
-      FILTER_VALIDATOR_INFO_LIST,
-    );
-  });
-
-  test("getValidatorInfoListByColumnType - Date", () => {
-    expect(
-      FilterResources.getValidatorInfoListByColumnType({ type: COLUMN.DATE }),
-    ).toEqual(FILTER_VALIDATORS_INFO_BY_COLUMN_TYPE.DATE);
-  });
-
-  test("getValidatorInfoListByColumnType - Formula Numeric", () => {
-    expect(
-      FilterResources.getValidatorInfoListByColumnType({
-        type: COLUMN.FORMULA,
-        formulaType: FORMULA.NUMBER,
-      }),
-    ).toEqual(FILTER_VALIDATORS_INFO_BY_COLUMN_TYPE.NUMERIC);
-  });
-
-  test("getValidatorInfoListByColumnTypes", () => {
-    expect(
-      FilterResources.getValidatorInfoListByColumnTypes([
-        { type: COLUMN.DATE },
-        { type: COLUMN.NUMERIC },
-      ]),
-    ).toEqual([
-      FILTER_VALIDATOR_INFO.EQUALS,
-      FILTER_VALIDATOR_INFO.NOT_EQUAL,
-      FILTER_VALIDATOR_INFO.BETWEEN_INCLUSIVE,
-      FILTER_VALIDATOR_INFO.BETWEEN_EXCLUSIVE,
-    ]);
-  });
-
-  test("getValidators", () => {
-    expect(FilterResources.getValidators()).toEqual(FILTER_VALIDATORS);
-  });
-});
-
-describe("Testing Filter Resources - Timezone", () => {
-  const timezone1: IDTimezone = { offset: "+00:00" };
-  const timezone2: IDTimezone = { offset: "-05:00" };
-
-  test("getFiltersByTimezone - Empty", () => {
-    const newFilters = FilterResources.getFiltersByTimezone([], timezone1);
-    expect(newFilters).toEqual([]);
-  });
-  test("getFiltersByTimezone - Filters", () => {
-    const newFilters = FilterResources.getFiltersByTimezone(
-      __mockFilters4,
-      timezone2,
-    );
-
-    const newMockFilter9: IFilter = {
-      ...__mockFilter9,
-      values: [
-        {
-          ...__mockFilter9.values![0],
-          anchor: "02/11/2024 19:00:00",
-        },
-      ],
-    };
-
-    const newMockFilter10: IFilter = {
-      ...__mockFilter10,
-      values: [
-        {
-          ...__mockFilter10.values![0],
-          value: "02/11/2024 19:00:00",
-        },
-      ],
-    };
-
-    const newMockFilter11: IFilter = {
-      ...__mockFilter11,
-      values: [
-        {
-          ...__mockFilter11.values![0],
-          min: "02/11/2024 19:00:00",
-          max: "02/12/2024 19:00:00",
-        },
-      ],
-    };
-
-    expect(newFilters).toEqual([
-      newMockFilter9,
-      newMockFilter10,
-      newMockFilter11,
-    ]);
-  });
-});

package/tests/classes/FilterSearcher.test.ts

@@ -1,188 +0,0 @@
-import { AGGREGATE, COLUMN } from "@qrvey/utils";
-
-import { FilterSearcher } from "../../src/classes/FilterSearcher";
-import {
-  __mockFilter1,
-  __mockFilter4,
-  __mockFilters1,
-} from "../mock/filters.mock";
-
-describe("Testing wrong arguments", () => {
-  test("Undefined argument", () => {
-    const searcher = new FilterSearcher(undefined);
-    expect(searcher.getFilters()).toEqual([]);
-  });
-
-  test("Null argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const searcher = new FilterSearcher(null);
-    expect(searcher.getFilters()).toEqual([]);
-  });
-
-  test("Boolean argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const searcher = new FilterSearcher(false);
-    expect(searcher.getFilters()).toEqual([]);
-  });
-
-  test("Numeric argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const searcher = new FilterSearcher(0);
-    expect(searcher.getFilters()).toEqual([]);
-  });
-
-  test("String argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const searcher = new FilterSearcher("Sales");
-    expect(searcher.getFilters()).toEqual([]);
-  });
-
-  test("Function-like argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const searcher = new FilterSearcher(() => "Hola");
-    expect(searcher.getFilters()).toEqual([]);
-  });
-});
-
-describe("Testing Filter Searcher - Empty Filters", () => {
-  let searcher: FilterSearcher;
-  beforeEach(() => {
-    searcher = new FilterSearcher([]);
-  });
-
-  test("Getting Empty Filters", () => {
-    expect(searcher.getFilters()).toEqual([]);
-  });
-
-  test("Filtering by Params", () => {
-    expect(searcher.filterByParams({ columnId: "123" })).toEqual([]);
-  });
-
-  test("Filtering Indexes by Params", () => {
-    expect(searcher.filterIndexesByParams({ columnId: "123" })).toEqual([]);
-  });
-
-  test("Finding by Params", () => {
-    expect(searcher.findByParams({ columnId: "123" })).toBeUndefined();
-  });
-
-  test("Finding Index by Params", () => {
-    expect(searcher.findIndexByParams({ columnId: "123" })).toBe(-1);
-  });
-
-  test("Excluding Index by Params", () => {
-    expect(searcher.excludeByParams({ columnId: "123" })).toEqual([]);
-  });
-});
-
-describe("Testing Filter Searcher - Setting Filters", () => {
-  let searcher: FilterSearcher;
-  beforeEach(() => {
-    searcher = new FilterSearcher([]);
-  });
-
-  test("Setting Filters", () => {
-    searcher.setFilters(__mockFilters1);
-    expect(searcher.getFilters()).toEqual(__mockFilters1);
-  });
-});
-
-describe("Testing Filter Searcher - With Filters", () => {
-  let searcher: FilterSearcher;
-  beforeEach(() => {
-    searcher = new FilterSearcher(__mockFilters1);
-  });
-
-  test("Filtering by Params - No results", () => {
-    expect(searcher.filterByParams({ columnId: "123" })).toEqual([]);
-  });
-
-  test("Filtering by Params - Results", () => {
-    expect(searcher.filterByParams({ columnId: "C123" })).toEqual([
-      __mockFilters1[0],
-    ]);
-  });
-
-  test("Filtering Indexes by Params - No results", () => {
-    expect(searcher.filterIndexesByParams({ datasetId: "123" })).toEqual([]);
-  });
-
-  test("Filtering Indexes by Params - No results", () => {
-    expect(searcher.filterIndexesByParams({ datasetId: "D123" })).toEqual([
-      0, 1,
-    ]);
-  });
-
-  test("Finding by Params - No results", () => {
-    expect(
-      searcher.findByParams({ columnType: COLUMN.YES_NO }),
-    ).toBeUndefined();
-  });
-
-  test("Finding by Params - Results", () => {
-    expect(searcher.findByParams({ columnType: COLUMN.DATE })).toEqual(
-      __mockFilters1[1],
-    );
-  });
-
-  test("Finding Index by Params - No results", () => {
-    expect(searcher.findIndexByParams({ aggregateType: AGGREGATE.SUM })).toBe(
-      -1,
-    );
-  });
-
-  test("Finding Index by Params - Results", () => {
-    expect(searcher.findIndexByParams({ aggregateType: undefined })).toBe(0);
-  });
-
-  test("Excluding Index by Params", () => {
-    expect(searcher.excludeByParams({ datasetId: "D123" })).toEqual([
-      __mockFilters1[2],
-    ]);
-  });
-
-  test("Finding the last Index by Filters", () => {
-    expect(searcher.findLastIndexByFilter(__mockFilter1)).toEqual({
-      index: 0,
-      nextToColumnFilter: true,
-      nextToDatasetFilter: false,
-      nextToScopeFilter: false,
-    });
-  });
-
-  test("Finding the last Index by Filters - With Custom Index", () => {
-    expect(searcher.findLastIndexByFilter(__mockFilter1, 1)).toEqual({
-      index: 1,
-      nextToColumnFilter: false,
-      nextToDatasetFilter: false,
-      nextToScopeFilter: false,
-    });
-  });
-
-  test("Finding the last Index by Filters - No Match", () => {
-    expect(searcher.findLastIndexByFilter(__mockFilter4)).toEqual({
-      index: -1,
-      nextToColumnFilter: false,
-      nextToDatasetFilter: false,
-      nextToScopeFilter: false,
-    });
-  });
-
-  test("Finding the last Index by Filters - Out of bounds 1", () => {
-    expect(searcher.findLastIndexByFilter(__mockFilter1, -2)).toEqual({
-      index: 0,
-      nextToColumnFilter: true,
-      nextToDatasetFilter: false,
-      nextToScopeFilter: false,
-    });
-  });
-
-  test("Finding the last Index by Filters - Out of bounds 2", () => {
-    expect(searcher.findLastIndexByFilter(__mockFilter1, 10)).toEqual({
-      index: 2,
-      nextToColumnFilter: false,
-      nextToDatasetFilter: false,
-      nextToScopeFilter: false,
-    });
-  });
-});

package/tests/classes/FilterValidation.test.ts

@@ -1,54 +0,0 @@
-import { FilterValidation } from "../../src/classes/FilterValidation";
-import {
-  __mockFilter2,
-  __mockFilter3,
-  __mockFilter4,
-  __mockFilter5,
-  __mockFilter7,
-  __mockFilter8,
-  __mockFilters1,
-  __mockFilters3,
-} from "../mock/filters.mock";
-
-describe("Testing Filter Duplications", () => {
-  test("Empty Params", () => {
-    // @ts-expect-error: Expected wrong params
-    expect(FilterValidation.isDuplicated()).toBeFalsy();
-  });
-
-  test("No Duplicated - Range", () => {
-    expect(
-      FilterValidation.isDuplicated(__mockFilters1, __mockFilter4),
-    ).toBeFalsy();
-  });
-
-  test("Duplicated - Range", () => {
-    expect(
-      FilterValidation.isDuplicated(__mockFilters1, __mockFilter3),
-    ).toBeTruthy();
-  });
-
-  test("No Duplicated - Regular", () => {
-    expect(
-      FilterValidation.isDuplicated(__mockFilters1, __mockFilter5),
-    ).toBeFalsy();
-  });
-
-  test("Duplicated - Regular", () => {
-    expect(
-      FilterValidation.isDuplicated(__mockFilters1, __mockFilter2),
-    ).toBeTruthy();
-  });
-
-  test("No Duplicated - Relative", () => {
-    expect(
-      FilterValidation.isDuplicated(__mockFilters3, __mockFilter8),
-    ).toBeFalsy();
-  });
-
-  test("Duplicated - Relative", () => {
-    expect(
-      FilterValidation.isDuplicated(__mockFilters3, __mockFilter7),
-    ).toBeTruthy();
-  });
-});

package/tests/helpers/getFilterId.test.ts

@@ -1,121 +0,0 @@
-import { getFilterId } from "../../src/helpers/getFilterId";
-import { FILTER_GROUPING } from "../../src/resources/filter-grouping.resources";
-import { FILTER_OPERATOR } from "../../src/resources/filter-operators.resources";
-import { FILTER_SCOPE } from "../../src/resources/filter-scopes.resources";
-import { FILTER_VALIDATOR } from "../../src/resources/filter-validators.resources";
-import { IFilter } from "../../src/resources/filters.resources";
-
-describe("Undefined/empty arguments", () => {
-  test("Undefined argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId();
-    expect(result).toBe("");
-  });
-
-  test("Undefined argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId(undefined);
-    expect(result).toBe("");
-  });
-
-  test("Null argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId(null);
-    expect(result).toBe("");
-  });
-
-  test("Empty array argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId([]);
-    expect(result).toBe("");
-  });
-});
-
-describe("Different argument type", () => {
-  test("Boolean argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId(false);
-    expect(result).toBe("");
-  });
-
-  test("Numeric argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId(0);
-    expect(result).toBe("");
-  });
-
-  test("String argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId("Sales");
-    expect(result).toBe("");
-  });
-
-  test("Function-like argument", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId(() => "Hola");
-    expect(result).toBe("");
-  });
-});
-
-describe("Wrong Object type", () => {
-  test("Date Object", () => {
-    const param1 = new Date();
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId(param1);
-    expect(result).toBe("");
-  });
-
-  test("Empty but valid object", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId({});
-    expect(result).toBe("");
-  });
-
-  test("Non-empty but valid object", () => {
-    // @ts-expect-error: Expected wrong params
-    const result = getFilterId({ Hello: "world" });
-    expect(result).toBe("");
-  });
-});
-
-describe("Correct Object type", () => {
-  const filter: IFilter = {
-    collapsed: false,
-    // @ts-expect-error: No need the type
-    columnType: "TEXT_LABEL",
-    deletable: true,
-    displayed: true,
-    editable: true,
-    enableable: true,
-    enabled: true,
-    id: "F123",
-    operator: FILTER_OPERATOR.AND,
-    scope: FILTER_SCOPE.GLOBAL,
-    scopeId: "S123",
-    datasetId: "D123",
-    columnId: "C123",
-    validator: FILTER_VALIDATOR.EQUALS,
-  };
-
-  const filter2: IFilter = {
-    ...filter,
-    // @ts-expect-error: No need the type
-    aggregateType: "SUM",
-    grouping: FILTER_GROUPING.DAY,
-  };
-
-  test("Filter 1", () => {
-    const result = getFilterId(filter);
-    expect(result).toBe("global|S123|D123|C123|equals");
-  });
-
-  test("Filter with Grouping and Aggregate", () => {
-    const result = getFilterId(filter2);
-    expect(result).toBe("global|S123|D123|C123|equals|day|sum");
-  });
-
-  test("With index", () => {
-    const result = getFilterId(filter2, 4);
-    expect(result).toBe("global|S123|D123|C123|equals|day|sum|4");
-  });
-});

package/tests/mock/datasets.mock.ts

@@ -1,61 +0,0 @@
-import { COLUMN, FORMULA, IDataset } from "@qrvey/utils";
-
-export const __dataset1: IDataset = {
-  qrveyid: "D123",
-  label: "Dataset 123",
-  options: [
-    {
-      id: "C123",
-      label: "Column 123",
-      qrveyid: "D123",
-      type: COLUMN.TEXT_LABEL,
-    },
-    {
-      id: "C456",
-      label: "Column 456",
-      qrveyid: "D123",
-      type: COLUMN.DATE,
-    },
-    {
-      id: "C789",
-      label: "Column 789",
-      qrveyid: "D123",
-      type: COLUMN.DATE,
-    },
-  ],
-};
-
-export const __dataset2: IDataset = {
-  qrveyid: "D456",
-  label: "Dataset 456",
-  options: [
-    {
-      id: "C987",
-      label: "Column 987",
-      qrveyid: "D456",
-      type: COLUMN.NUMERIC,
-    },
-    {
-      id: "C654",
-      label: "Column 654",
-      qrveyid: "D456",
-      type: COLUMN.FORMULA,
-      formulaType: FORMULA.NUMBER,
-    },
-  ],
-};
-
-export const __dataset3: IDataset = {
-  qrveyid: "D789",
-  label: "Dataset 789",
-  options: [
-    {
-      id: "C135",
-      label: "Column 135",
-      qrveyid: "D789",
-      type: COLUMN.BUCKET,
-    },
-  ],
-};
-
-export const __datasets1: IDataset[] = [__dataset1, __dataset2, __dataset3];