@ieeesa-npm/dashboard 0.0.0-stage → 0.0.1

package/esm2022/lib/services/attendance-reducers.mjs

@@ -0,0 +1,54 @@
+import { AttendanceState } from '../models/attendance-state.model';
+/**
+ * Pure reducers for the dashboard attendance state. These functions never
+ * mutate their inputs; each returns a new object/set so they can be exercised
+ * directly by property tests and composed by the DashboardService.
+ */
+/**
+ * Produce a new attendance-state map with the target meeting set to
+ * CURRENTLY_ATTENDING. Every other entry is copied unchanged (frame property).
+ *
+ * @param {Record<string, AttendanceState>} map The current attendance-state map (not mutated).
+ * @param {string} meetingId The meeting whose state transitions to CURRENTLY_ATTENDING.
+ * @return {Record<string, AttendanceState>} A new map reflecting the successful log-attendance action.
+ */
+export const applyLogAttendanceSuccess = (map, meetingId) => ({
+    ...map,
+    [meetingId]: AttendanceState.CURRENTLY_ATTENDING,
+});
+/**
+ * Produce a new attendance-state map with the target meeting set to
+ * NOT_ATTENDING. Every other entry is copied unchanged (frame property).
+ *
+ * @param {Record<string, AttendanceState>} map The current attendance-state map (not mutated).
+ * @param {string} meetingId The meeting whose state transitions to NOT_ATTENDING.
+ * @return {Record<string, AttendanceState>} A new map reflecting the successful leave-meeting action.
+ */
+export const applyLeaveMeetingSuccess = (map, meetingId) => ({
+    ...map,
+    [meetingId]: AttendanceState.NOT_ATTENDING,
+});
+/**
+ * Add a meeting to the in-flight set, returning a new set. Prior membership is
+ * retained so the displayed attendance state is preserved while the request
+ * resolves.
+ *
+ * @param {ReadonlySet<string>} set The current in-flight meeting-id set (not mutated).
+ * @param {string} meetingId The meeting whose attendance action has started.
+ * @return {Set<string>} A new set that additionally contains the meeting id.
+ */
+export const beginAttendanceAction = (set, meetingId) => new Set([...set, meetingId]);
+/**
+ * Remove a meeting from the in-flight set, returning a new set. All other
+ * in-flight ids are retained.
+ *
+ * @param {ReadonlySet<string>} set The current in-flight meeting-id set (not mutated).
+ * @param {string} meetingId The meeting whose attendance action has resolved.
+ * @return {Set<string>} A new set that no longer contains the meeting id.
+ */
+export const endAttendanceAction = (set, meetingId) => {
+    const next = new Set(set);
+    next.delete(meetingId);
+    return next;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/dashboard.service.mjs

@@ -0,0 +1,208 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, catchError, map, of, } from 'rxjs';
+import { AttendanceState } from '../models/attendance-state.model';
+import { DashboardSectionState } from '../models/dashboard-section-state.model';
+import { DashboardGroupsMock, DashboardUpcomingEventsMock, } from '../assets/dashboard-mock';
+import { applyLeaveMeetingSuccess, applyLogAttendanceSuccess, beginAttendanceAction, endAttendanceAction, } from './attendance-reducers';
+import * as i0 from "@angular/core";
+import * as i1 from "@ieeesa-npm/utility";
+/**
+ * DashboardService is the single source of truth for the dashboard landing
+ * page's data and attendance state. It mirrors the `events-and-meetings`
+ * service conventions: it is a `providedIn: 'root'` singleton, holds the host
+ * `apiBaseUrl` / `userPermissions` set via {@link setAppConfig}, owns its state
+ * via `BehaviorSubject`s exposed as observables, and reaches the backend only
+ * through the shared `HttpService` from `@ieeesa-npm/utility` (never
+ * `HttpClient` directly).
+ *
+ * The upcoming-events and groups loads currently return annotated mock data
+ * because their endpoints are not yet available; the attendance actions compose
+ * the pure reducers from `attendance-reducers.ts` so the displayed
+ * `AttendanceState` only advances on a successful resolution and the prior
+ * state is retained on failure.
+ * @export
+ * @class DashboardService
+ */
+export class DashboardService {
+    constructor(
+    // eslint-disable-next-line no-unused-vars
+    httpService // eslint-disable-next-line no-empty-function
+    ) {
+        this.httpService = httpService;
+        this.upcomingEvents = new BehaviorSubject([]);
+        this.groups = new BehaviorSubject([]);
+        this.upcomingState = new BehaviorSubject(DashboardSectionState.LOADING);
+        this.groupsState = new BehaviorSubject(DashboardSectionState.LOADING);
+        this.attendanceStates = new BehaviorSubject({});
+        this.inFlightMeetingIds = new BehaviorSubject(new Set());
+        /** Emits the list of the user's upcoming events. */
+        this.upcomingEvents$ = this.upcomingEvents.asObservable();
+        /** Emits the list of the user's groups. */
+        this.groups$ = this.groups.asObservable();
+        /** Emits the load/empty/error state of the upcoming-events section. */
+        this.upcomingState$ = this.upcomingState.asObservable();
+        /** Emits the load/empty/error state of the groups section. */
+        this.groupsState$ = this.groupsState.asObservable();
+        /** Emits the per-meeting attendance-state map. */
+        this.attendanceStates$ = this.attendanceStates.asObservable();
+        /** Emits the set of meeting ids with an attendance action in flight. */
+        this.inFlightMeetingIds$ = this.inFlightMeetingIds.asObservable();
+    }
+    /**
+     * Stores the host-supplied API base URL and user permissions used to build
+     * request URLs and gate permission-controlled actions. Mirrors the
+     * `events-and-meetings` service `setAppConfig`.
+     * @param {string} apiBaseURL - The host application's API base URL.
+     * @param {UserPermission[]} userPermissions - The signed-in user's permissions.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    setAppConfig(apiBaseURL, userPermissions) {
+        this.apiBaseUrl = apiBaseURL;
+        this.userPermissions = userPermissions;
+    }
+    /**
+     * Loads the user's upcoming events, driving the upcoming section through
+     * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on
+     * failure. Follows the `pipe(map, catchError(throw))` pattern and seeds the
+     * per-meeting attendance-state map from the loaded meetings.
+     *
+     * TODO: Replace mock with real API call when BE is ready
+     * @return {Observable<DashboardListResponse<UpcomingEvent[]>>} The upcoming-events response envelope.
+     * @memberof DashboardService
+     */
+    loadUpcomingEvents() {
+        this.upcomingState.next(DashboardSectionState.LOADING);
+        // TODO: Replace mock with real API call when BE is ready
+        const response$ = of({
+            status: true,
+            body: DashboardUpcomingEventsMock,
+        });
+        return response$.pipe(map((response) => {
+            const events = response?.body ?? [];
+            this.upcomingEvents.next(events);
+            this.seedAttendanceStates(events);
+            this.upcomingState.next(events.length > 0
+                ? DashboardSectionState.LOADED
+                : DashboardSectionState.EMPTY);
+            return response;
+        }), catchError((error) => {
+            this.upcomingState.next(DashboardSectionState.ERROR);
+            throw error;
+        }));
+    }
+    /**
+     * Loads the user's groups, driving the groups section through
+     * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on
+     * failure. Follows the `pipe(map, catchError(throw))` pattern.
+     *
+     * TODO: Replace mock with real API call when BE is ready
+     * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.
+     * @memberof DashboardService
+     */
+    loadGroups() {
+        this.groupsState.next(DashboardSectionState.LOADING);
+        // TODO: Replace mock with real API call when BE is ready
+        const response$ = of({
+            status: true,
+            body: DashboardGroupsMock,
+        });
+        return response$.pipe(map((response) => {
+            const groups = response?.body ?? [];
+            this.groups.next(groups);
+            this.groupsState.next(groups.length > 0
+                ? DashboardSectionState.LOADED
+                : DashboardSectionState.EMPTY);
+            return response;
+        }), catchError((error) => {
+            this.groupsState.next(DashboardSectionState.ERROR);
+            throw error;
+        }));
+    }
+    /**
+     * Logs attendance for a meeting. Marks the meeting in-flight (retaining the
+     * prior displayed state), posts through `HttpService`, applies the
+     * log-attendance-success reducer on success, clears the in-flight flag on
+     * completion, and rethrows while retaining prior state on failure.
+     * @param {string} meetingId - The meeting to log attendance for.
+     * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.
+     * @memberof DashboardService
+     */
+    logAttendance(meetingId) {
+        this.inFlightMeetingIds.next(beginAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+        return this.httpService
+            .postData(`${this.apiBaseUrl}/meetings/attendance/log`, { meetingId })
+            .pipe(map((response) => {
+            this.attendanceStates.next(applyLogAttendanceSuccess(this.attendanceStates.value, meetingId));
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            return response;
+        }), catchError((error) => {
+            // Retain prior attendance state; only clear the in-flight flag.
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            throw error;
+        }));
+    }
+    /**
+     * Leaves a meeting. Marks the meeting in-flight (retaining the prior
+     * displayed state), posts through `HttpService`, applies the
+     * leave-meeting-success reducer on success, clears the in-flight flag on
+     * completion, and rethrows while retaining prior state on failure.
+     * @param {string} meetingId - The meeting to leave.
+     * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.
+     * @memberof DashboardService
+     */
+    leaveMeeting(meetingId) {
+        this.inFlightMeetingIds.next(beginAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+        return this.httpService
+            .postData(`${this.apiBaseUrl}/meetings/attendance/leave`, { meetingId })
+            .pipe(map((response) => {
+            this.attendanceStates.next(applyLeaveMeetingSuccess(this.attendanceStates.value, meetingId));
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            return response;
+        }), catchError((error) => {
+            // Retain prior attendance state; only clear the in-flight flag.
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            throw error;
+        }));
+    }
+    /**
+     * Returns a synchronous snapshot of the per-meeting attendance-state map.
+     * @return {Record<string, AttendanceState>} The current attendance-state map.
+     * @memberof DashboardService
+     */
+    getAttendanceStatesSnapshot() {
+        return this.attendanceStates.value;
+    }
+    /**
+     * Seeds the attendance-state map from a freshly loaded list of events, using
+     * each meeting's `attendanceState` (defaulting to `NOT_ATTENDING`). Keeps the
+     * displayed state in sync with the data load without overwriting ids that are
+     * not present in the new list.
+     * @param {UpcomingEvent[]} events - The loaded upcoming events.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    seedAttendanceStates(events) {
+        const next = {
+            ...this.attendanceStates.value,
+        };
+        events.forEach((event) => {
+            event.meetings?.forEach((meeting) => {
+                if (meeting.meetingId) {
+                    next[meeting.meetingId] =
+                        meeting.attendanceState ?? AttendanceState.NOT_ATTENDING;
+                }
+            });
+        });
+        this.attendanceStates.next(next);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardService, deps: [{ token: i1.HttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.service.js","sourceRoot":"","sources":["../../../../../projects/dashboard/src/lib/services/dashboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n  BehaviorSubject,\r\n  Observable,\r\n  catchError,\r\n  map,\r\n  of,\r\n} from 'rxjs';\r\nimport { HttpService } from '@ieeesa-npm/utility';\r\nimport { UserPermission } from '@ieeesa-npm/models';\r\nimport { AttendanceState } from '../models/attendance-state.model';\r\nimport { DashboardListResponse } from '../models/dashboard-list-response.model';\r\nimport { DashboardSectionState } from '../models/dashboard-section-state.model';\r\nimport { GroupRow } from '../models/group-row.model';\r\nimport { UpcomingEvent } from '../models/upcoming-event.model';\r\nimport {\r\n  DashboardGroupsMock,\r\n  DashboardUpcomingEventsMock,\r\n} from '../assets/dashboard-mock';\r\nimport {\r\n  applyLeaveMeetingSuccess,\r\n  applyLogAttendanceSuccess,\r\n  beginAttendanceAction,\r\n  endAttendanceAction,\r\n} from './attendance-reducers';\r\n\r\n/**\r\n * DashboardService is the single source of truth for the dashboard landing\r\n * page's data and attendance state. It mirrors the `events-and-meetings`\r\n * service conventions: it is a `providedIn: 'root'` singleton, holds the host\r\n * `apiBaseUrl` / `userPermissions` set via {@link setAppConfig}, owns its state\r\n * via `BehaviorSubject`s exposed as observables, and reaches the backend only\r\n * through the shared `HttpService` from `@ieeesa-npm/utility` (never\r\n * `HttpClient` directly).\r\n *\r\n * The upcoming-events and groups loads currently return annotated mock data\r\n * because their endpoints are not yet available; the attendance actions compose\r\n * the pure reducers from `attendance-reducers.ts` so the displayed\r\n * `AttendanceState` only advances on a successful resolution and the prior\r\n * state is retained on failure.\r\n * @export\r\n * @class DashboardService\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class DashboardService {\r\n  apiBaseUrl!: string;\r\n  userPermissions!: UserPermission[];\r\n\r\n  private readonly upcomingEvents = new BehaviorSubject<UpcomingEvent[]>([]);\r\n  private readonly groups = new BehaviorSubject<GroupRow[]>([]);\r\n  private readonly upcomingState = new BehaviorSubject<DashboardSectionState>(\r\n    DashboardSectionState.LOADING\r\n  );\r\n  private readonly groupsState = new BehaviorSubject<DashboardSectionState>(\r\n    DashboardSectionState.LOADING\r\n  );\r\n  private readonly attendanceStates = new BehaviorSubject<\r\n    Record<string, AttendanceState>\r\n  >({});\r\n  private readonly inFlightMeetingIds = new BehaviorSubject<\r\n    ReadonlySet<string>\r\n  >(new Set<string>());\r\n\r\n  /** Emits the list of the user's upcoming events. */\r\n  upcomingEvents$: Observable<UpcomingEvent[]> =\r\n    this.upcomingEvents.asObservable();\r\n  /** Emits the list of the user's groups. */\r\n  groups$: Observable<GroupRow[]> = this.groups.asObservable();\r\n  /** Emits the load/empty/error state of the upcoming-events section. */\r\n  upcomingState$: Observable<DashboardSectionState> =\r\n    this.upcomingState.asObservable();\r\n  /** Emits the load/empty/error state of the groups section. */\r\n  groupsState$: Observable<DashboardSectionState> =\r\n    this.groupsState.asObservable();\r\n  /** Emits the per-meeting attendance-state map. */\r\n  attendanceStates$: Observable<Record<string, AttendanceState>> =\r\n    this.attendanceStates.asObservable();\r\n  /** Emits the set of meeting ids with an attendance action in flight. */\r\n  inFlightMeetingIds$: Observable<ReadonlySet<string>> =\r\n    this.inFlightMeetingIds.asObservable();\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private httpService: HttpService // eslint-disable-next-line no-empty-function\r\n  ) {}\r\n\r\n  /**\r\n   * Stores the host-supplied API base URL and user permissions used to build\r\n   * request URLs and gate permission-controlled actions. Mirrors the\r\n   * `events-and-meetings` service `setAppConfig`.\r\n   * @param {string} apiBaseURL - The host application's API base URL.\r\n   * @param {UserPermission[]} userPermissions - The signed-in user's permissions.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  setAppConfig(apiBaseURL: string, userPermissions: UserPermission[]): void {\r\n    this.apiBaseUrl = apiBaseURL;\r\n    this.userPermissions = userPermissions;\r\n  }\r\n\r\n  /**\r\n   * Loads the user's upcoming events, driving the upcoming section through\r\n   * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on\r\n   * failure. Follows the `pipe(map, catchError(throw))` pattern and seeds the\r\n   * per-meeting attendance-state map from the loaded meetings.\r\n   *\r\n   * TODO: Replace mock with real API call when BE is ready\r\n   * @return {Observable<DashboardListResponse<UpcomingEvent[]>>} The upcoming-events response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadUpcomingEvents(): Observable<DashboardListResponse<UpcomingEvent[]>> {\r\n    this.upcomingState.next(DashboardSectionState.LOADING);\r\n    // TODO: Replace mock with real API call when BE is ready\r\n    const response$: Observable<DashboardListResponse<UpcomingEvent[]>> = of({\r\n      status: true,\r\n      body: DashboardUpcomingEventsMock,\r\n    });\r\n    return response$.pipe(\r\n      map((response) => {\r\n        const events = response?.body ?? [];\r\n        this.upcomingEvents.next(events);\r\n        this.seedAttendanceStates(events);\r\n        this.upcomingState.next(\r\n          events.length > 0\r\n            ? DashboardSectionState.LOADED\r\n            : DashboardSectionState.EMPTY\r\n        );\r\n        return response;\r\n      }),\r\n      catchError((error) => {\r\n        this.upcomingState.next(DashboardSectionState.ERROR);\r\n        throw error;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Loads the user's groups, driving the groups section through\r\n   * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on\r\n   * failure. Follows the `pipe(map, catchError(throw))` pattern.\r\n   *\r\n   * TODO: Replace mock with real API call when BE is ready\r\n   * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadGroups(): Observable<DashboardListResponse<GroupRow[]>> {\r\n    this.groupsState.next(DashboardSectionState.LOADING);\r\n    // TODO: Replace mock with real API call when BE is ready\r\n    const response$: Observable<DashboardListResponse<GroupRow[]>> = of({\r\n      status: true,\r\n      body: DashboardGroupsMock,\r\n    });\r\n    return response$.pipe(\r\n      map((response) => {\r\n        const groups = response?.body ?? [];\r\n        this.groups.next(groups);\r\n        this.groupsState.next(\r\n          groups.length > 0\r\n            ? DashboardSectionState.LOADED\r\n            : DashboardSectionState.EMPTY\r\n        );\r\n        return response;\r\n      }),\r\n      catchError((error) => {\r\n        this.groupsState.next(DashboardSectionState.ERROR);\r\n        throw error;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Logs attendance for a meeting. Marks the meeting in-flight (retaining the\r\n   * prior displayed state), posts through `HttpService`, applies the\r\n   * log-attendance-success reducer on success, clears the in-flight flag on\r\n   * completion, and rethrows while retaining prior state on failure.\r\n   * @param {string} meetingId - The meeting to log attendance for.\r\n   * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  logAttendance(\r\n    meetingId: string\r\n  ): Observable<DashboardListResponse<unknown>> {\r\n    this.inFlightMeetingIds.next(\r\n      beginAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n    );\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/attendance/log`, { meetingId })\r\n      .pipe(\r\n        map((response) => {\r\n          this.attendanceStates.next(\r\n            applyLogAttendanceSuccess(this.attendanceStates.value, meetingId)\r\n          );\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          // Retain prior attendance state; only clear the in-flight flag.\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Leaves a meeting. Marks the meeting in-flight (retaining the prior\r\n   * displayed state), posts through `HttpService`, applies the\r\n   * leave-meeting-success reducer on success, clears the in-flight flag on\r\n   * completion, and rethrows while retaining prior state on failure.\r\n   * @param {string} meetingId - The meeting to leave.\r\n   * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  leaveMeeting(\r\n    meetingId: string\r\n  ): Observable<DashboardListResponse<unknown>> {\r\n    this.inFlightMeetingIds.next(\r\n      beginAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n    );\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/attendance/leave`, { meetingId })\r\n      .pipe(\r\n        map((response) => {\r\n          this.attendanceStates.next(\r\n            applyLeaveMeetingSuccess(this.attendanceStates.value, meetingId)\r\n          );\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          // Retain prior attendance state; only clear the in-flight flag.\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Returns a synchronous snapshot of the per-meeting attendance-state map.\r\n   * @return {Record<string, AttendanceState>} The current attendance-state map.\r\n   * @memberof DashboardService\r\n   */\r\n  getAttendanceStatesSnapshot(): Record<string, AttendanceState> {\r\n    return this.attendanceStates.value;\r\n  }\r\n\r\n  /**\r\n   * Seeds the attendance-state map from a freshly loaded list of events, using\r\n   * each meeting's `attendanceState` (defaulting to `NOT_ATTENDING`). Keeps the\r\n   * displayed state in sync with the data load without overwriting ids that are\r\n   * not present in the new list.\r\n   * @param {UpcomingEvent[]} events - The loaded upcoming events.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private seedAttendanceStates(events: UpcomingEvent[]): void {\r\n    const next: Record<string, AttendanceState> = {\r\n      ...this.attendanceStates.value,\r\n    };\r\n    events.forEach((event) => {\r\n      event.meetings?.forEach((meeting) => {\r\n        if (meeting.meetingId) {\r\n          next[meeting.meetingId] =\r\n            meeting.attendanceState ?? AttendanceState.NOT_ATTENDING;\r\n        }\r\n      });\r\n    });\r\n    this.attendanceStates.next(next);\r\n  }\r\n}\r\n"]}

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,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

package/esm2022/public-api.mjs

@@ -0,0 +1,34 @@
+/*
+ * 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/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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