updated Angular packages to 14 (and other supporting packages)

.gitignore

@@ -4,4 +4,5 @@ npm-debug.log
 src/*.js
 src/*.js.map
 src/*.d.ts
-/compiled
+/compiled
+dist/

dist/README.md

@@ -0,0 +1,83 @@
+# ngAddToCalendar
+Angular library to add custom events to common calendar applications (Google Calendar, iCalendar, Outlook, Outlook Live and Yahoo).
+
+## Install
+
+```
+npm install @trademe/ng-add-to-calendar
+```
+
+## Use
+
+Import NgAddToCalendarModule into your main app module.
+
+```
+import { NgAddToCalendarModule } from '@trademe/ng-add-to-calendar';
+
+@NgModule({
+  imports: [
+    NgAddToCalendarModule
+  ]
+})
+export class AppModule { }
+```
+
+Import NgAddToCalendarService and ICalendarEvent into your component. 
+Import SafeUrl and DomSanitizer for creating usable urls in your template.
+
+Create a new event.
+
+```
+import { NgAddToCalendarService, ICalendarEvent } from '@trademe/ng-add-to-calendar';
+import { SafeUrl, DomSanitizer } from '@angular/platform-browser';
+
+public googleCalendarEventUrl: SafeUrl;
+public newEvent: ICalendarEvent;
+
+constructor(
+    private _addToCalendarService: NgAddToCalendarService,
+    private _sanitizer: DomSanitizer
+) {
+    this.newEvent = {
+        // Event title
+        title: 'My event title',
+        // Event start date
+        start: new Date('June 15, 2013 19:00'),
+        // Event duration (IN MINUTES)
+        duration: 120,
+        // If an end time is set, this will take precedence over duration (optional)
+        end: new Date('June 15, 2013 23:00'),
+        // Event Address (optional)
+        address: '1 test street, testland',
+        // Event Description (optional)
+        description: 'An awesome event'
+    };
+}
+```
+
+To create line breaks in your event descriptions use '\\n' for a new line, or '\\n\\n' for a hard return.
+
+```
+this.newEvent = {
+    ...
+    description: 'An awesome event.\\nWith line breaks!\\n\\nSweet'
+};
+```
+
+Use the addToCalendarService in your component to create a safeUrl passing the newEvent you created.
+Event configuration is the same for each available calendar type (google, iCalendar, outlook, outlookLive, yahoo).
+
+```
+this.googleCalendarEventUrl = this._sanitizer.bypassSecurityTrustUrl(
+    this._addToCalendarService.getHrefFor(this._addToCalendarService.calendarType.google, this.newEvent)
+);
+```
+
+Use the url in your template.
+
+```
+<a [href]="googleCalendarEventUrl" target="_blank">Google Calendar Event</a>
+```
+
+## License
+MIT

dist/esm2020/generators/base-calendar.generator.mjs

@@ -0,0 +1,46 @@
+export const MS_IN_MINUTES = 60 * 1000;
+export const DATE_POCTUATION_REGEX = /-|:|\.\d+/g;
+export class BaseCalendarGenerator {
+    constructor(event) {
+        this.event = event;
+        this.startTime = this.formatTime(event.start);
+        this.endTime = this.calculateEndTime(event);
+        this.description = this.formatDescription(event.description || '');
+    }
+    get uid() {
+        return (this.s4()
+            + this.s4()
+            + '-' + this.s4()
+            + '-4' + this.s4().substr(0, 3)
+            + '-' + this.s4()
+            + '-' + this.s4()
+            + this.s4()
+            + this.s4()).toLowerCase();
+    }
+    formatDescription(description) {
+        return description.replace(/'/g, '\'');
+    }
+    formatDescriptionForOnlineCalendar(description) {
+        if (description.length) {
+            return description.replace(/\\r/g, '\n').replace(/\\n/g, '\n');
+        }
+        return null;
+    }
+    formatTime(date) {
+        return date.toISOString().replace(DATE_POCTUATION_REGEX, '');
+    }
+    calculateEndTime(event) {
+        if (event.end) {
+            return this.formatTime(event.end);
+        }
+        if (!event.duration) {
+            throw new Error('You have to provide either the duration or end');
+        }
+        return this.formatTime(new Date(event.start.getTime() + (event.duration * MS_IN_MINUTES)));
+    }
+    s4() {
+        // tslint:disable-next-line
+        return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

dist/esm2020/generators/google-calendar.generator.mjs

@@ -0,0 +1,16 @@
+import { BaseCalendarGenerator } from './base-calendar.generator';
+export const GOOGLE_URL = 'https://www.google.com/calendar/render?action=TEMPLATE';
+export const DATE_POCTUATION_REGEX = /-|:|\.\d+/g;
+export class GoogleCalendarGenerator extends BaseCalendarGenerator {
+    constructor(event) {
+        super(event);
+        this.event = event;
+    }
+    get href() {
+        const chunk = encodeURI(`${GOOGLE_URL}&dates=${(this.startTime || '')}/${(this.endTime || '')}&location=${(this.event.address || '')}&sprop=${(this.event.url || '')}`);
+        return chunk
+            + `&text=${encodeURIComponent(this.event.title || '')}`
+            + `&details=${encodeURIComponent(this.formatDescriptionForOnlineCalendar(this.event.description || '') || '')}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ29vZ2xlLWNhbGVuZGFyLmdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9nZW5lcmF0b3JzL2dvb2dsZS1jYWxlbmRhci5nZW5lcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFbEUsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLHdEQUF3RCxDQUFDO0FBQ25GLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLFlBQVksQ0FBQztBQUVsRCxNQUFNLE9BQU8sdUJBQXdCLFNBQVEscUJBQXFCO0lBRTlELFlBQXNCLEtBQXFCO1FBQ3ZDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztRQURLLFVBQUssR0FBTCxLQUFLLENBQWdCO0lBRTNDLENBQUM7SUFFRCxJQUFXLElBQUk7UUFDWCxNQUFNLEtBQUssR0FBRyxTQUFTLENBQ25CLEdBQUcsVUFBVSxVQUFVLENBQUMsSUFBSSxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxJQUFJLEVBQUUsQ0FBQyxFQUFFLENBQ2pKLENBQUM7UUFFRixPQUFPLEtBQUs7Y0FDTixTQUFTLGtCQUFrQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQyxFQUFFO2NBQ3JELFlBQVksa0JBQWtCLENBQUMsSUFBSSxDQUFDLGtDQUFrQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxJQUFJLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxFQUFFLENBQUM7SUFDeEgsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSUNhbGVuZGFyRXZlbnQgfSBmcm9tICcuLi9tb2RlbC9jYWxlbmRhci1ldmVudC5tb2RlbCc7XHJcbmltcG9ydCB7IEJhc2VDYWxlbmRhckdlbmVyYXRvciB9IGZyb20gJy4vYmFzZS1jYWxlbmRhci5nZW5lcmF0b3InO1xyXG5cclxuZXhwb3J0IGNvbnN0IEdPT0dMRV9VUkwgPSAnaHR0cHM6Ly93d3cuZ29vZ2xlLmNvbS9jYWxlbmRhci9yZW5kZXI/YWN0aW9uPVRFTVBMQVRFJztcclxuZXhwb3J0IGNvbnN0IERBVEVfUE9DVFVBVElPTl9SRUdFWCA9IC8tfDp8XFwuXFxkKy9nO1xyXG5cclxuZXhwb3J0IGNsYXNzIEdvb2dsZUNhbGVuZGFyR2VuZXJhdG9yIGV4dGVuZHMgQmFzZUNhbGVuZGFyR2VuZXJhdG9yIHtcclxuXHJcbiAgICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgZXZlbnQ6IElDYWxlbmRhckV2ZW50KSB7XHJcbiAgICAgICAgc3VwZXIoZXZlbnQpO1xyXG4gICAgfVxyXG5cclxuICAgIHB1YmxpYyBnZXQgaHJlZigpOiBzdHJpbmcge1xyXG4gICAgICAgIGNvbnN0IGNodW5rID0gZW5jb2RlVVJJKFxyXG4gICAgICAgICAgICBgJHtHT09HTEVfVVJMfSZkYXRlcz0keyh0aGlzLnN0YXJ0VGltZSB8fCAnJyl9LyR7KHRoaXMuZW5kVGltZSB8fCAnJyl9JmxvY2F0aW9uPSR7KHRoaXMuZXZlbnQuYWRkcmVzcyB8fCAnJyl9JnNwcm9wPSR7KHRoaXMuZXZlbnQudXJsIHx8ICcnKX1gLFxyXG4gICAgICAgICk7XHJcblxyXG4gICAgICAgIHJldHVybiBjaHVua1xyXG4gICAgICAgICAgICArIGAmdGV4dD0ke2VuY29kZVVSSUNvbXBvbmVudCh0aGlzLmV2ZW50LnRpdGxlIHx8ICcnKX1gXHJcbiAgICAgICAgICAgICsgYCZkZXRhaWxzPSR7ZW5jb2RlVVJJQ29tcG9uZW50KHRoaXMuZm9ybWF0RGVzY3JpcHRpb25Gb3JPbmxpbmVDYWxlbmRhcih0aGlzLmV2ZW50LmRlc2NyaXB0aW9uIHx8ICcnKSB8fCAnJyl9YDtcclxuICAgIH1cclxufVxyXG4iXX0=

dist/esm2020/generators/ics-calendar.generator.mjs

@@ -0,0 +1,33 @@
+import { BaseCalendarGenerator } from './base-calendar.generator';
+export class IcsCalendarGenerator extends BaseCalendarGenerator {
+    constructor(event) {
+        super(event);
+        this.event = event;
+    }
+    get href() {
+        return encodeURI('data:text/calendar;charset=utf8,' + [
+            'BEGIN:VCALENDAR',
+            'PRODID:-//Destination Search//ical4j 1.0//EN',
+            'VERSION:2.0',
+            'CALSCALE:GREGORIAN',
+            'X-MS-OLK-FORCEINSPECTOROPEN:true',
+            'METHOD:PUBLISH',
+            'BEGIN:VEVENT',
+            `URL:${this.event.url || ''}`,
+            `DTSTART:${(this.startTime || '')}`,
+            `DTEND:${(this.endTime || '')}`,
+            `SUMMARY:${(this.event.title || '')}`,
+            `DESCRIPTION:${(this.event.description || '')}`,
+            `LOCATION:${(this.event.address || '')}`,
+            'SEQUENCE:0',
+            `DTSTAMP:${this.dtStamp}`,
+            `UID:${this.uid}`,
+            'END:VEVENT',
+            'END:VCALENDAR'
+        ].join('\n'));
+    }
+    get dtStamp() {
+        return this.formatTime(new Date());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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