@energycap/components 0.41.1-ECAP-26841-date-input-features.20250108-1012 → 0.42.0

package/esm2022/lib/core/date-time-helper.mjs

@@ -0,0 +1,220 @@
+import moment from 'moment';
+/**
+ * Helper class that provides common date constants and helpful date functions
+ */
+export class DateTimeHelper {
+    ///////////////////////////////////////////////////////
+    // CONSTANTS
+    ///////////////////////////////////////////////////////
+    static { this.beginningOfTime = new Date(1899, 11, 31); }
+    /** 3000-01-01 */
+    static { this.endOfTime = new Date(3000, 0, 1); }
+    /** 3000-01-01 UTC */
+    static { this.endOfTimeUTC = moment.utc('3000-01-01').toDate(); }
+    /** Default effective date for new AccountMeter relationships: 2010-01-01 */
+    static { this.defaultAccountMeterEffectiveDate = new Date(2010, 0, 1); }
+    /** The default date that a newly created account becomes effective: 2010-01-01 */
+    static { this.defaultAccountServiceEffectiveDate = new Date(2010, 0, 1); }
+    /** Minimum date for all datepickers: 1980-01-01 */
+    static { this.minDatePickerDate = new Date(1980, 0, 1); }
+    /** Maximum date for all datepickers: 3000-01-01 11:59:59 PM to allow for local time offset working in for 3000-01-01 dates, which we store in the db to represent "end of time" */
+    static { this.maxDatePickerDate = new Date(3000, 0, 1, 23, 59, 59); }
+    /** Timestamp formats */
+    static { this.defaultDateFormat = "yyyy-MM-dd"; }
+    static { this.defaultTimeFormat = "HH:mm:ss"; }
+    static { this.defaultTimestampFormat = `${DateTimeHelper.defaultDateFormat} ${DateTimeHelper.defaultTimeFormat}`; }
+    /** List of valid bill import date formats
+     *  Warning! Do not use these for actual formatting of dates
+     */
+    static { this.billImportFormatDateFormats = [
+        { label: "mm/dd/yyyy", value: "mm/dd/yyyy" }, { label: "Month dd yyyy", value: "Month dd yyyy" },
+        { label: "dd/mm/yyyy", value: "dd/mm/yyyy" }, { label: "dd Month yyyy", value: "dd Month yyyy" }, { label: "yyyymmdd", value: "yyyymmdd" }
+    ]; }
+    /**
+     * User input formats that we will parse into a date
+     * when the users date format preference has month before day
+     */
+    static { this.monthFirstParseFormats = [
+        "yyyy/MM/dd",
+        "MM/dd/yyyy",
+        "MMddyyyy",
+        "MM/dd/yy",
+        "MMddyy",
+        "MM/dd",
+        "yyyy.MM.dd",
+        "MM.dd.yyyy",
+        "MM.dd.yy",
+        "MM.dd",
+        "yyyy-MM-dd",
+        "MM-dd-yyyy",
+        "MM-dd-yy",
+        "MM-dd",
+        "yyyyMMdd"
+    ]; }
+    /**
+     * User input formats that we will parse into a date
+     * when the users date format preference has month before day.
+     * To be used with moment.js. Moment ignores non-alphanumeric characters
+     * so dates like 2020/09/10 will be parsed the same as 2020-09-10
+     */
+    static { this.momentMonthFirstParseFormats = [
+        'M-D',
+        'MM-DD',
+        'M-D-YY',
+        'MM-DD-YY',
+        'MMDDYYYY',
+        'YYYYMMDD',
+        'YYYY-MM-DD',
+        'MM-DD-YYYY'
+    ]; }
+    /**
+     * User input formats that we will parse into a date
+     * when the users date format preference has day before month
+     */
+    static { this.dateFirstParseFormats = [
+        "yyyy/dd/MM",
+        "dd/MM/yyyy",
+        "ddMMyyyy",
+        "dd/MM/yy",
+        "ddMMyy",
+        "dd/MM",
+        "yyyy.dd.MM",
+        "dd.MM.yyyy",
+        "dd.MM.yy",
+        "dd.MM",
+        "yyyy-dd-MM",
+        "dd-MM-yyyy",
+        "dd-MM-yy",
+        "dd-MM",
+        "yyyyDDmm"
+    ]; }
+    /**
+     * User input formats that we will parse into a date
+     * when the users date format preference has day before month.
+     * To be used with moment.js. Moment ignores non-alphanumeric characters
+     * so dates like 2020/09/10 will be parsed the same as 2020-09-10
+     */
+    static { this.momentDateFirstParseFormats = [
+        'D-M',
+        'DD-MM',
+        'D-M-YY',
+        'DD-MM-YY',
+        'DDMMYYYY',
+        'YYYYMMDD',
+        'YYYY-MM-DD',
+        'DD-MM-YYYY'
+    ]; }
+    /**
+     * Formats used to parse dates that are in the medium or long format by moment js.
+     * These are shared by date-first and month-first date formats. The date can't be
+     * parsed differently based on the date preference since the month is not numeric.
+     * This is not an exhaustive list of formats, but it should cover most common formats.
+     */
+    static { this.momentMedAndLongDateFormats = [
+        'DD MMM YY',
+        'DD MMM YYYY',
+        'DD MMMM YYYY',
+        'MMM D, YY',
+        'MMM D, YYYY',
+        'MMM DD, YYYY',
+        'MMMM D, YYYY',
+        'MMMM DD, YYYY'
+    ]; }
+    /**
+     * Format to display the time portion of a datetime
+     */
+    static { this.timeFormat = 'HH:mm:ss'; }
+    ///////////////////////////////////////////////////////
+    // METHODS
+    ///////////////////////////////////////////////////////
+    /**
+     * Return true if @see date is equal to the @see endOfTime
+     */
+    static isEndOfTime(date, timeZoneOffset = false) {
+        const endOfTime = timeZoneOffset ? this.endOfTimeUTC : this.endOfTime;
+        return this.isSameDay(date, endOfTime);
+    }
+    /**
+     * Compare two dates and return true if they represent the same year, month, and day (time is ignored).
+     */
+    static isSameDay(date1, date2) {
+        return moment(date1).isSame(moment(date2), 'day');
+    }
+    /**
+     * Get the parse formats based on the given date format. If no date format is
+     * given, or we don't recognize the format, return the month first parse formats.
+     *
+     */
+    static getParseFormats(dateFormat) {
+        let map = {
+            'MM/DD/YYYY': this.monthFirstParseFormats,
+            'MM-DD-YYYY': this.monthFirstParseFormats,
+            'DD/MM/YYYY': this.dateFirstParseFormats,
+            'DD-MM-YYYY': this.dateFirstParseFormats,
+            'YYYY/MM/DD': this.monthFirstParseFormats,
+            'YYYY-MM-DD': this.monthFirstParseFormats
+        };
+        return dateFormat ? map[dateFormat] : this.monthFirstParseFormats;
+    }
+    /**
+     * Get the moment parse formats based on the given date format. If no date format is
+     * given, or we don't recognize the format, return the month first parse formats.
+     */
+    static getMomentParseFormats(dateFormat) {
+        let map = {
+            'MM/DD/YYYY': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats],
+            'MM-DD-YYYY': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats],
+            'DD/MM/YYYY': [...this.momentDateFirstParseFormats, ...this.momentMedAndLongDateFormats],
+            'DD-MM-YYYY': [...this.momentDateFirstParseFormats, ...this.momentMedAndLongDateFormats],
+            'YYYY/MM/DD': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats],
+            'YYYY-MM-DD': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats]
+        };
+        return dateFormat ? map[dateFormat] : this.momentMonthFirstParseFormats;
+    }
+    /**
+     * Get relationship start date (favoring date in partialFormState if exists)
+     * * return default account-meter effective date if no start date found
+     *
+     */
+    static getAccountMeterStartDate(partialFormState, accountMeter) {
+        let startDate = partialFormState.effectiveFrom || accountMeter.startDate;
+        return startDate ? new Date(startDate) : DateTimeHelper.defaultAccountMeterEffectiveDate;
+    }
+    /**
+     * Get relationship end date (favoring date in partialFormState if exists)
+     * * return null if no stored date or end date is 1/1/3000
+     */
+    static getAccountMeterEndDate(partialFormState, accountMeter) {
+        let endDate = partialFormState.effectiveTo || accountMeter.endDate;
+        if (endDate && !DateTimeHelper.isEndOfTime(endDate)) {
+            return new Date(endDate);
+        }
+        return null;
+    }
+    static isDateBetween(date, startDate, endDate, includeStart, includeEnd) {
+        let inclusivity = '()';
+        if (includeStart && includeEnd) {
+            inclusivity = '[]';
+        }
+        else if (includeStart) {
+            inclusivity = '[)';
+        }
+        else if (includeEnd) {
+            inclusivity = '(]';
+        }
+        // If a start date is not provide, we'll use our beginning of time instead
+        startDate = startDate || this.beginningOfTime;
+        // If an end date is not provided, we'll use our end of time instead
+        endDate = endDate || this.endOfTime;
+        return moment(date).isBetween(startDate, endDate, 'day', inclusivity);
+    }
+    static stringToDate(dateString) {
+        if (dateString === null || dateString === undefined) {
+            return dateString;
+        }
+        else {
+            return moment(dateString).toDate();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-helper.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/core/date-time-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from 'moment';\r\n\r\ntype DateFormatMap = { [format: string]: string[] };\r\n\r\n/**\r\n * Helper class that provides common date constants and helpful date functions\r\n */\r\nexport class DateTimeHelper {\r\n\r\n    ///////////////////////////////////////////////////////\r\n    // CONSTANTS\r\n    ///////////////////////////////////////////////////////\r\n\r\n    public static beginningOfTime: Date = new Date(1899,11,31);\r\n     \r\n    /** 3000-01-01 */\r\n    public static endOfTime: Date = new Date(3000, 0, 1);\r\n\r\n    /** 3000-01-01 UTC */\r\n    public static endOfTimeUTC: Date = moment.utc('3000-01-01').toDate();\r\n\r\n    /** Default effective date for new AccountMeter relationships: 2010-01-01 */\r\n    public static defaultAccountMeterEffectiveDate: Date = new Date(2010, 0, 1);\r\n\r\n    /** The default date that a newly created account becomes effective: 2010-01-01 */\r\n    public static defaultAccountServiceEffectiveDate: Date = new Date(2010, 0, 1);\r\n\r\n    /** Minimum date for all datepickers: 1980-01-01 */\r\n    public static minDatePickerDate: Date = new Date(1980, 0, 1);\r\n\r\n    /** Maximum date for all datepickers: 3000-01-01 11:59:59 PM to allow for local time offset working in for 3000-01-01 dates, which we store in the db to represent \"end of time\" */\r\n    public static maxDatePickerDate: Date = new Date(3000,0,1,23,59,59);\r\n\r\n    /** Timestamp formats */\r\n    public static defaultDateFormat: string = \"yyyy-MM-dd\";\r\n    public static defaultTimeFormat: string = \"HH:mm:ss\";\r\n    public static defaultTimestampFormat: string = `${DateTimeHelper.defaultDateFormat} ${DateTimeHelper.defaultTimeFormat}`;\r\n\r\n    /** List of valid bill import date formats\r\n     *  Warning! Do not use these for actual formatting of dates\r\n     */\r\n    public static billImportFormatDateFormats = [\r\n        { label: \"mm/dd/yyyy\", value: \"mm/dd/yyyy\" }, { label: \"Month dd yyyy\", value: \"Month dd yyyy\" }, \r\n        { label: \"dd/mm/yyyy\", value: \"dd/mm/yyyy\" }, { label: \"dd Month yyyy\", value: \"dd Month yyyy\" }, { label: \"yyyymmdd\", value: \"yyyymmdd\" }];\r\n\r\n    /**\r\n     * User input formats that we will parse into a date\r\n     * when the users date format preference has month before day\r\n     */\r\n    public static monthFirstParseFormats: string[] = [\r\n        \"yyyy/MM/dd\",\r\n        \"MM/dd/yyyy\",\r\n        \"MMddyyyy\",\r\n        \"MM/dd/yy\",\r\n        \"MMddyy\",\r\n        \"MM/dd\",\r\n        \"yyyy.MM.dd\",\r\n        \"MM.dd.yyyy\",\r\n        \"MM.dd.yy\",\r\n        \"MM.dd\",\r\n        \"yyyy-MM-dd\",\r\n        \"MM-dd-yyyy\",\r\n        \"MM-dd-yy\",\r\n        \"MM-dd\",\r\n        \"yyyyMMdd\"\r\n    ];\r\n\r\n    /**\r\n     * User input formats that we will parse into a date\r\n     * when the users date format preference has month before day.\r\n     * To be used with moment.js. Moment ignores non-alphanumeric characters\r\n     * so dates like 2020/09/10 will be parsed the same as 2020-09-10\r\n     */\r\n    public static momentMonthFirstParseFormats: string[] = [\r\n        'M-D',\r\n        'MM-DD',\r\n        'M-D-YY',\r\n        'MM-DD-YY',\r\n        'MMDDYYYY',\r\n        'YYYYMMDD',\r\n        'YYYY-MM-DD',\r\n        'MM-DD-YYYY'\r\n    ];\r\n\r\n    /**\r\n     * User input formats that we will parse into a date\r\n     * when the users date format preference has day before month\r\n     */\r\n    public static dateFirstParseFormats: string[] = [\r\n        \"yyyy/dd/MM\",\r\n        \"dd/MM/yyyy\",\r\n        \"ddMMyyyy\",\r\n        \"dd/MM/yy\",\r\n        \"ddMMyy\",\r\n        \"dd/MM\",\r\n        \"yyyy.dd.MM\",\r\n        \"dd.MM.yyyy\",\r\n        \"dd.MM.yy\",\r\n        \"dd.MM\",\r\n        \"yyyy-dd-MM\",\r\n        \"dd-MM-yyyy\",\r\n        \"dd-MM-yy\",\r\n        \"dd-MM\",\r\n        \"yyyyDDmm\"\r\n    ];\r\n\r\n    /**\r\n     * User input formats that we will parse into a date\r\n     * when the users date format preference has day before month.\r\n     * To be used with moment.js. Moment ignores non-alphanumeric characters\r\n     * so dates like 2020/09/10 will be parsed the same as 2020-09-10\r\n     */\r\n    public static momentDateFirstParseFormats: string[] = [\r\n        'D-M',\r\n        'DD-MM',\r\n        'D-M-YY',\r\n        'DD-MM-YY',\r\n        'DDMMYYYY',\r\n        'YYYYMMDD',\r\n        'YYYY-MM-DD',\r\n        'DD-MM-YYYY'\r\n    ];\r\n\r\n    /**\r\n     * Formats used to parse dates that are in the medium or long format by moment js.\r\n     * These are shared by date-first and month-first date formats. The date can't be\r\n     * parsed differently based on the date preference since the month is not numeric.\r\n     * This is not an exhaustive list of formats, but it should cover most common formats.\r\n     */\r\n    public static momentMedAndLongDateFormats: string[] = [\r\n        'DD MMM YY',\r\n        'DD MMM YYYY',\r\n        'DD MMMM YYYY',\r\n        'MMM D, YY',\r\n        'MMM D, YYYY',\r\n        'MMM DD, YYYY',\r\n        'MMMM D, YYYY',\r\n        'MMMM DD, YYYY'\r\n    ];\r\n\r\n    /**\r\n     * Format to display the time portion of a datetime\r\n     */\r\n    public static timeFormat: string = 'HH:mm:ss';\r\n\r\n    ///////////////////////////////////////////////////////\r\n    // METHODS\r\n    ///////////////////////////////////////////////////////\r\n\r\n    /**\r\n     * Return true if @see date is equal to the @see endOfTime\r\n     */\r\n    public static isEndOfTime(date: Date | moment.Moment | string, timeZoneOffset: boolean = false): boolean {\r\n        const endOfTime = timeZoneOffset ? this.endOfTimeUTC : this.endOfTime;\r\n        return this.isSameDay(date, endOfTime);\r\n    }\r\n\r\n\r\n    /**\r\n     * Compare two dates and return true if they represent the same year, month, and day (time is ignored).\r\n     */\r\n    public static isSameDay(date1: Date | moment.Moment | string, date2: Date | moment.Moment | string): boolean {\r\n        return moment(date1).isSame(moment(date2), 'day');\r\n    }\r\n\r\n    /**\r\n     * Get the parse formats based on the given date format. If no date format is\r\n     * given, or we don't recognize the format, return the month first parse formats.\r\n     * \r\n     */\r\n    public static getParseFormats(dateFormat?: string | null): string[] {\r\n        let map: DateFormatMap = {\r\n            'MM/DD/YYYY': this.monthFirstParseFormats,\r\n            'MM-DD-YYYY': this.monthFirstParseFormats,\r\n            'DD/MM/YYYY': this.dateFirstParseFormats,\r\n            'DD-MM-YYYY': this.dateFirstParseFormats,\r\n            'YYYY/MM/DD': this.monthFirstParseFormats,\r\n            'YYYY-MM-DD': this.monthFirstParseFormats\r\n        };\r\n\r\n        return dateFormat ? map[dateFormat] : this.monthFirstParseFormats;\r\n    }\r\n\r\n    /**\r\n     * Get the moment parse formats based on the given date format. If no date format is\r\n     * given, or we don't recognize the format, return the month first parse formats.\r\n     */\r\n    public static getMomentParseFormats(dateFormat?: string | null): string[] {\r\n        let map: DateFormatMap = {\r\n            'MM/DD/YYYY': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats],\r\n            'MM-DD-YYYY': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats],\r\n            'DD/MM/YYYY': [...this.momentDateFirstParseFormats, ...this.momentMedAndLongDateFormats],\r\n            'DD-MM-YYYY': [...this.momentDateFirstParseFormats, ...this.momentMedAndLongDateFormats],\r\n            'YYYY/MM/DD': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats],\r\n            'YYYY-MM-DD': [...this.momentMonthFirstParseFormats, ...this.momentMedAndLongDateFormats]\r\n        };\r\n\r\n        return dateFormat ? map[dateFormat] : this.momentMonthFirstParseFormats;\r\n    }\r\n\r\n\r\n\r\n    /**\r\n     * Get relationship start date (favoring date in partialFormState if exists)\r\n     * * return default account-meter effective date if no start date found\r\n     * \r\n     */\r\n    public static getAccountMeterStartDate(partialFormState: any, accountMeter: { startDate: Date | null | undefined }): Date {\r\n        let startDate = partialFormState.effectiveFrom || accountMeter.startDate;\r\n        return startDate ? new Date(startDate) : DateTimeHelper.defaultAccountMeterEffectiveDate;\r\n    }\r\n\r\n    \r\n    /**\r\n     * Get relationship end date (favoring date in partialFormState if exists)\r\n     * * return null if no stored date or end date is 1/1/3000\r\n     */\r\n    public static getAccountMeterEndDate(partialFormState: any, accountMeter: { endDate: Date | null | undefined }): Date | null {\r\n        let endDate = partialFormState.effectiveTo || accountMeter.endDate;\r\n        if (endDate && !DateTimeHelper.isEndOfTime(endDate)) {\r\n            return new Date(endDate);\r\n        }\r\n        return null;\r\n    }\r\n    \r\n    public static isDateBetween(\r\n        date: Date, \r\n        startDate?: Date | null, \r\n        endDate?: Date | null, \r\n        includeStart?: boolean, \r\n        includeEnd?: boolean\r\n    ):boolean {\r\n        let inclusivity: '()' | '[)' | '(]' | '[]' = '()';\r\n        if (includeStart && includeEnd ) {\r\n            inclusivity = '[]';\r\n        } else if (includeStart) {\r\n            inclusivity = '[)';\r\n        } else if (includeEnd) {\r\n            inclusivity = '(]';\r\n        }\r\n\r\n        // If a start date is not provide, we'll use our beginning of time instead\r\n        startDate = startDate || this.beginningOfTime;\r\n\r\n        // If an end date is not provided, we'll use our end of time instead\r\n        endDate = endDate || this.endOfTime;\r\n\r\n        return moment(date).isBetween(startDate, endDate, 'day', inclusivity);\r\n    }\r\n\r\n    public static stringToDate(dateString: string | null | undefined): Date | null | undefined {\r\n      if (dateString === null || dateString === undefined) {\r\n        return dateString;\r\n      } else {\r\n        return moment(dateString).toDate();\r\n      }      \r\n    }\r\n}"]}

package/esm2022/lib/core/error.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export function isApiError(errorResponse) {
+    // errorResponse is typed HttpErrorResponse if the api returns an error
+    if (errorResponse.error && errorResponse.error.hasOwnProperty('status') && errorResponse.error.status.hasOwnProperty('message')) {
+        return true;
+    }
+    // BillCAPture APIs return errors in a different format
+    if (errorResponse.error && errorResponse.error.hasOwnProperty('Message')) {
+        return true;
+    }
+    return false;
+}
+export class ErrorService {
+    constructor() { }
+    /**
+     * Parse an error that comes from the API for use inside the forms
+     * In most cases this isn't required because the error handler will do it automatically,
+     * but if you need to analyze the error message you can use this to extract it safely.
+     * NOTE: Because it can be used for comparison the result is not translated. You must translate
+     * it before providing it to the user.
+     * @param error The error object from the API
+     */
+    parseApiError(errorResponse, unknownErrorDefault) {
+        if (typeof errorResponse === 'string') {
+            return errorResponse;
+        }
+        // errorResponse is typed HttpErrorResponse if the api returns an error
+        let apiErrorMessage = unknownErrorDefault || 'DefaultUnknownError_SC';
+        if (errorResponse && isApiError(errorResponse)) {
+            try {
+                apiErrorMessage = errorResponse.error.status?.message || errorResponse.error.Message;
+            }
+            catch (error) {
+                //log the real error to the console (for developers) but just return the generic error to the user
+                this.logConsoleError(error);
+            }
+        }
+        else {
+            this.logConsoleError(errorResponse);
+        }
+        return apiErrorMessage;
+    }
+    /**
+     * Just a safe wrapper around console.error in case the browser doesn't have one exposed
+     */
+    logConsoleError(error) {
+        if (console && typeof (console.error) === 'function') {
+            console.error('unknown error:', error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ErrorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/router-helper.service.mjs

@@ -0,0 +1,111 @@
+import { Injectable } from "@angular/core";
+import { convertToParamMap, NavigationEnd, NavigationStart } from "@angular/router";
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class RouterHelper {
+    /**
+     * Traverses the pathFromRoot and combines all of the route parameters into
+     * one Params object and returns it
+     * @param route - ActivatedRouteSnapshot
+     * @see https://angular.io/api/router/ActivatedRouteSnapshot#pathFromRoot
+     */
+    getFullRouteParams(route) {
+        const params = {};
+        route.pathFromRoot.forEach(snapshot => {
+            snapshot.paramMap.keys.forEach(key => {
+                params[key] = snapshot.paramMap.get(key);
+            });
+        });
+        return params;
+    }
+    /**
+     * Traverses the pathFromRoot and combines all of the route paramters into
+     * one ParamMap and returns it
+     * @param route - ActivatedRouteSnapshot
+     * @see https://angular.io/api/router/ActivatedRouteSnapshot#pathFromRoot
+     */
+    getFullRouteParamMap(route) {
+        const params = this.getFullRouteParams(route);
+        return convertToParamMap(params);
+    }
+    /**
+     * Traverses the pathFromRoot and combines all of the route paths into
+     * a url from root to the provided activated route.
+     * @param route - ActivatedRouteSnapshot
+     * @see https://angular.io/api/router/ActivatedRouteSnapshot#pathFromRoot
+     */
+    serializeUrlFromRoot(route) {
+        let url = '';
+        const paths = [];
+        route.pathFromRoot.forEach(r => {
+            r.url.forEach(s => {
+                paths.push(s.path);
+            });
+        });
+        url = paths.join('/');
+        return url;
+    }
+    /**
+     * Look at the first two child activated routes of a page route and combine the
+     * url segments of each. These will contain the paths for the current view that
+     * correspond to a primary and secondary tab. Assumes the URL structure is
+     * /{page}/{primary}/{secondary}
+     * @param pageRoute - The ActivatedRoute for the 'page' portion of the url. E.g. meter/:meterId
+     */
+    getViewUrlSegments(pageRoute) {
+        let segments = [];
+        const primaryViewRoute = pageRoute.firstChild;
+        if (primaryViewRoute) {
+            segments = segments.concat(primaryViewRoute.snapshot.url);
+            const secondaryViewRoute = primaryViewRoute.firstChild;
+            if (secondaryViewRoute) {
+                segments = segments.concat(secondaryViewRoute.snapshot.url);
+            }
+        }
+        return segments;
+    }
+    /**
+     * Returns the 'last firstChild' of the provided route tree
+     * @param route - ActivatedRoute
+     */
+    getLastRouteDescendant(route) {
+        while (route.firstChild) {
+            route = route.firstChild;
+        }
+        return route;
+    }
+    /**
+     * Wrap code that will force the user to navigate based on some network call in a piece of logic that will cancel the action if there is another
+     * navigation event while we wait for the call to complete. This is a common problem with trying to pick a default child when a user switches between modules.
+     * @param asyncCall The async code to execute while watching for router navigation events. This code always executed and the result is returned
+     * @param doIfNoNavigation The code to execute only if no navigation events happen while asyncCall is executing. It is passed the result of the async call
+     * @param router The router instance to listen for navigation events.
+     */
+    async executeWithNavigationWatcher(asyncCall, doIfNoNavigation, router) {
+        let eventOccurred = false;
+        let subscription = router.events.pipe(filter(e => e instanceof NavigationStart || e instanceof NavigationEnd)).subscribe(() => {
+            eventOccurred = true;
+        });
+        try {
+            let result = await asyncCall();
+            if (!eventOccurred) {
+                await doIfNoNavigation(result);
+            }
+            subscription.unsubscribe();
+            return result;
+        }
+        catch (error) {
+            subscription.unsubscribe();
+            throw error;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouterHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouterHelper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouterHelper, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router-helper.service.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/core/router-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { ActivatedRoute, ActivatedRouteSnapshot, convertToParamMap, NavigationEnd, NavigationStart, ParamMap, Params, Router, UrlSegment } from \"@angular/router\";\r\nimport { filter } from 'rxjs/operators';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class RouterHelper {\r\n  /**\r\n   * Traverses the pathFromRoot and combines all of the route parameters into\r\n   * one Params object and returns it\r\n   * @param route - ActivatedRouteSnapshot\r\n   * @see https://angular.io/api/router/ActivatedRouteSnapshot#pathFromRoot\r\n   */\r\n  public getFullRouteParams(route: ActivatedRouteSnapshot): Params {\r\n    const params: Params = {};\r\n    route.pathFromRoot.forEach(snapshot => {\r\n      snapshot.paramMap.keys.forEach(key => {\r\n        params[key] = snapshot.paramMap.get(key);\r\n      });\r\n    });\r\n    return params;\r\n  }\r\n\r\n  /**\r\n   * Traverses the pathFromRoot and combines all of the route paramters into\r\n   * one ParamMap and returns it\r\n   * @param route - ActivatedRouteSnapshot\r\n   * @see https://angular.io/api/router/ActivatedRouteSnapshot#pathFromRoot\r\n   */\r\n  public getFullRouteParamMap(route: ActivatedRouteSnapshot): ParamMap {\r\n    const params = this.getFullRouteParams(route);\r\n    return convertToParamMap(params);\r\n  }\r\n  \r\n  /**\r\n   * Traverses the pathFromRoot and combines all of the route paths into\r\n   * a url from root to the provided activated route.\r\n   * @param route - ActivatedRouteSnapshot\r\n   * @see https://angular.io/api/router/ActivatedRouteSnapshot#pathFromRoot\r\n   */\r\n  public serializeUrlFromRoot(route: ActivatedRouteSnapshot): string {\r\n    let url:string = '';\r\n    const paths: string[] = [];\r\n    route.pathFromRoot.forEach(r => {\r\n      r.url.forEach(s => {\r\n        paths.push(s.path);\r\n      });\r\n    });\r\n    url = paths.join('/');\r\n    return url;\r\n  }\r\n\r\n  /**\r\n   * Look at the first two child activated routes of a page route and combine the \r\n   * url segments of each. These will contain the paths for the current view that\r\n   * correspond to a primary and secondary tab. Assumes the URL structure is \r\n   * /{page}/{primary}/{secondary}\r\n   * @param pageRoute - The ActivatedRoute for the 'page' portion of the url. E.g. meter/:meterId\r\n   */\r\n  public getViewUrlSegments(pageRoute: ActivatedRoute): UrlSegment[] {\r\n    let segments: UrlSegment[] = [];\r\n\r\n    const primaryViewRoute: ActivatedRoute | null = pageRoute.firstChild;\r\n    if (primaryViewRoute) {\r\n      segments = segments.concat(primaryViewRoute.snapshot.url);\r\n      const secondaryViewRoute: ActivatedRoute | null = primaryViewRoute.firstChild;\r\n      if (secondaryViewRoute) {\r\n        segments = segments.concat(secondaryViewRoute.snapshot.url);\r\n      }\r\n    }\r\n\r\n    return segments;\r\n  }\r\n\r\n  /**\r\n   * Returns the 'last firstChild' of the provided route tree\r\n   * @param route - ActivatedRoute\r\n   */\r\n  public getLastRouteDescendant(route: ActivatedRoute): ActivatedRoute {\r\n    while (route.firstChild) {\r\n      route = route.firstChild;\r\n    }\r\n    return route;\r\n  }\r\n\r\n  /**\r\n   * Wrap code that will force the user to navigate based on some network call in a piece of logic that will cancel the action if there is another\r\n   * navigation event while we wait for the call to complete. This is a common problem with trying to pick a default child when a user switches between modules.\r\n   * @param asyncCall The async code to execute while watching for router navigation events. This code always executed and the result is returned\r\n   * @param doIfNoNavigation The code to execute only if no navigation events happen while asyncCall is executing. It is passed the result of the async call\r\n   * @param router The router instance to listen for navigation events.\r\n   */\r\n  public async executeWithNavigationWatcher<T>(asyncCall: () => Promise<T>, doIfNoNavigation: (result: T) => Promise<void>, router: Router): Promise<T> {\r\n    let eventOccurred: boolean = false;\r\n    let subscription = router.events.pipe(\r\n      filter(e => e instanceof NavigationStart || e instanceof NavigationEnd)\r\n    ).subscribe(() => {\r\n      eventOccurred = true;\r\n    });\r\n\r\n    try {\r\n      let result = await asyncCall();\r\n      if (!eventOccurred) {\r\n        await doIfNoNavigation(result);\r\n      }\r\n      subscription.unsubscribe();\r\n      return result;\r\n      \r\n    } catch (error) {\r\n      subscription.unsubscribe();\r\n      throw error;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/scroll.service.mjs

@@ -0,0 +1,89 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class ScrollService {
+    constructor() { }
+    /**
+     * Given a container and the target element to scroll to, we will set the scroll top on
+     *  the container to bring the target into view.
+     *
+     * @param scrollContainerSelector A valid CSS selector string for the scroll container.
+     * @param targetElementSelector A valid CSS selector string for the target element.
+     * @param topPadding The amount of space to leave above the target
+     * to keep it from being pinned to the top of the scrollContainer. Defaults
+     * to 32px, the default height of a menu item.
+     */
+    scrollToItem(scrollContainerSelector, targetElementSelector, topPadding = 32) {
+        let scrollContainer = document.querySelector(scrollContainerSelector);
+        if (!scrollContainer) {
+            return;
+        }
+        let targetElement = scrollContainer.querySelector(targetElementSelector);
+        if (!targetElement) {
+            return;
+        }
+        let targetRect = targetElement.getBoundingClientRect();
+        let containerRect = scrollContainer.getBoundingClientRect();
+        // Only scroll if the target is outside of the view bounds of the container
+        if (targetRect.bottom > containerRect.bottom || targetRect.top < containerRect.top) {
+            scrollContainer.scrollTop =
+                (targetRect.top - containerRect.top) + scrollContainer.scrollTop - topPadding;
+        }
+    }
+    /**
+     * Return the value of the scrollTop property for an HTMLElement that matches the selector
+     * @param scrollContainerSelector A valid CSS selector
+     */
+    getCurrentScrollPosition(scrollContainerSelector) {
+        let scrollContainer = document.querySelector(scrollContainerSelector);
+        if (scrollContainer) {
+            return scrollContainer.scrollTop;
+        }
+        else {
+            console.error(`Scroll container '${scrollContainerSelector}' does not exist.`);
+            return 0;
+        }
+    }
+    /**
+     * Set the scrollTop of an HTMLElement that matches the selector to a specific position
+     * @param scrollContainerSelector A valid CSS selector
+     * @param position
+     */
+    scrollToPosition(scrollContainerSelector, position) {
+        let scrollContainer = document.querySelector(scrollContainerSelector);
+        if (scrollContainer) {
+            scrollContainer.scrollTop = position;
+        }
+        else {
+            console.error(`Scroll container '${scrollContainerSelector}' does not exist.`);
+        }
+    }
+    /**
+     *  Given a container and the target element to scroll to, we will set the scroll top on
+     *  the container to bring the target into view, with the item in the center of the scroll container.
+     *
+     * @param scrollContainerSelector A valid CSS selector string for the scroll container.
+     * @param targetElementSelector A valid CSS selector string for the target element.
+     */
+    scrollItemCentered(scrollContainerSelector, targetElementSelector) {
+        try {
+            let scrollContainer = document.querySelector(scrollContainerSelector);
+            if (scrollContainer) {
+                let containerHeight = scrollContainer.getBoundingClientRect().height;
+                // Pad the top with half of the height of the container to put the target in the middle
+                this.scrollToItem(scrollContainerSelector, targetElementSelector, containerHeight * .5);
+            }
+        }
+        catch (error) {
+            console.error(`Error scrolling target into view. Container selector: ${scrollContainerSelector}. Target selector:  ${targetElementSelector}`, error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScrollService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScrollService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll.service.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/core/scroll.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAK3C,MAAM,OAAO,aAAa;IAEtB,gBAAgB,CAAC;IAEjB;;;;;;;;;OASG;IACI,YAAY,CAAC,uBAA+B,EAAE,qBAA6B,EAAE,UAAU,GAAG,EAAE;QAC/F,IAAI,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;QACtE,IAAI,CAAC,eAAe,EAAE,CAAC;YACnB,OAAO;QACX,CAAC;QACD,IAAI,aAAa,GAAG,eAAe,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;QACzE,IAAI,CAAC,aAAa,EAAE,CAAC;YACjB,OAAO;QACX,CAAC;QAED,IAAI,UAAU,GAAG,aAAa,CAAC,qBAAqB,EAAE,CAAC;QACvD,IAAI,aAAa,GAAG,eAAe,CAAC,qBAAqB,EAAE,CAAC;QAE5D,2EAA2E;QAC3E,IAAI,UAAU,CAAC,MAAM,GAAG,aAAa,CAAC,MAAM,IAAI,UAAU,CAAC,GAAG,GAAG,aAAa,CAAC,GAAG,EAAE,CAAC;YACjF,eAAe,CAAC,SAAS;gBACrB,CAAC,UAAU,CAAC,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,SAAS,GAAG,UAAU,CAAC;QACtF,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,wBAAwB,CAAC,uBAA+B;QAC3D,IAAI,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;QACtE,IAAI,eAAe,EAAE,CAAC;YAClB,OAAO,eAAe,CAAC,SAAS,CAAC;QACrC,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,KAAK,CAAC,qBAAqB,uBAAuB,mBAAmB,CAAC,CAAC;YAC/E,OAAO,CAAC,CAAC;QACb,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,uBAA+B,EAAE,QAAgB;QACrE,IAAI,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;QACtE,IAAI,eAAe,EAAE,CAAC;YAClB,eAAe,CAAC,SAAS,GAAG,QAAQ,CAAC;QACzC,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,KAAK,CAAC,qBAAqB,uBAAuB,mBAAmB,CAAC,CAAC;QACnF,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,uBAA+B,EAAE,qBAA6B;QACpF,IAAI,CAAC;YACD,IAAI,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,uBAAuB,CAAC,CAAC;YACtE,IAAI,eAAe,EAAE,CAAC;gBAClB,IAAI,eAAe,GAAG,eAAe,CAAC,qBAAqB,EAAE,CAAC,MAAM,CAAC;gBACrE,uFAAuF;gBACvF,IAAI,CAAC,YAAY,CAAC,uBAAuB,EAAE,qBAAqB,EAAE,eAAe,GAAG,EAAE,CAAC,CAAA;YAC3F,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,yDAAyD,uBAAuB,uBAAuB,qBAAqB,EAAE,EAAE,KAAK,CAAC,CAAC;QACzJ,CAAC;IACL,CAAC;+GAhFQ,aAAa;mHAAb,aAAa,cAFV,MAAM;;4FAET,aAAa;kBAHzB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Injectable } from \"@angular/core\";\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class ScrollService {\r\n\r\n    constructor() { }\r\n\r\n    /**\r\n     * Given a container and the target element to scroll to, we will set the scroll top on\r\n     *  the container to bring the target into view.\r\n     *\r\n     * @param scrollContainerSelector A valid CSS selector string for the scroll container.\r\n     * @param targetElementSelector A valid CSS selector string for the target element.\r\n     * @param topPadding The amount of space to leave above the target\r\n     * to keep it from being pinned to the top of the scrollContainer. Defaults\r\n     * to 32px, the default height of a menu item.\r\n     */\r\n    public scrollToItem(scrollContainerSelector: string, targetElementSelector: string, topPadding = 32): void {\r\n        let scrollContainer = document.querySelector(scrollContainerSelector);\r\n        if (!scrollContainer) {\r\n            return;\r\n        }\r\n        let targetElement = scrollContainer.querySelector(targetElementSelector);\r\n        if (!targetElement) {\r\n            return;\r\n        }\r\n\r\n        let targetRect = targetElement.getBoundingClientRect();\r\n        let containerRect = scrollContainer.getBoundingClientRect();\r\n\r\n        // Only scroll if the target is outside of the view bounds of the container\r\n        if (targetRect.bottom > containerRect.bottom || targetRect.top < containerRect.top) {\r\n            scrollContainer.scrollTop =\r\n                (targetRect.top - containerRect.top) + scrollContainer.scrollTop - topPadding;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Return the value of the scrollTop property for an HTMLElement that matches the selector\r\n     * @param scrollContainerSelector A valid CSS selector\r\n     */\r\n    public getCurrentScrollPosition(scrollContainerSelector: string): number {\r\n        let scrollContainer = document.querySelector(scrollContainerSelector);\r\n        if (scrollContainer) {\r\n            return scrollContainer.scrollTop;\r\n        } else {\r\n            console.error(`Scroll container '${scrollContainerSelector}' does not exist.`);\r\n            return 0;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Set the scrollTop of an HTMLElement that matches the selector to a specific position\r\n     * @param scrollContainerSelector A valid CSS selector\r\n     * @param position\r\n     */\r\n    public scrollToPosition(scrollContainerSelector: string, position: number): void {\r\n        let scrollContainer = document.querySelector(scrollContainerSelector);\r\n        if (scrollContainer) {\r\n            scrollContainer.scrollTop = position;\r\n        } else {\r\n            console.error(`Scroll container '${scrollContainerSelector}' does not exist.`);\r\n        }\r\n    }\r\n\r\n    /**\r\n     *  Given a container and the target element to scroll to, we will set the scroll top on\r\n     *  the container to bring the target into view, with the item in the center of the scroll container.\r\n     *\r\n     * @param scrollContainerSelector A valid CSS selector string for the scroll container.\r\n     * @param targetElementSelector A valid CSS selector string for the target element.\r\n     */\r\n    public scrollItemCentered(scrollContainerSelector: string, targetElementSelector: string) {\r\n        try {\r\n            let scrollContainer = document.querySelector(scrollContainerSelector);\r\n            if (scrollContainer) {\r\n                let containerHeight = scrollContainer.getBoundingClientRect().height;\r\n                // Pad the top with half of the height of the container to put the target in the middle\r\n                this.scrollToItem(scrollContainerSelector, targetElementSelector, containerHeight * .5)\r\n            }\r\n        } catch (error) {\r\n            console.error(`Error scrolling target into view. Container selector: ${scrollContainerSelector}. Target selector:  ${targetElementSelector}`, error);\r\n        }\r\n    }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/core/telemetry-tracker.service.mjs

@@ -1,16 +1,16 @@
-import { Injectable } from '@angular/core';
-import * as i0 from "@angular/core";
-/** Default No-op telemetry implementation */
-export class TelemetryTrackerService {
-    trackPageView(pageName, url, properties) { }
-    trackEvent(name, properties, measurements) { }
-}
-TelemetryTrackerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TelemetryTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-TelemetryTrackerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TelemetryTrackerService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TelemetryTrackerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVsZW1ldHJ5LXRyYWNrZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2xpYi9jb3JlL3RlbGVtZXRyeS10cmFja2VyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLM0MsNkNBQTZDO0FBQzdDLE1BQU0sT0FBTyx1QkFBdUI7SUFDM0IsYUFBYSxDQUFDLFFBQWdCLEVBQUUsR0FBVSxFQUFFLFVBQStDLElBQUksQ0FBQztJQUNoRyxVQUFVLENBQUMsSUFBWSxFQUFFLFVBQW1DLEVBQUUsWUFBb0MsSUFBSSxDQUFDOztvSEFGbkcsdUJBQXVCO3dIQUF2Qix1QkFBdUIsY0FIdEIsTUFBTTsyRkFHUCx1QkFBdUI7a0JBSm5DLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG4vKiogRGVmYXVsdCBOby1vcCB0ZWxlbWV0cnkgaW1wbGVtZW50YXRpb24gKi9cclxuZXhwb3J0IGNsYXNzIFRlbGVtZXRyeVRyYWNrZXJTZXJ2aWNlIHtcclxuICBwdWJsaWMgdHJhY2tQYWdlVmlldyhwYWdlTmFtZTogc3RyaW5nLCB1cmw6c3RyaW5nLCBwcm9wZXJ0aWVzPzogeyBba2V5OiBzdHJpbmddOiBzdHJpbmcgfCBudW1iZXIgfSkgeyB9XHJcbiAgcHVibGljIHRyYWNrRXZlbnQobmFtZTogc3RyaW5nLCBwcm9wZXJ0aWVzPzoge1trZXk6IHN0cmluZ106c3RyaW5nfSwgbWVhc3VyZW1lbnRzPzoge1t2YWw6c3RyaW5nXTpudW1iZXJ9KSB7IH1cclxufVxyXG4iXX0=
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Default No-op telemetry implementation */
+export class TelemetryTrackerService {
+    trackPageView(pageName, url, properties) { }
+    trackEvent(name, properties, measurements) { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryTrackerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVsZW1ldHJ5LXRyYWNrZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2xpYi9jb3JlL3RlbGVtZXRyeS10cmFja2VyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLM0MsNkNBQTZDO0FBQzdDLE1BQU0sT0FBTyx1QkFBdUI7SUFDM0IsYUFBYSxDQUFDLFFBQWdCLEVBQUUsR0FBVSxFQUFFLFVBQStDLElBQUksQ0FBQztJQUNoRyxVQUFVLENBQUMsSUFBWSxFQUFFLFVBQW1DLEVBQUUsWUFBb0MsSUFBSSxDQUFDOytHQUZuRyx1QkFBdUI7bUhBQXZCLHVCQUF1QixjQUh0QixNQUFNOzs0RkFHUCx1QkFBdUI7a0JBSm5DLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG4vKiogRGVmYXVsdCBOby1vcCB0ZWxlbWV0cnkgaW1wbGVtZW50YXRpb24gKi9cclxuZXhwb3J0IGNsYXNzIFRlbGVtZXRyeVRyYWNrZXJTZXJ2aWNlIHtcclxuICBwdWJsaWMgdHJhY2tQYWdlVmlldyhwYWdlTmFtZTogc3RyaW5nLCB1cmw6c3RyaW5nLCBwcm9wZXJ0aWVzPzogeyBba2V5OiBzdHJpbmddOiBzdHJpbmcgfCBudW1iZXIgfSkgeyB9XHJcbiAgcHVibGljIHRyYWNrRXZlbnQobmFtZTogc3RyaW5nLCBwcm9wZXJ0aWVzPzoge1trZXk6IHN0cmluZ106c3RyaW5nfSwgbWVhc3VyZW1lbnRzPzoge1t2YWw6c3RyaW5nXTpudW1iZXJ9KSB7IH1cclxufVxyXG4iXX0=