@sports-alliance/sports-lib 6.0.4 → 6.1.1

package/lib/esm/stats/stats.class.abstract.d.ts

@@ -0,0 +1,15 @@
+import { StatsClassInterface } from './stats.class.interface';
+import { IDClass } from '../id/id.abstract.class';
+import { DataDistance } from '../data/data.distance';
+import { DataInterface } from '../data/data.interface';
+export declare abstract class StatsClassAbstract extends IDClass implements StatsClassInterface {
+    stats: Map<string, DataInterface>;
+    getDistance(): DataDistance;
+    getStat(statType: string): DataInterface | void;
+    getStats(): Map<string, DataInterface>;
+    getStatsAsArray(): DataInterface[];
+    removeStat(statType: string): void;
+    clearStats(): void;
+    setDistance(distance: DataDistance): void;
+    addStat(stat: DataInterface): void;
+}

package/lib/esm/stats/stats.class.abstract.js

@@ -0,0 +1,32 @@
+import { IDClass } from '../id/id.abstract.class';
+import { DataDistance } from '../data/data.distance';
+export class StatsClassAbstract extends IDClass {
+    constructor() {
+        super(...arguments);
+        this.stats = new Map(); // this could just be an array
+    }
+    getDistance() {
+        return this.stats.get(DataDistance.type);
+    }
+    getStat(statType) {
+        return this.stats.get(statType);
+    }
+    getStats() {
+        return this.stats;
+    }
+    getStatsAsArray() {
+        return Array.from(this.stats.values());
+    }
+    removeStat(statType) {
+        this.stats.delete(statType);
+    }
+    clearStats() {
+        this.stats.clear();
+    }
+    setDistance(distance) {
+        this.stats.set(DataDistance.type, distance);
+    }
+    addStat(stat) {
+        this.stats.set(stat.getType(), stat);
+    }
+}

package/lib/esm/stats/stats.class.interface.d.ts

@@ -0,0 +1,12 @@
+import { DataDistance } from '../data/data.distance';
+import { DataInterface } from '../data/data.interface';
+export interface StatsClassInterface {
+    getDistance(): DataDistance;
+    getStat(statType: string): DataInterface | void;
+    getStats(): Map<string, DataInterface>;
+    getStatsAsArray(): DataInterface[];
+    removeStat(statType: string): void;
+    clearStats(): void;
+    setDistance(distance: DataDistance): void;
+    addStat(stat: DataInterface): void;
+}

package/lib/esm/stats/stats.class.interface.js

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

package/lib/esm/stats/stats.json.interface.js

@@ -0,0 +1 @@
+"use strict";

package/lib/esm/streams/compressed.stream.interface.d.ts

@@ -0,0 +1,17 @@
+import { StreamJSONInterface } from './stream';
+export interface CompressedJSONStreamInterface extends StreamJSONInterface {
+    type: string;
+    data: any;
+    compressionMethod: CompressionMethods;
+    encoding: CompressionEncodings;
+}
+export declare enum CompressionEncodings {
+    None = "None",
+    Binary = "Binary",
+    base64 = "base64",
+    UInt8Array = "UInt8Array"
+}
+export declare enum CompressionMethods {
+    None = "None",
+    Pako = "Pako"
+}

package/lib/esm/streams/compressed.stream.interface.js

@@ -0,0 +1,12 @@
+export var CompressionEncodings;
+(function (CompressionEncodings) {
+    CompressionEncodings["None"] = "None";
+    CompressionEncodings["Binary"] = "Binary";
+    CompressionEncodings["base64"] = "base64";
+    CompressionEncodings["UInt8Array"] = "UInt8Array";
+})(CompressionEncodings || (CompressionEncodings = {}));
+export var CompressionMethods;
+(function (CompressionMethods) {
+    CompressionMethods["None"] = "None";
+    CompressionMethods["Pako"] = "Pako";
+})(CompressionMethods || (CompressionMethods = {}));

package/lib/esm/streams/ibi-stream.d.ts

@@ -0,0 +1,7 @@
+import { Stream } from './stream';
+import { StreamDataItem } from './stream.interface';
+export declare class IBIStream extends Stream {
+    constructor(data?: number[]);
+    getStreamDataByTime(startDate: Date, filterNull?: boolean): StreamDataItem[];
+    getStreamDataByDuration(offset?: number, filterNull?: boolean): StreamDataItem[];
+}

package/lib/esm/streams/ibi-stream.js

@@ -0,0 +1,43 @@
+import { Stream } from './stream';
+export class IBIStream extends Stream {
+    constructor(data) {
+        super('IBI');
+        if (data) {
+            this.data = data;
+        }
+    }
+    getStreamDataByTime(startDate, filterNull = false) {
+        let time = 0;
+        return this.data.reduce((accu, dataItem, index) => {
+            time += dataItem;
+            if (filterNull && dataItem === null) {
+                return accu;
+            }
+            accu.push({
+                time: startDate.getTime() + time,
+                value: dataItem
+            });
+            return accu;
+        }, []);
+    }
+    //
+    getStreamDataByDuration(offset, filterNull = false) {
+        // let data = (new IBIData(<number[]>this.data))
+        //   .lowLimitBPMFilter()
+        //   .lowPassFilter()
+        //   .highLimitBPMFilter().getAsArray();
+        const data = this.data;
+        let time = offset || 0;
+        return data.reduce((accu, dataItem, index) => {
+            time += dataItem;
+            if (filterNull && dataItem === null) {
+                return accu;
+            }
+            accu.push({
+                time: time,
+                value: dataItem
+            });
+            return accu;
+        }, []);
+    }
+}

package/lib/esm/streams/low-pass.stream.filter.d.ts

@@ -0,0 +1,6 @@
+import { StreamFilterInterface } from './stream.filter.interface';
+import { LowPassFilter } from '../events/utilities/grade-calculator/low-pass-filter';
+export declare class LowPassStreamFilter implements StreamFilterInterface {
+    lowPassFilter: LowPassFilter;
+    filterData(data: (number | null)[]): (number | null)[];
+}

package/lib/esm/streams/low-pass.stream.filter.js

@@ -0,0 +1,9 @@
+import { LowPassFilter } from '../events/utilities/grade-calculator/low-pass-filter';
+export class LowPassStreamFilter {
+    constructor() {
+        this.lowPassFilter = new LowPassFilter(0.2);
+    }
+    filterData(data) {
+        return this.lowPassFilter.smoothArray(data);
+    }
+}

package/lib/esm/streams/stream.d.ts

@@ -0,0 +1,22 @@
+import { StreamDataItem, StreamInterface } from './stream.interface';
+import { StreamFilterInterface } from './stream.filter.interface';
+export declare class Stream implements StreamInterface {
+    readonly type: string;
+    protected data: (number | null)[];
+    protected filter: StreamFilterInterface | null;
+    constructor(type: string, data?: (number | null)[]);
+    clearFilters(): this;
+    useFilter(filter: StreamFilterInterface): this;
+    hasFilter(): boolean;
+    getData(onlyNumeric?: boolean, filterInfinity?: boolean): (number | null)[];
+    setData(data: (number | null)[]): this;
+    getStreamDataByTime(startDate: Date, onlyNumeric?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    getStreamDataByDuration(offset?: number, onlyNumeric?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    isExportable(): boolean;
+    toJSON(): StreamJSONInterface;
+    private shouldDataBeFiltered;
+}
+export interface StreamJSONInterface {
+    type: string;
+    data: (number | null)[];
+}

package/lib/esm/streams/stream.filter.interface.d.ts

@@ -0,0 +1,3 @@
+export interface StreamFilterInterface {
+    filterData(data: (number | null)[]): (number | null)[];
+}

package/lib/esm/streams/stream.filter.interface.js

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

package/lib/esm/streams/stream.interface.d.ts

@@ -0,0 +1,73 @@
+import { SerializableClassInterface } from '../serializable/serializable.class.interface';
+import { StreamJSONInterface } from './stream';
+import { StreamFilterInterface } from './stream.filter.interface';
+/**
+ * A stream consists of an array of data like this for example
+ * AltitudeStream: [100, 110, null, 112, 200, null, 300]
+ * The sampling rate of streams is fixed to 1s
+ * That means that on the above example the duration is seconds would be:
+ * [1,2,3,4,5,6,6]
+ *
+ * null means no value and that means missing data.
+ */
+export interface StreamInterface extends SerializableClassInterface {
+    /**
+     * Type of the string. Can be any of the datatypes stored in the dataStore.
+     * @todo make this an 'enum'
+     */
+    type: string;
+    /**
+     * Instructs the stream to use a specific filter when asking for data
+     * @param filter
+     */
+    useFilter(filter: StreamFilterInterface): this;
+    /**
+     * Removes any filter that is used on the Streamm
+     */
+    clearFilters(): this;
+    /**
+     * Checks if a stream has a filter
+     */
+    hasFilter(): boolean;
+    /**
+     * Get's back the streams data as an array
+     * @param onlyNumeric
+     * @param filterInfinity
+     */
+    getData(onlyNumeric?: boolean, filterInfinity?: boolean): (number | null)[];
+    /**
+     * Sets the data for this stream
+     * @param data
+     */
+    setData(data: (number | null)[]): this;
+    /**
+     * Gets the data based / offset on a startDate
+     * @param startDate
+     * @param onlyNumeric
+     * @param filterInfinity
+     */
+    getStreamDataByTime(startDate: Date, onlyNumeric?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    /**
+     * Gets the data offset on a time
+     * @param offset
+     * @param onlyNumeric
+     * @param filterInfinity
+     */
+    getStreamDataByDuration(offset?: number, onlyNumeric?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    /**
+     * Checks if the speed is exportable
+     * - It should not be speed derived stream
+     * - It should not be unit derived stream
+     * - It should not be GNSS distance and other types on blacklist
+     */
+    isExportable(): boolean;
+    toJSON(): StreamJSONInterface;
+}
+export interface StreamDataItem {
+    /**
+     * The time of the value
+     * Can be time as of date or just time in ms
+     */
+    time: number;
+    value: number | null;
+}

package/lib/esm/streams/stream.interface.js

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

package/lib/esm/streams/stream.js

@@ -0,0 +1,72 @@
+import { isNumber } from '../events/utilities/helpers';
+import { DynamicDataLoader } from '../data/data.store';
+export class Stream {
+    constructor(type, data) {
+        this.data = [];
+        this.filter = null;
+        this.type = type;
+        if (data) {
+            this.data = data;
+        }
+    }
+    clearFilters() {
+        this.filter = null;
+        return this;
+    }
+    useFilter(filter) {
+        this.filter = filter;
+        return this;
+    }
+    hasFilter() {
+        return !!this.filter;
+    }
+    getData(onlyNumeric = false, filterInfinity = false) {
+        const data = this.filter ? this.filter.filterData(this.data) : this.data;
+        if (!onlyNumeric && !filterInfinity) {
+            return data;
+        }
+        return data.filter(dataItem => !this.shouldDataBeFiltered(dataItem, onlyNumeric, filterInfinity));
+    }
+    setData(data) {
+        this.data = data;
+        return this;
+    }
+    getStreamDataByTime(startDate, onlyNumeric = false, filterInfinity = false) {
+        return this.getData().reduce((accu, dataItem, index) => {
+            if (this.shouldDataBeFiltered(dataItem, onlyNumeric, filterInfinity)) {
+                return accu;
+            }
+            accu.push({
+                time: startDate.getTime() + index * 1000,
+                value: dataItem
+            });
+            return accu;
+        }, []);
+    }
+    getStreamDataByDuration(offset = 0, onlyNumeric = false, filterInfinity = false) {
+        return this.getData().reduce((accu, dataItem, index) => {
+            if (this.shouldDataBeFiltered(dataItem, onlyNumeric, filterInfinity)) {
+                return accu;
+            }
+            accu.push({
+                time: index * 1000 + (offset || 0),
+                value: dataItem
+            });
+            return accu;
+        }, []);
+    }
+    isExportable() {
+        return (!DynamicDataLoader.isUnitDerivedDataType(this.type) &&
+            !DynamicDataLoader.isSpeedDerivedDataType(this.type) &&
+            !DynamicDataLoader.isBlackListedStream(this.type));
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            data: this.data // Exporting does/ should not use a filter
+        };
+    }
+    shouldDataBeFiltered(data, onlyNumeric, filterInfinity) {
+        return (onlyNumeric && !isNumber(data)) || (filterInfinity && (data === Infinity || data === -Infinity));
+    }
+}

package/lib/esm/streams/stream.spec.d.ts

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

package/lib/esm/streams/stream.spec.js

@@ -0,0 +1,168 @@
+import { DataAltitude } from '../data/data.altitude';
+import { Stream } from './stream';
+import { DataPace, DataPaceMinutesPerMile } from '../data/data.pace';
+import { DataSwimPace, DataSwimPaceMinutesPer100Yard } from '../data/data.swim-pace';
+import { DataSpeed, DataSpeedKilometersPerHour } from '../data/data.speed';
+import { DataGNSSDistance } from '../data/data.gnss-distance';
+import { DataGradeAdjustedSpeed, DataGradeAdjustedSpeedKilometersPerHour } from '../data/data.grade-adjusted-speed';
+import { DataTime } from '../data/data.time';
+import { DataGradeAdjustedPace, DataGradeAdjustedPaceMinutesPerMile } from '../data/data.grade-adjusted-pace';
+import { DataVerticalSpeed, DataVerticalSpeedFeetPerHour } from '../data/data.vertical-speed';
+describe('Stream', () => {
+    beforeEach(() => { });
+    it('should get data', () => {
+        const stream = new Stream(DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]);
+        expect(stream.getData()).toEqual([200, null, 502, Infinity, -Infinity, NaN, 0]);
+        expect(stream.getData(true)).toEqual([200, 502, Infinity, -Infinity, 0]);
+        expect(stream.getData(false, true)).toEqual([200, null, 502, NaN, 0]);
+        expect(stream.getData(true, true)).toEqual([200, 502, 0]);
+    });
+    it('should if it can be exported', () => {
+        let stream;
+        // Pace not exportable
+        stream = new Stream(DataPace.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new Stream(DataPaceMinutesPerMile.type);
+        expect(stream.isExportable()).toBe(false);
+        // Swim pace not exportable
+        stream = new Stream(DataSwimPace.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new Stream(DataSwimPaceMinutesPer100Yard.type);
+        expect(stream.isExportable()).toBe(false);
+        // Speed exportable
+        stream = new Stream(DataSpeed.type);
+        expect(stream.isExportable()).toBe(true);
+        // Speed unit not
+        stream = new Stream(DataSpeedKilometersPerHour.type);
+        expect(stream.isExportable()).toBe(false);
+        // Black listed ones
+        stream = new Stream(DataGNSSDistance.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new Stream(DataTime.type);
+        expect(stream.isExportable()).toBe(false);
+        // Grade one
+        stream = new Stream(DataGradeAdjustedSpeed.type);
+        expect(stream.isExportable()).toBe(true);
+        stream = new Stream(DataGradeAdjustedSpeedKilometersPerHour.type);
+        expect(stream.isExportable()).toBe(false);
+        // GAP should not be exportable
+        stream = new Stream(DataGradeAdjustedPace.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new Stream(DataGradeAdjustedPaceMinutesPerMile.type);
+        expect(stream.isExportable()).toBe(false);
+        // Verticalos
+        stream = new Stream(DataVerticalSpeed.type);
+        expect(stream.isExportable()).toBe(true);
+        stream = new Stream(DataVerticalSpeedFeetPerHour.type);
+        expect(stream.isExportable()).toBe(false);
+    });
+    it('should get stream data by time', () => {
+        const stream = new Stream(DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]);
+        const date = new Date();
+        expect(stream.getStreamDataByTime(date)).toEqual([
+            {
+                time: date.getTime(),
+                value: 200
+            },
+            {
+                time: date.getTime() + 1000,
+                value: null
+            },
+            {
+                time: date.getTime() + 2000,
+                value: 502
+            },
+            {
+                time: date.getTime() + 3000,
+                value: Infinity
+            },
+            {
+                time: date.getTime() + 4000,
+                value: -Infinity
+            },
+            {
+                time: date.getTime() + 5000,
+                value: NaN
+            },
+            {
+                time: date.getTime() + 6000,
+                value: 0
+            }
+        ]);
+        expect(stream.getStreamDataByTime(date, true, true)).toEqual([
+            {
+                time: date.getTime(),
+                value: 200
+            },
+            {
+                time: date.getTime() + 2000,
+                value: 502
+            },
+            {
+                time: date.getTime() + 6000,
+                value: 0
+            }
+        ]);
+    });
+    it('should get stream data by duration', () => {
+        const stream = new Stream(DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]);
+        expect(stream.getStreamDataByDuration(0)).toEqual([
+            {
+                time: 0,
+                value: 200
+            },
+            {
+                time: 1000,
+                value: null
+            },
+            {
+                time: 2000,
+                value: 502
+            },
+            {
+                time: 3000,
+                value: Infinity
+            },
+            {
+                time: 4000,
+                value: -Infinity
+            },
+            {
+                time: 5000,
+                value: NaN
+            },
+            {
+                time: 6000,
+                value: 0
+            }
+        ]);
+        expect(stream.getStreamDataByDuration(0, true, true)).toEqual([
+            {
+                time: 0,
+                value: 200
+            },
+            {
+                time: 2000,
+                value: 502
+            },
+            {
+                time: 6000,
+                value: 0
+            }
+        ]);
+        expect(stream.getStreamDataByDuration(33, true, true)).toEqual([
+            {
+                time: 33,
+                value: 200
+            },
+            {
+                time: 2033,
+                value: 502
+            },
+            {
+                time: 6033,
+                value: 0
+            }
+        ]);
+    });
+});

package/lib/esm/tiles/tile.settings.interface.d.ts

@@ -0,0 +1,59 @@
+import { MapThemes, MapTypes } from '../users/settings/user.map.settings.interface';
+export interface TileSettingsInterface {
+    name: string;
+    order: number;
+    type: TileTypes;
+    size: {
+        columns: number;
+        rows: number;
+    };
+}
+export interface TileChartSettingsInterface extends TileSettingsInterface {
+    chartType: ChartTypes;
+    dataType: string;
+    dataValueType: ChartDataValueTypes;
+    dataTimeInterval: TimeIntervals;
+    dataCategoryType: ChartDataCategoryTypes;
+}
+export interface TileMapSettingsInterface extends TileSettingsInterface {
+    mapType: MapTypes;
+    mapTheme: MapThemes;
+    showHeatMap: boolean;
+    clusterMarkers: boolean;
+}
+export declare enum TileTypes {
+    Chart = "Chart",
+    Map = "Map"
+}
+export declare enum ChartTypes {
+    Pie = "Pie",
+    ColumnsHorizontal = "Columns Horizontal",
+    ColumnsVertical = "Columns Vertical",
+    PyramidsVertical = "Pyramids Vertical",
+    LinesHorizontal = "Lines Horizontal",
+    LinesVertical = "Lines Vertical",
+    Spiral = "Spiral",
+    BrianDevine = "Brian Devine",
+    IntensityZones = "Intensity Zones"
+}
+export declare enum ChartDataValueTypes {
+    Total = "Total",
+    Average = "Average",
+    Maximum = "Maximum",
+    Minimum = "Minimum"
+}
+export declare enum ChartDataCategoryTypes {
+    ActivityType = "Activity Type",
+    DateType = "Date Type"
+}
+export declare enum TimeIntervals {
+    Auto = 0,
+    Hourly = 1,
+    Daily = 2,
+    Weekly = 3,
+    BiWeekly = 4,
+    Monthly = 5,
+    Quarterly = 6,
+    Semesterly = 7,
+    Yearly = 8
+}

package/lib/esm/tiles/tile.settings.interface.js

@@ -0,0 +1,41 @@
+export var TileTypes;
+(function (TileTypes) {
+    TileTypes["Chart"] = "Chart";
+    TileTypes["Map"] = "Map";
+})(TileTypes || (TileTypes = {}));
+export var ChartTypes;
+(function (ChartTypes) {
+    ChartTypes["Pie"] = "Pie";
+    ChartTypes["ColumnsHorizontal"] = "Columns Horizontal";
+    ChartTypes["ColumnsVertical"] = "Columns Vertical";
+    ChartTypes["PyramidsVertical"] = "Pyramids Vertical";
+    ChartTypes["LinesHorizontal"] = "Lines Horizontal";
+    ChartTypes["LinesVertical"] = "Lines Vertical";
+    ChartTypes["Spiral"] = "Spiral";
+    ChartTypes["BrianDevine"] = "Brian Devine";
+    ChartTypes["IntensityZones"] = "Intensity Zones";
+})(ChartTypes || (ChartTypes = {}));
+export var ChartDataValueTypes;
+(function (ChartDataValueTypes) {
+    ChartDataValueTypes["Total"] = "Total";
+    ChartDataValueTypes["Average"] = "Average";
+    ChartDataValueTypes["Maximum"] = "Maximum";
+    ChartDataValueTypes["Minimum"] = "Minimum";
+})(ChartDataValueTypes || (ChartDataValueTypes = {}));
+export var ChartDataCategoryTypes;
+(function (ChartDataCategoryTypes) {
+    ChartDataCategoryTypes["ActivityType"] = "Activity Type";
+    ChartDataCategoryTypes["DateType"] = "Date Type";
+})(ChartDataCategoryTypes || (ChartDataCategoryTypes = {}));
+export var TimeIntervals;
+(function (TimeIntervals) {
+    TimeIntervals[TimeIntervals["Auto"] = 0] = "Auto";
+    TimeIntervals[TimeIntervals["Hourly"] = 1] = "Hourly";
+    TimeIntervals[TimeIntervals["Daily"] = 2] = "Daily";
+    TimeIntervals[TimeIntervals["Weekly"] = 3] = "Weekly";
+    TimeIntervals[TimeIntervals["BiWeekly"] = 4] = "BiWeekly";
+    TimeIntervals[TimeIntervals["Monthly"] = 5] = "Monthly";
+    TimeIntervals[TimeIntervals["Quarterly"] = 6] = "Quarterly";
+    TimeIntervals[TimeIntervals["Semesterly"] = 7] = "Semesterly";
+    TimeIntervals[TimeIntervals["Yearly"] = 8] = "Yearly";
+})(TimeIntervals || (TimeIntervals = {}));

package/lib/esm/users/settings/dashboard/user.dashboard.settings.interface.d.ts

@@ -0,0 +1,28 @@
+import { ActivityTypes } from '../../../activities/activity.types';
+import { TileSettingsInterface } from '../../../tiles/tile.settings.interface';
+export interface UserDashboardSettingsInterface {
+    dateRange: DateRanges;
+    startDate: number;
+    endDate: number;
+    tiles: TileSettingsInterface[];
+    tableSettings: TableSettings;
+    activityTypes?: ActivityTypes[];
+}
+export interface TableSettings {
+    eventsPerPage: number;
+    active: string;
+    direction: 'asc' | 'desc';
+    selectedColumns: string[];
+}
+export declare enum DateRanges {
+    thisWeek = 0,
+    lastWeek = 1,
+    lastSevenDays = 2,
+    thisMonth = 3,
+    lastMonth = 4,
+    lastThirtyDays = 5,
+    thisYear = 6,
+    lastYear = 7,
+    custom = 8,
+    all = 9
+}

package/lib/esm/users/settings/dashboard/user.dashboard.settings.interface.js

@@ -0,0 +1,13 @@
+export var DateRanges;
+(function (DateRanges) {
+    DateRanges[DateRanges["thisWeek"] = 0] = "thisWeek";
+    DateRanges[DateRanges["lastWeek"] = 1] = "lastWeek";
+    DateRanges[DateRanges["lastSevenDays"] = 2] = "lastSevenDays";
+    DateRanges[DateRanges["thisMonth"] = 3] = "thisMonth";
+    DateRanges[DateRanges["lastMonth"] = 4] = "lastMonth";
+    DateRanges[DateRanges["lastThirtyDays"] = 5] = "lastThirtyDays";
+    DateRanges[DateRanges["thisYear"] = 6] = "thisYear";
+    DateRanges[DateRanges["lastYear"] = 7] = "lastYear";
+    DateRanges[DateRanges["custom"] = 8] = "custom";
+    DateRanges[DateRanges["all"] = 9] = "all";
+})(DateRanges || (DateRanges = {}));