@ieeesa-npm/dashboard 0.0.0-stage → 0.0.2

package/lib/models/my-groups-view.model.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Read-only aggregate view returned by GET /v1/groups/my-groups, mirroring the
+ * groups-api `MyGroupsView` DTO. The dashboard "Your Groups" section consumes
+ * the `groups` collection; `interests` is not shown on the dashboard.
+ */
+export interface MyGroupsView {
+    groups: MyGroupView[];
+    interests?: MyInterestView[];
+}
+/**
+ * A single officer role the user holds in a group, as returned in the
+ * `officer` array of GET /v1/groups/my-groups.
+ */
+export interface GroupOfficer {
+    officerId: string;
+    officerName: string;
+}
+/**
+ * A single group the user is a roster member of. Carries the group's name,
+ * type, affiliations, the user's member level, and the user's officer role(s)
+ * for the group (the `officer` array — empty when the user holds no officer
+ * role).
+ */
+export interface MyGroupView {
+    groupId: string;
+    groupName: string;
+    groupType?: string;
+    groupTypeName?: string | null;
+    /** Ancestor hierarchy (root→leaf) of the group, for the expandable rows. */
+    hierarchy?: MyGroupHierarchyItem[];
+    affiliations?: string[];
+    memberLevelId?: string | null;
+    memberLevel?: string | null;
+    /** Officer roles the user holds in this group (e.g. "Chair"); empty if none. */
+    officer?: GroupOfficer[];
+}
+/** A single node in a group's ancestor hierarchy (root→leaf). */
+export interface MyGroupHierarchyItem {
+    groupId: string;
+    groupName: string;
+    groupShortName?: string;
+    groupAcronym?: string;
+    groupLevel?: number;
+    groupParentId?: string | null;
+    groupType?: string;
+    groupTypeName?: string | null;
+    groupDesc?: string | null;
+    hasChildren?: boolean | null;
+}
+/** A single interest the user has expressed (not shown on the dashboard). */
+export interface MyInterestView {
+    interestId: string;
+    groupId: string;
+    groupName: string;
+    status: string;
+}

package/lib/models/page-change.model.d.ts

@@ -0,0 +1,4 @@
+export interface PageChange {
+    pageIndex: number;
+    pageSize: number;
+}

package/lib/models/upcoming-event.model.d.ts

@@ -0,0 +1,51 @@
+import { MeetingRow } from './meeting-row.model';
+/**
+ * Discriminates how a row in the "Upcoming Meetings & Events" list is rendered.
+ * EVENT rows render as an expandable event block that owns child meetings;
+ * STANDALONE_MEETING rows render as a single meeting card and always sort LAST
+ * within the list.
+ */
+export declare enum UpcomingItemKind {
+    EVENT = "EVENT",
+    STANDALONE_MEETING = "STANDALONE_MEETING"
+}
+/**
+ * View model for a single entry in the "Upcoming Meetings & Events" section.
+ *
+ * When {@link kind} is `EVENT` the entry renders as the expandable event block
+ * (header badge, title, "Day X of Y", meeting-count sub-line, dates/timezone,
+ * View button, and the show/hide child-meeting list). When `kind` is
+ * `STANDALONE_MEETING` the entry renders as a single standalone meeting card
+ * (rendered after all events).
+ *
+ * `startEpochMs` / `endEpochMs` carry the raw epoch-milliseconds values from the
+ * backend and are formatted with luxon `DateTime.fromMillis`. The legacy ISO
+ * `startDate` / `endDate` fields are retained for existing fixtures/tests.
+ */
+export interface UpcomingEvent {
+    eventId: string;
+    /** EVENT vs. STANDALONE_MEETING render discriminator. */
+    kind: UpcomingItemKind;
+    title: string;
+    status: string;
+    dayIndicator?: string;
+    meetingCount: number;
+    openForAttendanceCount: number;
+    /** Start date-time as an ISO-8601 string (or epoch ms for fixtures). */
+    startDateTime?: string | number;
+    /** End date-time as an ISO-8601 string (or epoch ms for fixtures). */
+    endDateTime?: string | number;
+    /** Legacy ISO start date, retained for fixtures/tests. */
+    startDate?: string;
+    /** Legacy ISO end date, retained for fixtures/tests. */
+    endDate?: string;
+    timezone: string;
+    /** Owning group label, shown on standalone-meeting cards. */
+    groupOrCommittee?: string;
+    /** Room / location, shown on standalone-meeting cards. */
+    roomOrLocation?: string;
+    /** True when the user is a member of the owning group. */
+    isMemberOfGroup?: boolean;
+    /** The event's child meetings (empty / lazily loaded for EVENT rows). */
+    meetings: MeetingRow[];
+}

package/lib/services/attendance-reducers.d.ts

@@ -0,0 +1,43 @@
+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 declare const applyLogAttendanceSuccess: (map: Record<string, AttendanceState>, meetingId: string) => Record<string, AttendanceState>;
+/**
+ * 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 declare const applyLeaveMeetingSuccess: (map: Record<string, AttendanceState>, meetingId: string) => Record<string, AttendanceState>;
+/**
+ * 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 declare const beginAttendanceAction: (set: ReadonlySet<string>, meetingId: string) => Set<string>;
+/**
+ * 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 declare const endAttendanceAction: (set: ReadonlySet<string>, meetingId: string) => Set<string>;

package/lib/services/dashboard.service.d.ts

@@ -0,0 +1,202 @@
+import { Observable } from 'rxjs';
+import { HttpService } from '@ieeesa-npm/utility';
+import { UserPermission } from '@ieeesa-npm/models';
+import { AttendanceState } from '../models/attendance-state.model';
+import { DashboardListResponse } from '../models/dashboard-list-response.model';
+import { DashboardSectionState } from '../models/dashboard-section-state.model';
+import { GroupRow } from '../models/group-row.model';
+import { MyGroupsView } from '../models/my-groups-view.model';
+import { UpcomingEvent } from '../models/upcoming-event.model';
+import { EventMeetingDetailResponse, EventMeetingListResponse } from '../models/event-meeting-list-item.model';
+import * as i0 from "@angular/core";
+/**
+ * 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 load calls the real `POST /meetings/eventsAndMeetings`
+ * endpoint (child meetings are lazily loaded per-event via
+ * `POST /meetings/meetingsDetails`); the groups load calls `GET
+ * /groups/my-groups`. 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 declare class DashboardService {
+    private httpService;
+    apiBaseUrl: string;
+    userPermissions: UserPermission[];
+    private readonly upcomingEvents;
+    private readonly groups;
+    private readonly upcomingState;
+    private readonly groupsState;
+    private readonly attendanceStates;
+    private readonly inFlightMeetingIds;
+    /** Emits the list of the user's upcoming events. */
+    upcomingEvents$: Observable<UpcomingEvent[]>;
+    /** Emits the list of the user's groups. */
+    groups$: Observable<GroupRow[]>;
+    /** Emits the load/empty/error state of the upcoming-events section. */
+    upcomingState$: Observable<DashboardSectionState>;
+    /** Emits the load/empty/error state of the groups section. */
+    groupsState$: Observable<DashboardSectionState>;
+    /** Emits the per-meeting attendance-state map. */
+    attendanceStates$: Observable<Record<string, AttendanceState>>;
+    /** Emits the set of meeting ids with an attendance action in flight. */
+    inFlightMeetingIds$: Observable<ReadonlySet<string>>;
+    constructor(httpService: HttpService);
+    /**
+     * 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: string, userPermissions: UserPermission[]): void;
+    /**
+     * Loads the user's upcoming events & meetings from the real backend via
+     * `POST {apiBaseUrl}/meetings/eventsAndMeetings`, the same endpoint the
+     * `view-events-meetings-list` screen uses. The response is mapped into the
+     * dashboard view models (with STANDALONE_MEETING rows ordered last), the
+     * per-meeting attendance-state map is seeded, and the section advances through
+     * LOADING → LOADED/EMPTY on success, leaving the caller to set ERROR on
+     * failure. Follows the shared `pipe(map, catchError(throw))` pattern.
+     * @return {Observable<EventMeetingListResponse>} The upcoming events & meetings response envelope.
+     * @memberof DashboardService
+     */
+    loadUpcomingEvents(): Observable<EventMeetingListResponse>;
+    /**
+     * Lazily loads (and paginates) the child meetings of an EVENT row via
+     * `POST {apiBaseUrl}/meetings/meetingsDetails` — the per-event expand endpoint
+     * used by the reference screen. On success the loaded meetings are mapped and
+     * merged onto the matching event in the `upcomingEvents` list (with its
+     * `meetingCount` / `openForAttendanceCount` refreshed), and the per-meeting
+     * attendance-state map is extended. Each event paginates independently.
+     * @param {string} eventId - The event whose meetings to load.
+     * @param {number} [page=1] - The one-based page to request.
+     * @param {number} [size=EVENT_MEETINGS_PAGE_SIZE] - The page size.
+     * @return {Observable<EventMeetingDetailResponse>} The child-meetings response envelope.
+     * @memberof DashboardService
+     */
+    loadEventMeetings(eventId: string, page?: number, size?: number): Observable<EventMeetingDetailResponse>;
+    /**
+     * Merges a freshly loaded page of child meetings onto the matching event in
+     * the `upcomingEvents` list, refreshing the event's `meetings`,
+     * `meetingCount` (from the backend `totalRecords`), and
+     * `openForAttendanceCount`. Leaves all other events untouched.
+     * @param {string} eventId - The event to merge meetings onto.
+     * @param {MeetingRow[]} meetings - The mapped child meetings for the page.
+     * @param {number} totalRecords - The event's total meeting count from the backend.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    private mergeEventMeetings;
+    /**
+     * Eagerly fetches each EVENT's total meeting count and open-for-attendance
+     * count by requesting a large first page of its child meetings, then merging
+     * only the counts (not the rows) so the collapsed card summaries are accurate
+     * before the user expands. Standalone meetings are skipped. Failures per event
+     * are swallowed so one failing count never breaks the list.
+     * @param {UpcomingEvent[]} events - The loaded events to fetch counts for.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    private loadEventCounts;
+    /**
+     * Merges only the meeting counts onto the matching event, leaving its
+     * `meetings` rows untouched (used by the eager count prefetch).
+     * @param {string} eventId - The event to update.
+     * @param {number} totalRecords - The event's total meeting count.
+     * @param {number} openForAttendanceCount - The open-for-attendance count.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    private mergeEventCounts;
+    /**
+     * Builds and posts the `meetingsDetails` request for a single event page,
+     * returning the raw response envelope. Shared by {@link loadEventMeetings} and
+     * the eager count prefetch.
+     * @param {string} eventId - The event whose meetings to fetch.
+     * @param {number} page - The one-based page to request.
+     * @param {number} size - The page size.
+     * @return {Observable<EventMeetingDetailResponse>} The child-meetings response.
+     * @memberof DashboardService
+     */
+    private fetchEventMeetingsPage;
+    /**
+     * 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(): Observable<DashboardListResponse<MyGroupsView>>;
+    /**
+     * Maps a backend {@link MyGroupView} to the table-facing {@link GroupRow}.
+     * Mirrors the My Groups profile tab: the type falls back to "Unassigned" when
+     * `groupTypeName` is null, affiliations are comma-joined, empty officer role /
+     * affiliation render as a placeholder, and a blank member level becomes
+     * "Unassigned" (rendered as the warning pill by the Your Groups component).
+     * @param {MyGroupView} group - The backend group view.
+     * @return {GroupRow}
+     * @memberof DashboardService
+     */
+    private mapGroup;
+    /**
+     * 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: string): Observable<DashboardListResponse<unknown>>;
+    /**
+     * 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: string): Observable<DashboardListResponse<unknown>>;
+    /**
+     * Returns a synchronous snapshot of the per-meeting attendance-state map.
+     * @return {Record<string, AttendanceState>} The current attendance-state map.
+     * @memberof DashboardService
+     */
+    getAttendanceStatesSnapshot(): Record<string, AttendanceState>;
+    /**
+     * 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
+     */
+    private seedAttendanceStates;
+    /**
+     * Seeds the attendance-state map from a list of meeting rows, using each
+     * meeting's `attendanceState` (defaulting to `NOT_ATTENDING`) without
+     * overwriting ids absent from the new list. Shared by the list load and the
+     * per-event expand so freshly loaded child meetings pick up their state.
+     * @param {MeetingRow[]} meetings - The meeting rows to seed from.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    private seedAttendanceStatesFromMeetings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardService>;
+}

package/lib/services/user-permissions.service.d.ts

@@ -0,0 +1,31 @@
+import { UserPermission } from '@ieeesa-npm/models';
+import { AttendanceActionPermissions } from '../models/attendance-action-permissions.model';
+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.
+ */
+export declare enum DashboardPermissionType {
+    LOG_ATTENDANCE = "Log Attendance",
+    LEAVE_MEETING = "Leave Meeting"
+}
+export declare 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: DashboardPermissionType, userPermissions: UserPermission[]): boolean;
+    /**
+     * 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: UserPermission[]): AttendanceActionPermissions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserPermissionsService>;
+}

package/lib/utils/attendance-action.util.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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';
+/**
+ * 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 declare enum AttendanceAction {
+    LOG_ATTENDANCE = "LOG_ATTENDANCE",
+    LEAVE_MEETING = "LEAVE_MEETING",
+    NONE = "NONE"
+}
+/**
+ * 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 declare function resolveAttendanceAction(attendanceState: AttendanceState | undefined, isInFlight: boolean, meetingId: string | undefined): AttendanceAction;

package/lib/utils/date-format.util.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 declare function extractIanaZone(timezone: string | undefined): string | 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 declare function parseBackendDateTime(value: string | number | undefined | null, timezone?: string): DateTime;
+/**
+ * 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 declare function formatBackendDateTime(value: string | number | undefined | null, format: string, timezone?: string): string;
+/**
+ * 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 declare function formatEpoch(value: string | number | undefined | null, format: string, timezone?: string): string;
+/**
+ * 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 declare function computeDayIndicator(start: string | number | undefined | null, end: string | number | undefined | null, timezone?: string): string;

package/lib/utils/event-meeting-mapper.util.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure mappers converting the raw "events & meetings" backend list/detail items
+ * into the dashboard view models. No Angular / service dependencies so they are
+ * trivially unit-testable and shared by {@link DashboardService}.
+ *
+ * Backend dates are epoch milliseconds; callers format them with luxon
+ * `DateTime.fromMillis` at render time. The list mapper enforces the dashboard
+ * rule that STANDALONE_MEETING rows always sort LAST within the section.
+ */
+import { EventMeetingDetailItem, EventMeetingListItem } from '../models/event-meeting-list-item.model';
+import { MeetingRow } from '../models/meeting-row.model';
+import { UpcomingEvent, UpcomingItemKind } from '../models/upcoming-event.model';
+/**
+ * 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 declare function resolveItemKind(item: EventMeetingListItem): UpcomingItemKind;
+/**
+ * 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 declare function mapListItemToUpcomingEvent(item: EventMeetingListItem): UpcomingEvent;
+/**
+ * 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 declare function mapEventMeetingList(items: EventMeetingListItem[]): UpcomingEvent[];
+/**
+ * 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 declare function mapDetailItemToMeetingRow(item: EventMeetingDetailItem): MeetingRow;
+/**
+ * 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 declare function mapEventMeetingDetails(items: EventMeetingDetailItem[]): MeetingRow[];

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@ieeesa-npm/dashboard",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "peerDependencies": {
+    "@angular/common": "^16.1.0",
+    "@angular/core": "^16.1.0",
+    "@angular/material": "^16.1.3",
+    "@angular/router": "^16.1.0",
+    "@ieeesa-npm/models": ">=0.1.4",
+    "@ieeesa-npm/presentation": ">=0.33.33",
+    "@ieeesa-npm/shared-styles": ">=0.7.5",
+    "@ieeesa-npm/utility": ">=0.12.17",
+    "luxon": "^3.7.2",
+    "rxjs": "~7.8.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ieeesa-npm-dashboard.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/ieeesa-npm-dashboard.mjs",
+      "esm": "./esm2022/ieeesa-npm-dashboard.mjs",
+      "default": "./fesm2022/ieeesa-npm-dashboard.mjs"
+    }
+  }
 }

package/public-api.d.ts

@@ -0,0 +1,26 @@
+export * from './lib/dashboard.component';
+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';
+export * from './lib/dashboard.module';
+export * from './lib/dashboard.routes';
+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';
+export * from './lib/services/dashboard.service';
+export * from './lib/services/user-permissions.service';
+export * from './lib/assets/dashboard-route-paths.mock';
+export * from './lib/assets/dashboard-user-permissions.mock';
+export * from './lib/assets/dashboard-mock';