@ieeesa-npm/dashboard 0.0.1 → 0.0.2

package/lib/models/event-meeting-list-item.model.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Raw list item returned by the real "events & meetings" backend
+ * (`POST {apiBaseUrl}/meetings/eventsAndMeetings`). A single list may contain
+ * both EVENT rows (`isMeetingEvent === true` / `hasChildren === true`, which own
+ * child meetings) and STANDALONE MEETING rows (`isMeetingEvent === false`).
+ *
+ * Dates are epoch milliseconds (not ISO strings) and must be formatted with
+ * luxon `DateTime.fromMillis`. This shape mirrors the `events-and-meetings`
+ * library's `EventsAndMeetings` list model so the dashboard reuses the exact
+ * backend contract referenced by the existing
+ * `view-events-meetings-list` screen.
+ */
+export interface EventMeetingListItem {
+    /** Stable identifier of the event or standalone meeting. */
+    id: string;
+    /** Event / meeting display name. */
+    name: string;
+    /** Start date-time as an ISO-8601 string (or epoch ms for legacy fixtures). */
+    startDateTime: string | number;
+    /** End date-time as an ISO-8601 string (or epoch ms for legacy fixtures). */
+    endDateTime: string | number;
+    /** IANA / offset-prefixed timezone string, e.g. "(UTC+05:30) Asia/Kolkata". */
+    timeZone: string;
+    /** Owning group id. */
+    groupId?: string;
+    /** Owning group display name. */
+    groupName?: string;
+    /** Owning group acronym, when provided. */
+    groupAcronym?: string;
+    /** Room / location text, when provided. */
+    meetingLocation?: string | null;
+    /** True when this row is an EVENT that owns child meetings. */
+    hasChildren?: boolean;
+    /**
+     * True when the row represents an EVENT (vs. a standalone meeting). Combined
+     * with {@link hasChildren} this is the EVENT-vs-STANDALONE discriminator.
+     */
+    isMeetingEvent?: boolean;
+    /** Lifecycle status, e.g. "In Progress", "Upcoming", "Starts Soon". */
+    status?: string;
+    /** True when the signed-in user is a member of the owning group. */
+    isMemberOfGroup?: boolean;
+    /** True when the current user is currently attending (drives the pill). */
+    isCurrentlyAttending?: boolean;
+    /** True when the row is open for attendance logging. */
+    isOpenForAttendance?: boolean;
+    /** Event id a standalone/child meeting belongs to, when applicable. */
+    eventId?: string;
+    /** Meeting id, when the row is a meeting. */
+    meetingId?: string;
+    /** Alternate name key some payloads use for meetings. */
+    meetingTitle?: string;
+    /** Alternate status key (the list screen copies status here). */
+    contentUnderLink?: string;
+    /** Alternate location key used by some meeting payloads. */
+    room?: string | null;
+    /** Count of child meetings for an event, when the backend provides it. */
+    meetingCount?: number;
+    /** Count of child meetings open for attendance, when provided. */
+    openForAttendanceCount?: number;
+    /** "Day X of Y" indicator string, when the backend provides it. */
+    dayIndicator?: string;
+}
+/**
+ * Response envelope for the dashboard events-&-meetings list endpoint, matching
+ * the `events-and-meetings` library's `GetEventsAndMeetingsResponse` body shape.
+ */
+export interface EventMeetingListResponse {
+    status: boolean;
+    message?: string;
+    body: {
+        totalRecords: number;
+        eventMeetingList: EventMeetingListItem[];
+    };
+}
+/**
+ * Child-meeting list item returned by the per-event expand endpoint
+ * (`POST {apiBaseUrl}/meetings/meetingsDetails`). Dates are epoch milliseconds.
+ * Mirrors the `events-and-meetings` library's `Meeting` model.
+ */
+export interface EventMeetingDetailItem {
+    meetingId: string;
+    meetingTitle: string;
+    meetingStDate: string | number;
+    meetingEdDate: string | number;
+    meetingLocation?: string;
+    groupId?: string;
+    groupName?: string;
+    groupAcronym?: string;
+    timeZone?: string;
+    status?: string;
+    isMemberOfGroup?: boolean;
+    isCurrentlyAttending?: boolean;
+    isOpenForAttendance?: boolean;
+}
+/**
+ * Response envelope for the per-event child-meetings expand endpoint, matching
+ * the `events-and-meetings` library's `GetMeetingsByEventIdResponse` body shape.
+ */
+export interface EventMeetingDetailResponse {
+    status: boolean;
+    message?: string;
+    body: {
+        totalRecords: number;
+        meetings: EventMeetingDetailItem[];
+    };
+}

package/lib/models/event-meeting-list-payload.model.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Request payloads for the dashboard "events & meetings" backend calls. These
+ * mirror the `events-and-meetings` library's `GetEventsAndMeetingsPayload` /
+ * `GetMeetingsByEventIdPayload` so the dashboard reuses the exact contract the
+ * existing `view-events-meetings-list` screen posts.
+ */
+/** Filter block shared by the list and expand payloads. */
+export interface EventMeetingFilter {
+    /** Lifecycle statuses to include, e.g. ["In Progress", "Upcoming"]. */
+    status: string[];
+    /** Whether every meeting (regardless of membership) should be returned. */
+    isAllMeetingSelected: boolean;
+    /** Optional group-id scope. */
+    groupIds?: string[];
+}
+/** Payload for `POST {apiBaseUrl}/meetings/eventsAndMeetings` (the section list). */
+export interface EventMeetingListPayload {
+    payload: {
+        /** Null for the top-level list; an event id when scoping to one event. */
+        eventId: string | null;
+        sortColumn: string;
+        ascendingOrder: boolean;
+        page: number;
+        size: number;
+        searchTerm?: string | null;
+        filter: EventMeetingFilter;
+    };
+}
+/** Payload for `POST {apiBaseUrl}/meetings/meetingsDetails` (per-event expand). */
+export interface EventMeetingDetailPayload {
+    payload: {
+        eventId: string;
+        sortColumn: string;
+        ascendingOrder: boolean;
+        page: number;
+        size: number;
+        searchTerm?: string | null;
+        filter: EventMeetingFilter;
+    };
+}

package/lib/models/group-row.model.d.ts

@@ -1,3 +1,26 @@
+/**
+ * A single node in a group's ancestor hierarchy (root→leaf), as returned by
+ * GET /v1/groups/my-groups. Used to render the expandable hierarchy rows in the
+ * Your Groups table.
+ */
+export interface GroupHierarchyNode {
+    groupId: string;
+    groupName: string;
+    groupShortName?: string;
+    groupAcronym?: string;
+    groupLevel?: number;
+    groupParentId?: string | null;
+    groupType?: string;
+    groupTypeName?: string | null;
+    groupDesc?: string | null;
+    hasChildren?: boolean | null;
+}
+/**
+ * Table-facing view of a group in the Your Groups section. The display fields
+ * are mapped from the backend; `hierarchy` carries the group's ancestor path so
+ * the row can expand to show the hierarchy (matching the My Profile Find Groups
+ * tree).
+ */
 export interface GroupRow {
     groupId: string;
     group: string;
@@ -5,4 +28,6 @@ export interface GroupRow {
     officerRole?: string;
     affiliation?: string;
     memberLevel: string;
+    /** Ancestor hierarchy (root→leaf) for the expandable hierarchy rows. */
+    hierarchy?: GroupHierarchyNode[];
 }

package/lib/models/meeting-row.model.d.ts

@@ -1,12 +1,28 @@
 import { AttendanceState } from './attendance-state.model';
+/**
+ * View model for a single meeting row, used both for an event's expanded child
+ * meetings and (via {@link UpcomingEvent}) for standalone meeting cards.
+ *
+ * `startEpochMs` / `endEpochMs` carry the raw epoch-milliseconds values from the
+ * backend and are formatted with luxon `DateTime.fromMillis`. The legacy ISO
+ * `meetingDate` / `meetingTime` fields are retained for existing fixtures/tests.
+ */
 export interface MeetingRow {
     meetingId: string;
     meetingName: string;
     groupOrCommittee?: string;
     roomOrLocation?: string;
-    meetingDate: string;
-    meetingTime: string;
+    /** 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 meeting date, retained for fixtures/tests. */
+    meetingDate?: string;
+    /** Legacy ISO meeting time, retained for fixtures/tests. */
+    meetingTime?: string;
     timezone: string;
+    status?: string;
+    isMemberOfGroup?: boolean;
     isOpenForAttendance?: boolean;
     attendanceState?: AttendanceState;
 }

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/upcoming-event.model.d.ts

@@ -1,13 +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;
-    startDate: string;
-    endDate: string;
+    /** 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/dashboard.service.d.ts

@@ -5,7 +5,9 @@ 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
@@ -16,11 +18,12 @@ import * as i0 from "@angular/core";
  * 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.
+ * 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
  */
@@ -58,16 +61,75 @@ export declare class DashboardService {
      */
     setAppConfig(apiBaseURL: string, userPermissions: UserPermission[]): void;
     /**
-     * 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.
+     * 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
      */
-    loadUpcomingEvents(): Observable<DashboardListResponse<UpcomingEvent[]>>;
+    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
@@ -77,7 +139,18 @@ export declare class DashboardService {
      * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.
      * @memberof DashboardService
      */
-    loadGroups(): Observable<DashboardListResponse<GroupRow[]>>;
+    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
@@ -114,6 +187,16 @@ export declare class DashboardService {
      * @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/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,6 @@
 {
   "name": "@ieeesa-npm/dashboard",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "peerDependencies": {
     "@angular/common": "^16.1.0",
     "@angular/core": "^16.1.0",

package/public-api.d.ts

@@ -14,6 +14,8 @@ 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';