@ieeesa-npm/dashboard 0.0.0-stage → 0.0.2

package/esm2022/lib/services/user-permissions.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Permission identifiers (by name) that gate the dashboard attendance actions.
+ * Mirrors the permission-type pattern used by the `events-and-meetings` and
+ * `groups` user-permissions services.
+ */
+/* eslint-disable no-unused-vars */
+export var DashboardPermissionType;
+(function (DashboardPermissionType) {
+    DashboardPermissionType["LOG_ATTENDANCE"] = "Log Attendance";
+    DashboardPermissionType["LEAVE_MEETING"] = "Leave Meeting";
+})(DashboardPermissionType || (DashboardPermissionType = {}));
+/* eslint-enable no-unused-vars */
+export class UserPermissionsService {
+    /**
+     * Returns access provision for the passed action/feature based on whether the signed in user has appropriate permission.
+     * @param {DashboardPermissionType} permission
+     * @param {UserPermission[]} userPermissions
+     * @return {boolean}
+     * @memberof UserPermissionsService
+     */
+    validateAccessPermission(permission, userPermissions) {
+        const isPermitted = userPermissions?.length > 0
+            ? userPermissions?.some(({ permissionName }) => permissionName === permission)
+            : false;
+        return isPermitted;
+    }
+    /**
+     * Maps the host-supplied user permissions to the attendance-action permissions consumed by the dashboard rows.
+     * @param {UserPermission[]} userPermissions
+     * @return {AttendanceActionPermissions}
+     * @memberof UserPermissionsService
+     */
+    mapToAttendanceActionPermissions(userPermissions) {
+        return {
+            canLogAttendance: this.validateAccessPermission(DashboardPermissionType.LOG_ATTENDANCE, userPermissions),
+            canLeaveMeeting: this.validateAccessPermission(DashboardPermissionType.LEAVE_MEETING, userPermissions),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserPermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserPermissionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserPermissionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/attendance-action.util.mjs

@@ -0,0 +1,53 @@
+/**
+ * Pure helpers for the per-meeting attendance action state machine. No Angular /
+ * service dependencies so they are trivially testable (property-tested as
+ * Property 1) and reusable by `MeetingAttendanceRowComponent`.
+ *
+ * The handler is the single source of truth for what a meeting row's action
+ * button should emit when activated. The displayed `AttendanceState` only
+ * advances on a successful resolution (handled by the service reducers), so this
+ * function is a pure mapping from the current inputs to the action to emit.
+ */
+import { AttendanceState } from '../models/attendance-state.model';
+/* eslint-disable no-unused-vars */
+/**
+ * The action a meeting row's action button should emit when activated.
+ * `NONE` means the activation is non-actionable (empty id or in-flight) and the
+ * row must emit no `logAttendance` / `leaveMeeting` / navigation event.
+ */
+export var AttendanceAction;
+(function (AttendanceAction) {
+    AttendanceAction["LOG_ATTENDANCE"] = "LOG_ATTENDANCE";
+    AttendanceAction["LEAVE_MEETING"] = "LEAVE_MEETING";
+    AttendanceAction["NONE"] = "NONE";
+})(AttendanceAction || (AttendanceAction = {}));
+/* eslint-enable no-unused-vars */
+/**
+ * Resolves the attendance action to emit for a meeting row, following the
+ * attendance action state machine (see design: Attendance Action State Machine).
+ *
+ * Behavior:
+ * - Returns `NONE` when `meetingId` is empty or undefined (non-actionable row).
+ * - Returns `NONE` while the row is in-flight (re-entrancy guard — no further
+ *   event is emitted until the current action resolves).
+ * - Returns `LEAVE_MEETING` when the state is `CURRENTLY_ATTENDING`.
+ * - Returns `LOG_ATTENDANCE` when the state is `NOT_ATTENDING` or undefined.
+ *
+ * @param {AttendanceState | undefined} attendanceState The row's current attendance state.
+ * @param {boolean} isInFlight Whether an attendance action for this row is awaiting resolution.
+ * @param {string | undefined} meetingId The row's meeting identifier.
+ * @return {AttendanceAction} The action to emit, or `NONE` when non-actionable.
+ */
+export function resolveAttendanceAction(attendanceState, isInFlight, meetingId) {
+    if (!meetingId) {
+        return AttendanceAction.NONE;
+    }
+    if (isInFlight) {
+        return AttendanceAction.NONE;
+    }
+    if (attendanceState === AttendanceState.CURRENTLY_ATTENDING) {
+        return AttendanceAction.LEAVE_MEETING;
+    }
+    return AttendanceAction.LOG_ATTENDANCE;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZW5kYW5jZS1hY3Rpb24udXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rhc2hib2FyZC9zcmMvbGliL3V0aWxzL2F0dGVuZGFuY2UtYWN0aW9uLnV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7OztHQVNHO0FBQ0gsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRW5FLG1DQUFtQztBQUNuQzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFOLElBQVksZ0JBSVg7QUFKRCxXQUFZLGdCQUFnQjtJQUMxQixxREFBaUMsQ0FBQTtJQUNqQyxtREFBK0IsQ0FBQTtJQUMvQixpQ0FBYSxDQUFBO0FBQ2YsQ0FBQyxFQUpXLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFJM0I7QUFDRCxrQ0FBa0M7QUFFbEM7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUNyQyxlQUE0QyxFQUM1QyxVQUFtQixFQUNuQixTQUE2QjtJQUU3QixJQUFJLENBQUMsU0FBUyxFQUFFO1FBQ2QsT0FBTyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUM7S0FDOUI7SUFFRCxJQUFJLFVBQVUsRUFBRTtRQUNkLE9BQU8sZ0JBQWdCLENBQUMsSUFBSSxDQUFDO0tBQzlCO0lBRUQsSUFBSSxlQUFlLEtBQUssZUFBZSxDQUFDLG1CQUFtQixFQUFFO1FBQzNELE9BQU8sZ0JBQWdCLENBQUMsYUFBYSxDQUFDO0tBQ3ZDO0lBRUQsT0FBTyxnQkFBZ0IsQ0FBQyxjQUFjLENBQUM7QUFDekMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBQdXJlIGhlbHBlcnMgZm9yIHRoZSBwZXItbWVldGluZyBhdHRlbmRhbmNlIGFjdGlvbiBzdGF0ZSBtYWNoaW5lLiBObyBBbmd1bGFyIC9cclxuICogc2VydmljZSBkZXBlbmRlbmNpZXMgc28gdGhleSBhcmUgdHJpdmlhbGx5IHRlc3RhYmxlIChwcm9wZXJ0eS10ZXN0ZWQgYXNcclxuICogUHJvcGVydHkgMSkgYW5kIHJldXNhYmxlIGJ5IGBNZWV0aW5nQXR0ZW5kYW5jZVJvd0NvbXBvbmVudGAuXHJcbiAqXHJcbiAqIFRoZSBoYW5kbGVyIGlzIHRoZSBzaW5nbGUgc291cmNlIG9mIHRydXRoIGZvciB3aGF0IGEgbWVldGluZyByb3cncyBhY3Rpb25cclxuICogYnV0dG9uIHNob3VsZCBlbWl0IHdoZW4gYWN0aXZhdGVkLiBUaGUgZGlzcGxheWVkIGBBdHRlbmRhbmNlU3RhdGVgIG9ubHlcclxuICogYWR2YW5jZXMgb24gYSBzdWNjZXNzZnVsIHJlc29sdXRpb24gKGhhbmRsZWQgYnkgdGhlIHNlcnZpY2UgcmVkdWNlcnMpLCBzbyB0aGlzXHJcbiAqIGZ1bmN0aW9uIGlzIGEgcHVyZSBtYXBwaW5nIGZyb20gdGhlIGN1cnJlbnQgaW5wdXRzIHRvIHRoZSBhY3Rpb24gdG8gZW1pdC5cclxuICovXHJcbmltcG9ydCB7IEF0dGVuZGFuY2VTdGF0ZSB9IGZyb20gJy4uL21vZGVscy9hdHRlbmRhbmNlLXN0YXRlLm1vZGVsJztcclxuXHJcbi8qIGVzbGludC1kaXNhYmxlIG5vLXVudXNlZC12YXJzICovXHJcbi8qKlxyXG4gKiBUaGUgYWN0aW9uIGEgbWVldGluZyByb3cncyBhY3Rpb24gYnV0dG9uIHNob3VsZCBlbWl0IHdoZW4gYWN0aXZhdGVkLlxyXG4gKiBgTk9ORWAgbWVhbnMgdGhlIGFjdGl2YXRpb24gaXMgbm9uLWFjdGlvbmFibGUgKGVtcHR5IGlkIG9yIGluLWZsaWdodCkgYW5kIHRoZVxyXG4gKiByb3cgbXVzdCBlbWl0IG5vIGBsb2dBdHRlbmRhbmNlYCAvIGBsZWF2ZU1lZXRpbmdgIC8gbmF2aWdhdGlvbiBldmVudC5cclxuICovXHJcbmV4cG9ydCBlbnVtIEF0dGVuZGFuY2VBY3Rpb24ge1xyXG4gIExPR19BVFRFTkRBTkNFID0gJ0xPR19BVFRFTkRBTkNFJyxcclxuICBMRUFWRV9NRUVUSU5HID0gJ0xFQVZFX01FRVRJTkcnLFxyXG4gIE5PTkUgPSAnTk9ORScsXHJcbn1cclxuLyogZXNsaW50LWVuYWJsZSBuby11bnVzZWQtdmFycyAqL1xyXG5cclxuLyoqXHJcbiAqIFJlc29sdmVzIHRoZSBhdHRlbmRhbmNlIGFjdGlvbiB0byBlbWl0IGZvciBhIG1lZXRpbmcgcm93LCBmb2xsb3dpbmcgdGhlXHJcbiAqIGF0dGVuZGFuY2UgYWN0aW9uIHN0YXRlIG1hY2hpbmUgKHNlZSBkZXNpZ246IEF0dGVuZGFuY2UgQWN0aW9uIFN0YXRlIE1hY2hpbmUpLlxyXG4gKlxyXG4gKiBCZWhhdmlvcjpcclxuICogLSBSZXR1cm5zIGBOT05FYCB3aGVuIGBtZWV0aW5nSWRgIGlzIGVtcHR5IG9yIHVuZGVmaW5lZCAobm9uLWFjdGlvbmFibGUgcm93KS5cclxuICogLSBSZXR1cm5zIGBOT05FYCB3aGlsZSB0aGUgcm93IGlzIGluLWZsaWdodCAocmUtZW50cmFuY3kgZ3VhcmQg4oCUIG5vIGZ1cnRoZXJcclxuICogICBldmVudCBpcyBlbWl0dGVkIHVudGlsIHRoZSBjdXJyZW50IGFjdGlvbiByZXNvbHZlcykuXHJcbiAqIC0gUmV0dXJucyBgTEVBVkVfTUVFVElOR2Agd2hlbiB0aGUgc3RhdGUgaXMgYENVUlJFTlRMWV9BVFRFTkRJTkdgLlxyXG4gKiAtIFJldHVybnMgYExPR19BVFRFTkRBTkNFYCB3aGVuIHRoZSBzdGF0ZSBpcyBgTk9UX0FUVEVORElOR2Agb3IgdW5kZWZpbmVkLlxyXG4gKlxyXG4gKiBAcGFyYW0ge0F0dGVuZGFuY2VTdGF0ZSB8IHVuZGVmaW5lZH0gYXR0ZW5kYW5jZVN0YXRlIFRoZSByb3cncyBjdXJyZW50IGF0dGVuZGFuY2Ugc3RhdGUuXHJcbiAqIEBwYXJhbSB7Ym9vbGVhbn0gaXNJbkZsaWdodCBXaGV0aGVyIGFuIGF0dGVuZGFuY2UgYWN0aW9uIGZvciB0aGlzIHJvdyBpcyBhd2FpdGluZyByZXNvbHV0aW9uLlxyXG4gKiBAcGFyYW0ge3N0cmluZyB8IHVuZGVmaW5lZH0gbWVldGluZ0lkIFRoZSByb3cncyBtZWV0aW5nIGlkZW50aWZpZXIuXHJcbiAqIEByZXR1cm4ge0F0dGVuZGFuY2VBY3Rpb259IFRoZSBhY3Rpb24gdG8gZW1pdCwgb3IgYE5PTkVgIHdoZW4gbm9uLWFjdGlvbmFibGUuXHJcbiAqL1xyXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZUF0dGVuZGFuY2VBY3Rpb24oXHJcbiAgYXR0ZW5kYW5jZVN0YXRlOiBBdHRlbmRhbmNlU3RhdGUgfCB1bmRlZmluZWQsXHJcbiAgaXNJbkZsaWdodDogYm9vbGVhbixcclxuICBtZWV0aW5nSWQ6IHN0cmluZyB8IHVuZGVmaW5lZFxyXG4pOiBBdHRlbmRhbmNlQWN0aW9uIHtcclxuICBpZiAoIW1lZXRpbmdJZCkge1xyXG4gICAgcmV0dXJuIEF0dGVuZGFuY2VBY3Rpb24uTk9ORTtcclxuICB9XHJcblxyXG4gIGlmIChpc0luRmxpZ2h0KSB7XHJcbiAgICByZXR1cm4gQXR0ZW5kYW5jZUFjdGlvbi5OT05FO1xyXG4gIH1cclxuXHJcbiAgaWYgKGF0dGVuZGFuY2VTdGF0ZSA9PT0gQXR0ZW5kYW5jZVN0YXRlLkNVUlJFTlRMWV9BVFRFTkRJTkcpIHtcclxuICAgIHJldHVybiBBdHRlbmRhbmNlQWN0aW9uLkxFQVZFX01FRVRJTkc7XHJcbiAgfVxyXG5cclxuICByZXR1cm4gQXR0ZW5kYW5jZUFjdGlvbi5MT0dfQVRURU5EQU5DRTtcclxufVxyXG4iXX0=

package/esm2022/lib/utils/date-format.util.mjs

@@ -0,0 +1,110 @@
+/**
+ * Pure luxon date/time formatting helpers for the dashboard library.
+ *
+ * The real "events & meetings" backend returns date-times as ISO-8601 strings
+ * (e.g. "2026-01-01T00:00:00") together with a display timezone string
+ * (e.g. "(UTC-04:00) America/New_York"). These helpers parse the ISO value and
+ * render it in the item's own zone (never moment). A numeric epoch-milliseconds
+ * value is also accepted for backward compatibility with fixtures/tests. All
+ * helpers fall back gracefully to an empty string when the value is missing or
+ * unparseable.
+ */
+import { DateTime } from 'luxon';
+/**
+ * Extracts a luxon-usable IANA zone from a backend timezone string such as
+ * "(UTC-04:00) America/New_York" or "America/New_York". Returns `undefined`
+ * when no usable zone can be derived so luxon falls back to the local zone.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string | undefined} The IANA zone id, or undefined.
+ */
+export function extractIanaZone(timezone) {
+    if (!timezone) {
+        return undefined;
+    }
+    // Strip a leading "(UTC±HH:MM) " offset prefix when present.
+    const closingParen = timezone.indexOf(') ');
+    const zone = closingParen > -1
+        ? timezone.slice(closingParen + 2).trim()
+        : timezone.trim();
+    return zone.length > 0 ? zone : undefined;
+}
+/**
+ * Parses a backend date-time value — either an ISO-8601 string
+ * (e.g. "2026-01-01T00:00:00") or an epoch-milliseconds number — into a luxon
+ * {@link DateTime} in the supplied timezone. The ISO value is treated as a wall
+ * time in the item's zone so the rendered time matches the backend's intent.
+ * Returns an invalid DateTime when the value is missing/unparseable.
+ * @param {string | number | undefined | null} value - The ISO string or epoch ms.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {DateTime} The parsed luxon DateTime (may be invalid).
+ */
+export function parseBackendDateTime(value, timezone) {
+    const zone = extractIanaZone(timezone);
+    if (value === undefined || value === null || value === '') {
+        return DateTime.invalid('empty');
+    }
+    if (typeof value === 'number') {
+        return zone
+            ? DateTime.fromMillis(value, { zone })
+            : DateTime.fromMillis(value);
+    }
+    // ISO string: parse as a wall time in the item's zone when known.
+    const isoOptions = zone ? { zone } : {};
+    const parsed = DateTime.fromISO(value, isoOptions);
+    return parsed.isValid ? parsed : DateTime.fromISO(value);
+}
+/**
+ * Formats a backend date-time value (ISO string or epoch ms) with luxon using
+ * the supplied format token, honouring the supplied timezone. Returns an empty
+ * string when the value is missing or invalid.
+ * @param {string | number | undefined | null} value - The ISO string or epoch ms.
+ * @param {string} format - The luxon `toFormat` token.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string} The formatted value, or an empty string.
+ */
+export function formatBackendDateTime(value, format, timezone) {
+    const parsed = parseBackendDateTime(value, timezone);
+    return parsed.isValid ? parsed.toFormat(format) : '';
+}
+/**
+ * Backward-compatible alias kept for existing callers. Accepts ISO strings or
+ * epoch ms and formats them in the item's zone.
+ * @param {string | number | undefined | null} value - The ISO string or epoch ms.
+ * @param {string} format - The luxon `toFormat` token.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string} The formatted value, or an empty string.
+ */
+export function formatEpoch(value, format, timezone) {
+    return formatBackendDateTime(value, format, timezone);
+}
+/**
+ * Computes a human "Day X of Y" indicator for a multi-day event from its start
+ * and end date-times, relative to "now". Returns an empty string when the dates
+ * are missing/invalid or the event spans a single day.
+ * @param {string | number | undefined | null} start - Event start (ISO or epoch ms).
+ * @param {string | number | undefined | null} end - Event end (ISO or epoch ms).
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string} The "Day X of Y" label, or an empty string.
+ */
+export function computeDayIndicator(start, end, timezone) {
+    const zone = extractIanaZone(timezone);
+    const startDt = parseBackendDateTime(start, timezone);
+    const endDt = parseBackendDateTime(end, timezone);
+    if (!startDt.isValid || !endDt.isValid) {
+        return '';
+    }
+    const startDay = startDt.startOf('day');
+    const endDay = endDt.startOf('day');
+    const totalDays = Math.floor(endDay.diff(startDay, 'days').days) + 1;
+    // Only meaningful for short, multi-day events (a conference-week style span).
+    // Very long spans (e.g. a year-long series) are not shown as "Day X of Y".
+    const MAX_DAY_INDICATOR_SPAN = 31;
+    if (totalDays <= 1 || totalDays > MAX_DAY_INDICATOR_SPAN) {
+        return '';
+    }
+    const now = (zone ? DateTime.now().setZone(zone) : DateTime.now()).startOf('day');
+    const clampedNow = now < startDay ? startDay : now > endDay ? endDay : now;
+    const currentDay = Math.floor(clampedNow.diff(startDay, 'days').days) + 1;
+    return `Day ${currentDay} of ${totalDays}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-format.util.js","sourceRoot":"","sources":["../../../../../projects/dashboard/src/lib/utils/date-format.util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,QAA4B;IAE5B,IAAI,CAAC,QAAQ,EAAE;QACb,OAAO,SAAS,CAAC;KAClB;IACD,6DAA6D;IAC7D,MAAM,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,MAAM,IAAI,GACR,YAAY,GAAG,CAAC,CAAC;QACf,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE;QACzC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACtB,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAC5C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAyC,EACzC,QAAiB;IAEjB,MAAM,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE;QACzD,OAAO,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KAClC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;QAC7B,OAAO,IAAI;YACT,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC;YACtC,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;KAChC;IACD,kEAAkE;IAClE,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACxC,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IACnD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAyC,EACzC,MAAc,EACd,QAAiB;IAEjB,MAAM,MAAM,GAAG,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACrD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACvD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,KAAyC,EACzC,MAAc,EACd,QAAiB;IAEjB,OAAO,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAyC,EACzC,GAAuC,EACvC,QAAiB;IAEjB,MAAM,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IACvC,MAAM,OAAO,GAAG,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACtD,MAAM,KAAK,GAAG,oBAAoB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;QACtC,OAAO,EAAE,CAAC;KACX;IACD,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrE,8EAA8E;IAC9E,2EAA2E;IAC3E,MAAM,sBAAsB,GAAG,EAAE,CAAC;IAClC,IAAI,SAAS,IAAI,CAAC,IAAI,SAAS,GAAG,sBAAsB,EAAE;QACxD,OAAO,EAAE,CAAC;KACX;IACD,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,OAAO,CACxE,KAAK,CACN,CAAC;IACF,MAAM,UAAU,GAAG,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;IAC3E,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1E,OAAO,OAAO,UAAU,OAAO,SAAS,EAAE,CAAC;AAC7C,CAAC","sourcesContent":["/**\r\n * Pure luxon date/time formatting helpers for the dashboard library.\r\n *\r\n * The real \"events & meetings\" backend returns date-times as ISO-8601 strings\r\n * (e.g. \"2026-01-01T00:00:00\") together with a display timezone string\r\n * (e.g. \"(UTC-04:00) America/New_York\"). These helpers parse the ISO value and\r\n * render it in the item's own zone (never moment). A numeric epoch-milliseconds\r\n * value is also accepted for backward compatibility with fixtures/tests. All\r\n * helpers fall back gracefully to an empty string when the value is missing or\r\n * unparseable.\r\n */\r\nimport { DateTime } from 'luxon';\r\n\r\n/**\r\n * Extracts a luxon-usable IANA zone from a backend timezone string such as\r\n * \"(UTC-04:00) America/New_York\" or \"America/New_York\". Returns `undefined`\r\n * when no usable zone can be derived so luxon falls back to the local zone.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string | undefined} The IANA zone id, or undefined.\r\n */\r\nexport function extractIanaZone(\r\n  timezone: string | undefined\r\n): string | undefined {\r\n  if (!timezone) {\r\n    return undefined;\r\n  }\r\n  // Strip a leading \"(UTC±HH:MM) \" offset prefix when present.\r\n  const closingParen = timezone.indexOf(') ');\r\n  const zone =\r\n    closingParen > -1\r\n      ? timezone.slice(closingParen + 2).trim()\r\n      : timezone.trim();\r\n  return zone.length > 0 ? zone : undefined;\r\n}\r\n\r\n/**\r\n * Parses a backend date-time value — either an ISO-8601 string\r\n * (e.g. \"2026-01-01T00:00:00\") or an epoch-milliseconds number — into a luxon\r\n * {@link DateTime} in the supplied timezone. The ISO value is treated as a wall\r\n * time in the item's zone so the rendered time matches the backend's intent.\r\n * Returns an invalid DateTime when the value is missing/unparseable.\r\n * @param {string | number | undefined | null} value - The ISO string or epoch ms.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {DateTime} The parsed luxon DateTime (may be invalid).\r\n */\r\nexport function parseBackendDateTime(\r\n  value: string | number | undefined | null,\r\n  timezone?: string\r\n): DateTime {\r\n  const zone = extractIanaZone(timezone);\r\n  if (value === undefined || value === null || value === '') {\r\n    return DateTime.invalid('empty');\r\n  }\r\n  if (typeof value === 'number') {\r\n    return zone\r\n      ? DateTime.fromMillis(value, { zone })\r\n      : DateTime.fromMillis(value);\r\n  }\r\n  // ISO string: parse as a wall time in the item's zone when known.\r\n  const isoOptions = zone ? { zone } : {};\r\n  const parsed = DateTime.fromISO(value, isoOptions);\r\n  return parsed.isValid ? parsed : DateTime.fromISO(value);\r\n}\r\n\r\n/**\r\n * Formats a backend date-time value (ISO string or epoch ms) with luxon using\r\n * the supplied format token, honouring the supplied timezone. Returns an empty\r\n * string when the value is missing or invalid.\r\n * @param {string | number | undefined | null} value - The ISO string or epoch ms.\r\n * @param {string} format - The luxon `toFormat` token.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string} The formatted value, or an empty string.\r\n */\r\nexport function formatBackendDateTime(\r\n  value: string | number | undefined | null,\r\n  format: string,\r\n  timezone?: string\r\n): string {\r\n  const parsed = parseBackendDateTime(value, timezone);\r\n  return parsed.isValid ? parsed.toFormat(format) : '';\r\n}\r\n\r\n/**\r\n * Backward-compatible alias kept for existing callers. Accepts ISO strings or\r\n * epoch ms and formats them in the item's zone.\r\n * @param {string | number | undefined | null} value - The ISO string or epoch ms.\r\n * @param {string} format - The luxon `toFormat` token.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string} The formatted value, or an empty string.\r\n */\r\nexport function formatEpoch(\r\n  value: string | number | undefined | null,\r\n  format: string,\r\n  timezone?: string\r\n): string {\r\n  return formatBackendDateTime(value, format, timezone);\r\n}\r\n\r\n/**\r\n * Computes a human \"Day X of Y\" indicator for a multi-day event from its start\r\n * and end date-times, relative to \"now\". Returns an empty string when the dates\r\n * are missing/invalid or the event spans a single day.\r\n * @param {string | number | undefined | null} start - Event start (ISO or epoch ms).\r\n * @param {string | number | undefined | null} end - Event end (ISO or epoch ms).\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string} The \"Day X of Y\" label, or an empty string.\r\n */\r\nexport function computeDayIndicator(\r\n  start: string | number | undefined | null,\r\n  end: string | number | undefined | null,\r\n  timezone?: string\r\n): string {\r\n  const zone = extractIanaZone(timezone);\r\n  const startDt = parseBackendDateTime(start, timezone);\r\n  const endDt = parseBackendDateTime(end, timezone);\r\n  if (!startDt.isValid || !endDt.isValid) {\r\n    return '';\r\n  }\r\n  const startDay = startDt.startOf('day');\r\n  const endDay = endDt.startOf('day');\r\n  const totalDays = Math.floor(endDay.diff(startDay, 'days').days) + 1;\r\n  // Only meaningful for short, multi-day events (a conference-week style span).\r\n  // Very long spans (e.g. a year-long series) are not shown as \"Day X of Y\".\r\n  const MAX_DAY_INDICATOR_SPAN = 31;\r\n  if (totalDays <= 1 || totalDays > MAX_DAY_INDICATOR_SPAN) {\r\n    return '';\r\n  }\r\n  const now = (zone ? DateTime.now().setZone(zone) : DateTime.now()).startOf(\r\n    'day'\r\n  );\r\n  const clampedNow = now < startDay ? startDay : now > endDay ? endDay : now;\r\n  const currentDay = Math.floor(clampedNow.diff(startDay, 'days').days) + 1;\r\n  return `Day ${currentDay} of ${totalDays}`;\r\n}\r\n"]}

package/esm2022/lib/utils/event-meeting-mapper.util.mjs

@@ -0,0 +1,96 @@
+import { UpcomingItemKind, } from '../models/upcoming-event.model';
+import { computeDayIndicator } from './date-format.util';
+/**
+ * Determines whether a raw list item is an EVENT (owns child meetings) or a
+ * STANDALONE_MEETING. An item is an EVENT when the backend flags it with
+ * `isMeetingEvent === true` or `hasChildren === true`.
+ * @param {EventMeetingListItem} item - The raw list item.
+ * @return {UpcomingItemKind} The resolved render kind.
+ */
+export function resolveItemKind(item) {
+    const isEvent = item?.isMeetingEvent === true || item?.hasChildren === true;
+    return isEvent ? UpcomingItemKind.EVENT : UpcomingItemKind.STANDALONE_MEETING;
+}
+/**
+ * Maps a raw backend list item to the {@link UpcomingEvent} view model. EVENT
+ * rows start with an empty `meetings` array (child meetings are lazily loaded on
+ * expand); STANDALONE_MEETING rows carry their own group/location fields.
+ * @param {EventMeetingListItem} item - The raw list item.
+ * @return {UpcomingEvent} The mapped view model.
+ */
+export function mapListItemToUpcomingEvent(item) {
+    const kind = resolveItemKind(item);
+    const timezone = item?.timeZone ?? '';
+    const dayIndicator = item?.dayIndicator ??
+        (kind === UpcomingItemKind.EVENT
+            ? computeDayIndicator(item?.startDateTime, item?.endDateTime, timezone)
+            : '');
+    return {
+        eventId: item?.id ?? item?.eventId ?? item?.meetingId ?? '',
+        kind,
+        // The list endpoint uses `name`; fall back to `meetingTitle` for meeting rows.
+        title: item?.name ?? item?.meetingTitle ?? '',
+        // The list screen copies status into contentUnderLink; accept either.
+        status: item?.status ?? item?.contentUnderLink ?? '',
+        dayIndicator,
+        meetingCount: kind === UpcomingItemKind.STANDALONE_MEETING
+            ? 1
+            : item?.meetingCount ?? 0,
+        openForAttendanceCount: item?.openForAttendanceCount ?? 0,
+        startDateTime: item?.startDateTime,
+        endDateTime: item?.endDateTime,
+        timezone,
+        groupOrCommittee: item?.groupName ?? item?.groupAcronym ?? '',
+        roomOrLocation: item?.meetingLocation ?? item?.room ?? '',
+        isMemberOfGroup: item?.isMemberOfGroup ?? false,
+        meetings: [],
+    };
+}
+/**
+ * Maps a raw backend list of events & meetings into the dashboard view models,
+ * enforcing that STANDALONE_MEETING rows always sort LAST while preserving the
+ * backend's within-group ordering for each partition (stable sort).
+ * @param {EventMeetingListItem[]} items - The raw list items.
+ * @return {UpcomingEvent[]} The mapped, standalone-last ordered view models.
+ */
+export function mapEventMeetingList(items) {
+    const mapped = (items ?? []).map((item) => mapListItemToUpcomingEvent(item));
+    const events = mapped.filter((entry) => entry.kind === UpcomingItemKind.EVENT);
+    const standalone = mapped.filter((entry) => entry.kind === UpcomingItemKind.STANDALONE_MEETING);
+    return [...events, ...standalone];
+}
+/**
+ * Maps a raw backend child-meeting detail item to the {@link MeetingRow} view
+ * model used by the event block's expanded meeting list.
+ * @param {EventMeetingDetailItem} item - The raw child-meeting item.
+ * @return {MeetingRow} The mapped meeting row.
+ */
+export function mapDetailItemToMeetingRow(item) {
+    const status = item?.status ?? '';
+    // A meeting is "open for attendance" while it is In Progress. The
+    // meetingsDetails endpoint has no dedicated flag, so derive it from status
+    // (honouring an explicit backend flag when one is provided).
+    const isOpenForAttendance = item?.isOpenForAttendance ?? status.trim().toLowerCase() === 'in progress';
+    return {
+        meetingId: item?.meetingId ?? '',
+        meetingName: item?.meetingTitle ?? '',
+        groupOrCommittee: item?.groupName ?? '',
+        roomOrLocation: item?.meetingLocation ?? '',
+        startDateTime: item?.meetingStDate,
+        endDateTime: item?.meetingEdDate,
+        timezone: item?.timeZone ?? '',
+        status,
+        isMemberOfGroup: item?.isMemberOfGroup ?? false,
+        isOpenForAttendance,
+    };
+}
+/**
+ * Maps a raw backend list of child-meeting detail items to {@link MeetingRow}
+ * view models.
+ * @param {EventMeetingDetailItem[]} items - The raw child-meeting items.
+ * @return {MeetingRow[]} The mapped meeting rows.
+ */
+export function mapEventMeetingDetails(items) {
+    return (items ?? []).map((item) => mapDetailItemToMeetingRow(item));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-meeting-mapper.util.js","sourceRoot":"","sources":["../../../../../projects/dashboard/src/lib/utils/event-meeting-mapper.util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Pure mappers converting the raw \"events & meetings\" backend list/detail items\r\n * into the dashboard view models. No Angular / service dependencies so they are\r\n * trivially unit-testable and shared by {@link DashboardService}.\r\n *\r\n * Backend dates are epoch milliseconds; callers format them with luxon\r\n * `DateTime.fromMillis` at render time. The list mapper enforces the dashboard\r\n * rule that STANDALONE_MEETING rows always sort LAST within the section.\r\n */\r\nimport {\r\n  EventMeetingDetailItem,\r\n  EventMeetingListItem,\r\n} from '../models/event-meeting-list-item.model';\r\nimport { MeetingRow } from '../models/meeting-row.model';\r\nimport {\r\n  UpcomingEvent,\r\n  UpcomingItemKind,\r\n} from '../models/upcoming-event.model';\r\nimport { computeDayIndicator } from './date-format.util';\r\n\r\n/**\r\n * Determines whether a raw list item is an EVENT (owns child meetings) or a\r\n * STANDALONE_MEETING. An item is an EVENT when the backend flags it with\r\n * `isMeetingEvent === true` or `hasChildren === true`.\r\n * @param {EventMeetingListItem} item - The raw list item.\r\n * @return {UpcomingItemKind} The resolved render kind.\r\n */\r\nexport function resolveItemKind(\r\n  item: EventMeetingListItem\r\n): UpcomingItemKind {\r\n  const isEvent = item?.isMeetingEvent === true || item?.hasChildren === true;\r\n  return isEvent ? UpcomingItemKind.EVENT : UpcomingItemKind.STANDALONE_MEETING;\r\n}\r\n\r\n/**\r\n * Maps a raw backend list item to the {@link UpcomingEvent} view model. EVENT\r\n * rows start with an empty `meetings` array (child meetings are lazily loaded on\r\n * expand); STANDALONE_MEETING rows carry their own group/location fields.\r\n * @param {EventMeetingListItem} item - The raw list item.\r\n * @return {UpcomingEvent} The mapped view model.\r\n */\r\nexport function mapListItemToUpcomingEvent(\r\n  item: EventMeetingListItem\r\n): UpcomingEvent {\r\n  const kind = resolveItemKind(item);\r\n  const timezone = item?.timeZone ?? '';\r\n  const dayIndicator =\r\n    item?.dayIndicator ??\r\n    (kind === UpcomingItemKind.EVENT\r\n      ? computeDayIndicator(item?.startDateTime, item?.endDateTime, timezone)\r\n      : '');\r\n  return {\r\n    eventId: item?.id ?? item?.eventId ?? item?.meetingId ?? '',\r\n    kind,\r\n    // The list endpoint uses `name`; fall back to `meetingTitle` for meeting rows.\r\n    title: item?.name ?? item?.meetingTitle ?? '',\r\n    // The list screen copies status into contentUnderLink; accept either.\r\n    status: item?.status ?? item?.contentUnderLink ?? '',\r\n    dayIndicator,\r\n    meetingCount:\r\n      kind === UpcomingItemKind.STANDALONE_MEETING\r\n        ? 1\r\n        : item?.meetingCount ?? 0,\r\n    openForAttendanceCount: item?.openForAttendanceCount ?? 0,\r\n    startDateTime: item?.startDateTime,\r\n    endDateTime: item?.endDateTime,\r\n    timezone,\r\n    groupOrCommittee: item?.groupName ?? item?.groupAcronym ?? '',\r\n    roomOrLocation: item?.meetingLocation ?? item?.room ?? '',\r\n    isMemberOfGroup: item?.isMemberOfGroup ?? false,\r\n    meetings: [],\r\n  };\r\n}\r\n\r\n/**\r\n * Maps a raw backend list of events & meetings into the dashboard view models,\r\n * enforcing that STANDALONE_MEETING rows always sort LAST while preserving the\r\n * backend's within-group ordering for each partition (stable sort).\r\n * @param {EventMeetingListItem[]} items - The raw list items.\r\n * @return {UpcomingEvent[]} The mapped, standalone-last ordered view models.\r\n */\r\nexport function mapEventMeetingList(\r\n  items: EventMeetingListItem[]\r\n): UpcomingEvent[] {\r\n  const mapped = (items ?? []).map((item) => mapListItemToUpcomingEvent(item));\r\n  const events = mapped.filter(\r\n    (entry) => entry.kind === UpcomingItemKind.EVENT\r\n  );\r\n  const standalone = mapped.filter(\r\n    (entry) => entry.kind === UpcomingItemKind.STANDALONE_MEETING\r\n  );\r\n  return [...events, ...standalone];\r\n}\r\n\r\n/**\r\n * Maps a raw backend child-meeting detail item to the {@link MeetingRow} view\r\n * model used by the event block's expanded meeting list.\r\n * @param {EventMeetingDetailItem} item - The raw child-meeting item.\r\n * @return {MeetingRow} The mapped meeting row.\r\n */\r\nexport function mapDetailItemToMeetingRow(\r\n  item: EventMeetingDetailItem\r\n): MeetingRow {\r\n  const status = item?.status ?? '';\r\n  // A meeting is \"open for attendance\" while it is In Progress. The\r\n  // meetingsDetails endpoint has no dedicated flag, so derive it from status\r\n  // (honouring an explicit backend flag when one is provided).\r\n  const isOpenForAttendance =\r\n    item?.isOpenForAttendance ?? status.trim().toLowerCase() === 'in progress';\r\n  return {\r\n    meetingId: item?.meetingId ?? '',\r\n    meetingName: item?.meetingTitle ?? '',\r\n    groupOrCommittee: item?.groupName ?? '',\r\n    roomOrLocation: item?.meetingLocation ?? '',\r\n    startDateTime: item?.meetingStDate,\r\n    endDateTime: item?.meetingEdDate,\r\n    timezone: item?.timeZone ?? '',\r\n    status,\r\n    isMemberOfGroup: item?.isMemberOfGroup ?? false,\r\n    isOpenForAttendance,\r\n  };\r\n}\r\n\r\n/**\r\n * Maps a raw backend list of child-meeting detail items to {@link MeetingRow}\r\n * view models.\r\n * @param {EventMeetingDetailItem[]} items - The raw child-meeting items.\r\n * @return {MeetingRow[]} The mapped meeting rows.\r\n */\r\nexport function mapEventMeetingDetails(\r\n  items: EventMeetingDetailItem[]\r\n): MeetingRow[] {\r\n  return (items ?? []).map((item) => mapDetailItemToMeetingRow(item));\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,36 @@
+/*
+ * Public API Surface of dashboard
+ */
+// Container component + navigation intent type (DashboardComponent, DashboardNavigationIntent)
+export * from './lib/dashboard.component';
+// Child components
+export * from './lib/components/welcome-header/dashboard-welcome-header.component';
+export * from './lib/components/upcoming-meetings-events/upcoming-meetings-events.component';
+export * from './lib/components/event-group-card/event-group-card.component';
+export * from './lib/components/meeting-attendance-row/meeting-attendance-row.component';
+export * from './lib/components/your-groups/your-groups.component';
+export * from './lib/components/member-level-badge/member-level-badge.component';
+// Module + routes
+export * from './lib/dashboard.module';
+export * from './lib/dashboard.routes';
+// Models
+export * from './lib/models/dashboard-route-config.model';
+export * from './lib/models/attendance-state.model';
+export * from './lib/models/dashboard-section-state.model';
+export * from './lib/models/page-change.model';
+export * from './lib/models/dashboard-user-info.model';
+export * from './lib/models/meeting-row.model';
+export * from './lib/models/upcoming-event.model';
+export * from './lib/models/event-meeting-list-item.model';
+export * from './lib/models/event-meeting-list-payload.model';
+export * from './lib/models/group-row.model';
+export * from './lib/models/attendance-action-permissions.model';
+export * from './lib/models/dashboard-list-response.model';
+// Services
+export * from './lib/services/dashboard.service';
+export * from './lib/services/user-permissions.service';
+// Asset mocks consumed by the demo app
+export * from './lib/assets/dashboard-route-paths.mock';
+export * from './lib/assets/dashboard-user-permissions.mock';
+export * from './lib/assets/dashboard-mock';
+//# sourceMappingURL=data:application/json;base64,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