@qrvey/utils 1.3.0-0 → 1.3.0-11

package/src/dates/adapters/index.ts

@@ -0,0 +1,11 @@
+export * from './dateToHms';
+export * from './dateToMdyDate';
+export * from './dateToMonthYear';
+export * from './dateToQuarterYear';
+export * from './dateToWeekYear';
+export * from './dateToYear';
+export * from './mdyDateToDate';
+export * from './monthYearToDate';
+export * from './quarterYearToDate';
+export * from './weekYearToDate';
+export * from './yearToDate';

package/src/dates/adapters/mdyDateToDate.ts

@@ -9,7 +9,7 @@ import { validateDate } from "../helpers/validateDate";
  * @param time Flag to parse the object date to milliseconds.
  * @returns The date object or the date in milliseconds
  */
-export function mdyDateToDate (date: string, time = false) {
+export function mdyDateToDate (date: string, time = false): string | Date | number {
     if (isEmpty(date) || isTokenLabel(date)) return date;
    
     if (validateDate(date, DATE_FORMAT.DAY)) {

package/src/dates/adapters/monthYearToDate.ts

@@ -10,7 +10,7 @@ import { validateDate } from "../helpers/validateDate";
  * @param time Flag to parse the object date to milliseconds.
  * @returns The date object or the date in milliseconds
  */
-export function monthYearToDate(monthYearDate: string, time = false) {
+export function monthYearToDate(monthYearDate: string, time = false): string | Date | number {
     if (isEmpty(monthYearDate) || isTokenLabel(monthYearDate)) return monthYearDate;
 
     if (validateDate(monthYearDate, DATE_FORMAT.MONTH)) {

package/src/dates/adapters/quarterYearToDate.ts

@@ -10,7 +10,7 @@ import { validateDate } from "../helpers/validateDate";
  * @param time Flag to parse the object date to milliseconds.
  * @returns The date object or the date in milliseconds
  */
-export function quarterYearToDate (quarterYearDate: string, time = false) {
+export function quarterYearToDate (quarterYearDate: string, time = false): string | Date | number {
     if (isEmpty(quarterYearDate) || isTokenLabel(quarterYearDate)) return quarterYearDate;
     
     if (validateDate(quarterYearDate, DATE_FORMAT.QUARTER)) {

package/src/dates/adapters/weekYearToDate.ts

@@ -10,7 +10,7 @@ import { validateDate } from "../helpers/validateDate";
  * @param time Flag to parse the object date to milliseconds.
  * @returns The date object or the date in milliseconds
  */
- export function weekYearToDate(weekYear: string, time = false) {
+ export function weekYearToDate(weekYear: string, time = false): string | Date | number {
     if (isEmpty(weekYear) || isTokenLabel(weekYear)) return weekYear;
 
     if (validateDate(weekYear, DATE_FORMAT.WEEK)) {

package/src/dates/adapters/yearToDate.ts

@@ -10,7 +10,7 @@ import { validateDate } from "../helpers/validateDate";
  * @param time Flag to parse the object date to milliseconds.
  * @returns The date object or the date in milliseconds
  */
-export function yearToDate(yearDate: string, time = false) {
+export function yearToDate(yearDate: string, time = false): string | Date | number {
     if (isEmpty(yearDate) || isTokenLabel(yearDate)) return yearDate;
 
     if (validateDate(yearDate, DATE_FORMAT.YEAR)) {

package/src/dates/helpers/getDateByDateFormat.ts

@@ -13,7 +13,7 @@ import { mdyDateToDate } from "../adapters/mdyDateToDate";
  * @param time flag to convert the formatted date to miliseconds
  * @returns a Date object, milisecond time or the same value if date format does not match.
  */
-export function getDateByDateFormat(date: string, format: IDateFormat, time = false) {
+export function getDateByDateFormat(date: string, format: IDateFormat, time = false): string | Date | number {
     switch (format) {
         case DATE_FORMAT.YEAR:
             return yearToDate(date, time);

package/src/dates/helpers/getDatePickerPickLevel.ts

@@ -0,0 +1,12 @@
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+
+/**
+ * Gets the pick level number related to the Date picker element
+ * @param {IDateFormat} format The date format
+ * @returns {number} A number of the pick level setting
+ */
+export function getDatePickerPickLevel(format: IDateFormat): 0 | 1 | 2 {
+    return format === DATE_FORMAT.YEAR ? 2 :
+      format === DATE_FORMAT.MONTH ? 1 : 0;
+}

package/src/dates/helpers/getFormattedDateByFormat.ts

@@ -0,0 +1,29 @@
+import { dateToMdyDate } from "../adapters/dateToMdyDate";
+import { dateToMonthYear } from "../adapters/dateToMonthYear";
+import { dateToQuarterYear } from "../adapters/dateToQuarterYear";
+import { dateToWeekYear } from "../adapters/dateToWeekYear";
+import { dateToYear } from "../adapters/dateToYear";
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+
+/**
+ * A Date object, string or millisecond number are gotten in order to convert it in an formatted string date
+ * @param date String with a formatted date
+ * @param format The date format
+ * @returns a formmatted date or the same value if format does not match
+ */
+ export function getFormattedDateByFormat(date: string | Date | number, format: IDateFormat): string | Date | number {
+    if (format === DATE_FORMAT.QUARTER) {
+      return dateToQuarterYear(date);
+    } else if (format === DATE_FORMAT.MONTH) {
+      return dateToMonthYear(date);
+    } else if (format === DATE_FORMAT.YEAR) {
+      return dateToYear(date);
+    } else if (format === DATE_FORMAT.WEEK) {
+      return dateToWeekYear(date);
+    } else if (format === DATE_FORMAT.DAY) {
+      return dateToMdyDate(date);
+    } else {
+      return date;
+    }
+}

package/src/dates/helpers/includeDateTokens.ts

@@ -0,0 +1,26 @@
+import { isEmpty } from "../../general/mix/isEmpty";
+import { isTokenLabel } from "../../tokens/isTokenLabel";
+import { IDateFormat } from "../interfaces/IDateFormat";
+import { getSeparatorByDateFormat } from "./getSeparatorByDateFormat";
+
+/**
+ * Determines if the given date has tokens. The date is splitted depending on date format.
+ * Undefined date is returning false.
+ * @param date The string of the date. It may contain tokens.
+ * @param format The date format
+ * @returns true: include tokens; false: otherwise
+ */
+export function includeDateTokens(date: string, format: IDateFormat) {
+    let hasTokens = false;
+    if (!isEmpty(date)) {
+        if (isTokenLabel(date)) hasTokens = true;
+        else {
+            const separator = getSeparatorByDateFormat(format);
+            if (separator != null) {
+                const tokens = date.split(separator);
+                hasTokens = tokens.some(token => isTokenLabel(token));
+            }
+        }
+    }
+    return hasTokens;
+}

package/src/dates/helpers/index.ts

@@ -1,6 +1,10 @@
+export * from './getDateByDateFormat';
 export * from './getDateFormatByProperty';
 export * from './getDateFormatRegularExpressionInArray';
+export * from './getDatePickerPickLevel';
+export * from './getFormattedDateByFormat';
 export * from './getSeparatorByDateFormat';
+export * from './includeDateTokens';
 export * from './getWeek';
 export * from './validateDate';
 export * from './validateDateByDateFormat';

package/src/dates/index.ts

@@ -3,3 +3,4 @@ export * from './helpers/index';
 export * from './interfaces/index';
 export * from './range/index';
 export * from './relative/index';
+export * from './adapters/index';

package/src/filters/helpers/common/getFiltersByDatasetsColumns.ts

@@ -0,0 +1,35 @@
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { IDataset } from "../../../qrvey/interfaces/IDataset";
+import { IFUData } from "../../interfaces/ui/IFUData";
+
+/**
+ * Filtering the filters by the columns of datasets.
+ * Module specially for CLS.
+ * @param data the filter data
+ * @param datasets the collection of datasets and their columns
+ * @returns A new filter data with the filtered filters by columns
+ */
+export function getFiltersByDatasetsColumns(data: IFUData, datasets: IDataset[] = []): IFUData {
+    if (isEmpty(data) || isEmpty(data.scopes)) return;
+
+    return {
+        ...data,
+        scopes: data.scopes.map(scope => ({
+            ...scope,
+            datasets: scope.datasets.map(filterDataset => {
+                const dataset = datasets.find(data => data.qrveyid === filterDataset.qrveyid);
+                if (!isEmpty(dataset)) {
+                    return {
+                        ...filterDataset,
+                        filters: filterDataset.filters.map(filter => {
+                            const column = (dataset.options || []).find(cInfo => cInfo.id === filter.column.id && cInfo.qrveyid === filter.column.qrveyid);
+                            if (!isEmpty(column)) {
+                                return { ...filter };
+                            }
+                        }).filter(Boolean)
+                    };
+                }
+            }).filter(dataset => !isEmpty(dataset) && dataset.filters.length > 0)
+        })).filter(scope => !isEmpty(scope) && scope.datasets.length > 0)
+    };
+}

package/src/filters/helpers/common/index.ts

@@ -7,6 +7,7 @@ export * from './getFilterColumnLabel';
 export * from './getFilterid';
 export * from './getFilterLabel';
 export * from './getFiltersByAggregateColumn';
+export * from './getFiltersByDatasetsColumns';
 export * from './getFiltersByParams';
 export * from './getFiltersByScopes';
 export * from './getFiltersByScopesIds';

package/src/filters/helpers/common/resolveFilterConditions.ts

@@ -17,8 +17,8 @@ export function resolveFilterConditions(filter: IFSFilter, params: IFSParamsToGe
     (!_hasProperty(params, 'panelid') || (letPassUndefinedProperties && filter.extras.panelid == null) || (letPassUndefinedParams && isEmpty(params.panelid)) || params.panelid === filter.extras.panelid) &&
     (!_hasProperty(params, 'property') || (letPassUndefinedProperties && filter.property == null) || (letPassUndefinedParams && isEmpty(params.property)) || params.property === filter.property) &&
     (!_hasProperty(params, 'validator') || (letPassUndefinedProperties && filter.validator == null) || (letPassUndefinedParams && isEmpty(params.validator)) || params.validator === filter.validator) &&
-    (!_hasProperty(params, 'column') || (letPassUndefinedProperties && filter.column == null) || (letPassUndefinedParams && isEmpty(params.column)) || (params.column?.id === filter.column.id &&
-        params.column?.qrveyid === filter.column.qrveyid &&
-        params.column?.linkid === filter.column.linkid &&
-        params.column?.aggregate === filter.column.aggregate));
+    (!_hasProperty(params, 'column') || (letPassUndefinedProperties && filter.column == null) || (letPassUndefinedParams && isEmpty(params.column)) || ((letPassUndefinedParams && isEmpty(params.column?.id) || params.column?.id === filter.column.id) &&
+        (letPassUndefinedParams && isEmpty(params.column?.qrveyid) || params.column?.qrveyid === filter.column.qrveyid) &&
+        (letPassUndefinedParams && isEmpty(params.column?.linkid) || params.column?.linkid === filter.column.linkid) &&
+        (letPassUndefinedParams && isEmpty(params.column?.aggregate) || params.column?.aggregate === filter.column.aggregate)));
 }

package/src/filters/interfaces/common/IFSParamsToGetFilter.ts

@@ -9,7 +9,7 @@ import { IFSParamsToGetFilterEnableds } from "./IFSParamsToGetFilterEnableds";
  * Structure for filter properties
  */
 export interface IFSParamsToGetFilter {
-    column?: IFSColumn;
+    column?: Partial<IFSColumn>;
     dateSection?: IFDateSection;
     enableds?: IFSParamsToGetFilterEnableds;
     linkid?: string;
@@ -19,4 +19,4 @@ export interface IFSParamsToGetFilter {
     scope?: IFScope;
     scopeid?: string;
     validator?: IFValidator;
-}
+}

package/src/general/array/addPropertyToArrayOfObjects.ts

@@ -0,0 +1,32 @@
+import { isEmpty } from '../mix/isEmpty';
+import { isObject } from '../object/isObject';
+
+/**
+ * It takes an array of objects, adds a property to each object, and returns the new array.
+ * @param {Object} info - Information needed to add property to the array of objects.
+ * @param {Array} info.array - The array of objects you want to add a property to.
+ * @param {string} info.property - The property you want to add to the object.
+ * @param {any} info.value - - The value to be added to the array of objects.
+ * ----------------------------------------------------------------------------------------------
+ * @example <caption>Example usage of addPropertyToArrayOfObjects.</caption>
+ * addPropertyToArrayOfObjects({
+ * 	array: [{ name: "John", lastName: "Doe" }, { name: "Chris", lastName: "Musk" }],
+ * 	property: "lastName",
+ * 	value: 'Peck'
+ * });
+ * @returns the new array created.
+ */
+export function addPropertyToArrayOfObjects(obj: AddPropertyToArrayOfObjectsParams): any[] {
+	if (isEmpty(obj) || !isObject(obj)) return [];
+	const { array, property, value } = obj;
+	if (Array.isArray(array)) {
+		if (isEmpty(array) || isEmpty(property)) return array;
+		return array.map((element) => ({ ...element, [property]: value }));
+	}
+	return [];
+}
+type AddPropertyToArrayOfObjectsParams = {
+	array: any[];
+	property: string;
+	value: any;
+};

package/src/general/array/index.ts

@@ -1,3 +1,4 @@
+export * from './addPropertyToArrayOfObjects';
 export * from './delete';
 export * from './flattenDeep';
 export * from './filterNestedTree';

package/src/general/string/index.ts

@@ -1 +1,3 @@
-export * from './capitalize';
+export * from './capitalize';
+export * from './padLeadingZeros';
+export * from './parseUrl';

package/src/general/string/padLeadingZeros.ts

@@ -0,0 +1,7 @@
+export function padLeadingZeros(num: number | string, size = 0): string {
+    if (isNaN(Number(num))) return String(num);
+  
+    let s = num + "";
+    while (s.length < size) s = "0" + s;
+    return s;
+}

package/src/globalization/interfaces/style_themes/II18nStyleThemesTheme.ts

@@ -18,6 +18,7 @@ export interface II18nStyleThemesTheme {
     qrvey_theme: string;
     restore_to_default: string;
     save_theme: string;
+    show_header: string;
     show_title: string;
     table_header_styles: string;
     text_styles: string;

package/src/globalization/labels/chart_builder/I18N_CHART_BUILDER_STYLE_OPTIONS.ts

@@ -191,9 +191,9 @@ export const I18N_CHART_BUILDER_STYLE_OPTIONS: Pick<II18nChartBuilder, StyleOpti
         align: 'Align',
         align_all_columns: 'All Columns',
         align_default: 'Default',
-        align_left: 'Align Left',
-        align_right: 'Align Right',
-        align_center: 'Align Center',
+        align_left: 'Left',
+        align_right: 'Right',
+        align_center: 'Center',
         typeface: 'Typeface', 
         weight: 'Weight',
         weight_bold: 'Bold',

package/src/globalization/labels/style_themes/I18N_STYLE_THEMES.ts

@@ -42,6 +42,7 @@ export const I18N_STYLE_THEMES: II18nStyleThemes = {
       qrvey_theme: 'Qrvey Theme',
       restore_to_default: 'Restore to Default',
       save_theme: 'Save Theme',
+      show_header: 'Show Header',
       show_title: 'Show Title',
       table_header_styles: 'Table Header Styles',
       text_styles: 'Text Styles',

package/src/globalization/service/i18nextBuilder.ts

@@ -35,7 +35,17 @@ export class I18nServiceBuilder {
   }
 }
 
+/**
+ * This class allows to use the translation service of the i18next library
+ */
 export abstract class I18nService {
+
+  /**
+    * This method by means of the key searches in the configuration object, replaces the values received by means of the options parameter and returns the translated text. Ex: <b>translate('the_value_is {{number}}',{number: 1});</b>
+    * @param key String used as key
+    * @param options Object of type II18nServiceTranslateOption that contains the dynamic parameters to replace
+    * @returns The translated text Ex: <b>The value is: 1</b>
+    */
   abstract translate(key: string, options?: II18nServiceTranslateOption): string;
 }
 

package/src/index.ts

@@ -13,3 +13,4 @@ export * from './stencil/index';
 export * from './services/index';
 export * from './typescript/index';
 export * from './tokens/index';
+export * from './column_format/index';

package/src/interfaces/format/IFormatDefaultFormat.ts

@@ -0,0 +1,5 @@
+export interface IFormatDefaultFormat {
+    format: string;
+    type: string;
+    decimals?: number;
+}

package/src/interfaces/format/IFormatOutputFormat.Interface.ts

@@ -1,10 +1,8 @@
 import { IFormatCurrency } from "./IFormatCurrency.Interface";
+import { IFormatDefaultFormat } from "./IFormatDefaultFormat";
 
-export interface IFormatOutputFormat {
-    format: string;
-    type: string;
-    decimals?: number;
+export interface IFormatOutputFormat extends IFormatDefaultFormat {
     currency?: IFormatCurrency;
     backup_currency?: IFormatCurrency;
-    originalFormat?: any;
+    originalFormat?: IFormatOutputFormat;
 }

package/test/general/array/addPropertyToArrayOfObjects.test.js

@@ -0,0 +1,96 @@
+const { addPropertyToArrayOfObjects } = require('../../../dist/cjs');
+
+describe('Testing undefined argument', function () {
+	test('no argument passed', function () {
+		const validation = addPropertyToArrayOfObjects();
+		expect(validation).toEqual([]);
+	});
+
+	test('Undefined argument', function () {
+		const validation = addPropertyToArrayOfObjects(undefined);
+		expect(validation).toEqual([]);
+	});
+
+	test('Null argument', function () {
+		const validation = addPropertyToArrayOfObjects(null);
+		expect(validation).toEqual([]);
+	});
+});
+
+describe('Testing no-object argument', function () {
+	const scenarios1 = 1;
+	const scenarios2 = false;
+	const scenarios4 = 'Hello World';
+	const scenarios5 = ['Hello', 'World'];
+
+	test('Numeric variable', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios1);
+		expect(validation).toEqual([]);
+	});
+
+	test('Boolean variable', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios2);
+		expect(validation).toEqual([]);
+	});
+
+	test('String variable', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios4);
+		expect(validation).toEqual([]);
+	});
+
+	test('Array variable', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios5);
+		expect(validation).toEqual([]);
+	});
+});
+
+describe('Testing invalid object arguments', function () {
+	const scenarios1 = { array: undefined, property: 'lastName', value: 'Doe' };
+	const scenarios2 = { array: [{ name: 'Lebron', lastName: 'James' }], property: undefined, value: 'Doe' };
+
+	test('Empty Array', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios1);
+		expect(validation).toEqual([]);
+	});
+
+	test('Empty Property', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios2);
+		expect(validation).toEqual(scenarios2.array);
+	});
+});
+
+describe('Regular scenarios', function () {
+	const commonArray = [
+		{ name: 'John', lastName: 'Doe' },
+		{ name: 'Chris', lastName: 'Musk' },
+	];
+
+	const scenarios1 = { array: commonArray, property: 'name', value: 'Daniel' };
+	const scenarios2 = { array: commonArray, property: 'nationality', value: 'Colombian' };
+	const scenarios3 = { array: [{ name: 'Lebron', lastName: 'James' }], property: 'lastName', value: undefined };
+
+	const expectedScenario1 = [
+		{ name: 'Daniel', lastName: 'Doe' },
+		{ name: 'Daniel', lastName: 'Musk' },
+	];
+	const expectedScenario2 = [
+		{ name: 'John', lastName: 'Doe', nationality: 'Colombian' },
+		{ name: 'Chris', lastName: 'Musk', nationality: 'Colombian' },
+	];
+	const expectedScenario3 = [{ name: 'Lebron', lastName: undefined }];
+
+	test('Scenario #1', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios1);
+		expect(validation).toEqual(expectedScenario1);
+	});
+
+	test('Scenario #2', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios2);
+		expect(validation).toEqual(expectedScenario2);
+	});
+
+	test('Scenario #3', function () {
+		const validation = addPropertyToArrayOfObjects(scenarios3);
+		expect(validation).toEqual(expectedScenario3);
+	});
+});

package/test/tokens/isTokenLabel.test.js

@@ -1,3 +1,133 @@
+// import { isTokenLabel } from '../../src/tokens/isTokenLabel';
+
+// describe('Testing undefined argument', function () {
+//     test('no argument passed', function () {
+//         const validation: boolean = isTokenLabel();
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Undefined argument', function () {
+//         const validation: boolean = isTokenLabel(undefined);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Null argument', function () {
+//         const validation: boolean = isTokenLabel(null);
+//         expect(validation).toBeFalsy();
+//     });
+// });
+
+// describe('Testing no-string arguments', function () {
+//     const variable1: any = 1;
+//     const variable2: any = false;
+//     const variable3: any = new Date();
+//     const variable4: any = { const1: 'Hello', const2: 'World'};
+//     const variable5: any = ['Hello', 'World'];
+
+//     test('Numeric variable', function () {
+//         const validation: boolean = isTokenLabel(variable1);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Boolean variable', function () {
+//         const validation: boolean = isTokenLabel(variable2);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Date object variable', function () {
+//         const validation: boolean = isTokenLabel(variable3);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Object variable', function () {
+//         const validation: boolean = isTokenLabel(variable4);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Array variable', function () {
+//         const validation: boolean = isTokenLabel(variable5);
+//         expect(validation).toBeFalsy();
+//     });
+// });
+
+// describe('Testing invalid string argument', function () {
+//     const variable1: string = '';
+//     const variable2: string = 'Hello World';
+//     const variable3: string = '{}';
+//     const variable4: string = '{{}}';
+//     const variable5: string = '{{ }}';
+//     const variable6: string = '{{ Hello }}';
+//     const variable7: string = '{{Hello}';
+//     const variable8: string = '{{Hello}}{{World}}';
+//     const variable9: string = '{Hello}';
+    
+//     test('Empty string', function () {
+//         const validation: boolean = isTokenLabel(variable1);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Non-empty and regular string', function () {
+//         const validation: boolean = isTokenLabel(variable2);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Single curly brackets and empty label', function () {
+//         const validation: boolean = isTokenLabel(variable3);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Double curly brackets and empty label', function () {
+//         const validation: boolean = isTokenLabel(variable4);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Double curly brackets and space between them', function () {
+//         const validation: boolean = isTokenLabel(variable5);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Double curly brackets and non-empty label with space between them', function () {
+//         const validation: boolean = isTokenLabel(variable6);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Double left and single right curly brackets and non-empty label', function () {
+//         const validation: boolean = isTokenLabel(variable7);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Two data tokens in a single string', function () {
+//         const validation: boolean = isTokenLabel(variable8);
+//         expect(validation).toBeFalsy();
+//     });
+
+//     test('Single curly brackets and non-empty label', function () {
+//         const validation: boolean = isTokenLabel(variable9);
+//         expect(validation).toBeFalsy();
+//     });
+// });
+
+// describe('Regular scenarios', function () {
+//     const variable1: string = '{{NOW}}';
+//     const variable2: string = '{{LAST_YEAR_END}}';
+//     const variable3: string = '{{data.marathonparatooltips-cambiodesorting.FECHA.avg}}';
+    
+//     test('Scenario #1', function () {
+//         const validation: boolean = isTokenLabel(variable1);
+//         expect(validation).toBeTruthy();
+//     });
+
+//     test('Scenario #2', function () {
+//         const validation: boolean = isTokenLabel(variable2);
+//         expect(validation).toBeTruthy();
+//     });
+
+//     test('Scenario #3', function () {
+//         const validation: boolean = isTokenLabel(variable3);
+//         expect(validation).toBeTruthy();
+//     });
+// });
+
 const { isTokenLabel } = require("../../dist/cjs");
 
 describe('Testing undefined argument', function () {

package/tsconfig.doc.json

@@ -0,0 +1,4 @@
+{
+  "include": ["src/**/*.ts"],
+  "exclude": ["test/*.test.ts", "test/**/*.test.js"]
+}

package/tsconfig.json

@@ -62,5 +62,5 @@
 
     /* Advanced Options */
     "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
-  },
+  }
 }