@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1441

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

@@ -0,0 +1,228 @@
+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',
+        'MMM DD',
+        'DD MMM YY',
+        'DD MMM YYYY',
+        'DD MMMM YYYY',
+        'MMM D, YY',
+        'MMM D, YYYY',
+        'MMM DD, YYYY',
+        'MMMM D, YYYY',
+        'MMMM DD, YYYY',
+        'MMM YY',
+        'MMM YYYY',
+        'MMMM YYYY',
+        'MMM, YY',
+        'MMM, YYYY',
+        'MMMM, 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',\r\n        'MMM DD',\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        'MMM YY',\r\n        'MMM YYYY',\r\n        'MMMM YYYY',\r\n        'MMM, YY',\r\n        'MMM, YYYY',\r\n        'MMMM, 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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAA0C,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAwC,MAAM,iBAAiB,CAAC;AAClK,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;;AAKxC,MAAM,OAAO,YAAY;IACvB;;;;;OAKG;IACI,kBAAkB,CAAC,KAA6B;QACrD,MAAM,MAAM,GAAW,EAAE,CAAC;QAC1B,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YACpC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACnC,MAAM,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,oBAAoB,CAAC,KAA6B;QACvD,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC9C,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACI,oBAAoB,CAAC,KAA6B;QACvD,IAAI,GAAG,GAAU,EAAE,CAAC;QACpB,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YAC7B,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAChB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtB,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,SAAyB;QACjD,IAAI,QAAQ,GAAiB,EAAE,CAAC;QAEhC,MAAM,gBAAgB,GAA0B,SAAS,CAAC,UAAU,CAAC;QACrE,IAAI,gBAAgB,EAAE,CAAC;YACrB,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC1D,MAAM,kBAAkB,GAA0B,gBAAgB,CAAC,UAAU,CAAC;YAC9E,IAAI,kBAAkB,EAAE,CAAC;gBACvB,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,kBAAkB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACI,sBAAsB,CAAC,KAAqB;QACjD,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC;YACxB,KAAK,GAAG,KAAK,CAAC,UAAU,CAAC;QAC3B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,4BAA4B,CAAI,SAA2B,EAAE,gBAA8C,EAAE,MAAc;QACtI,IAAI,aAAa,GAAY,KAAK,CAAC;QACnC,IAAI,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CACnC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,YAAY,eAAe,IAAI,CAAC,YAAY,aAAa,CAAC,CACxE,CAAC,SAAS,CAAC,GAAG,EAAE;YACf,aAAa,GAAG,IAAI,CAAC;QACvB,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,IAAI,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,MAAM,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACjC,CAAC;YACD,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,OAAO,MAAM,CAAC;QAEhB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,YAAY,CAAC,WAAW,EAAE,CAAC;YAC3B,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;+GA1GU,YAAY;mHAAZ,YAAY,cAFX,MAAM;;4FAEP,YAAY;kBAHxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","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/esm2022/lib/core/telemetry-tracker.service.mjs

@@ -0,0 +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) { }
+    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=

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

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./telemetry-tracker.service";
+export class TelemetryService {
+    constructor(telemetryTrackerService) {
+        this.telemetryTrackerService = telemetryTrackerService;
+    }
+    /**
+     * Tracks a Page View / State change
+     *
+     * @param {string} pageName
+     * @param {string} url
+     * @memberof TelemetryService
+     */
+    trackPageView(pageName, url, properties) {
+        this.telemetryTrackerService.trackPageView(pageName, url, properties);
+    }
+    /**
+     * Tracks a generic event
+     *
+     * @param {string} name
+     * @param {{[key: string]:string}} [properties]
+     * @param {{[val:string]:number}} [measurements]
+     * @memberof TelemetryService
+     */
+    trackEvent(name, properties, measurements) {
+        this.telemetryTrackerService.trackEvent(name, properties, measurements);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryService, deps: [{ token: i1.TelemetryTrackerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TelemetryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TelemetryTrackerService }] });
+//# sourceMappingURL=data:application/json;base64,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