@feedmepos/mf-hrm-portal 2.2.4 → 2.2.5-dev.10

package/dist/src/views/scheduling/composables/useScheduleDemand.d.ts

@@ -0,0 +1,76 @@
+import type { CoverageSegment, DaySlot, DemandPeriod, Employee, Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export declare function toMin(t: string): number;
+export declare function minToHHMM(m: number): string;
+/** Minutes from midnight for a start/end pair, with the end pushed past 1440 when it wraps —
+ * so an overnight stretch stays one interval rather than two that cross zero. */
+export declare function spanOf(start: string, end: string): [number, number];
+/** 12-hour clock for prose — the sheet and the popovers read as sentences, and "16:00" in the
+ * middle of one does not. */
+export declare function t12(hhmm: string): string;
+/** The timeline's two end labels — "8am", "10:30pm", meridiem spelled out. */
+export declare function minToShort(m: number): string;
+export declare function rangeText(from: number, to: number): string;
+export declare function roleTotalOf(p: DemandPeriod): number;
+/** The unnamed part of a period's headcount. Derived, never typed — so it cannot disagree with
+ * the total above it. Negative means the breakdown has overrun that total. */
+export declare function anyLeftOf(p: DemandPeriod): number;
+export interface ScheduleCoverageAxis {
+    from: number;
+    to: number;
+}
+/** Staffing demand, and coverage read against it.
+ *
+ * Storage follows this board's dayNotes rather than the mockup's flat `di` index: the mockup
+ * renders one long horizon so a day index identifies a date, but this board pages through
+ * weeks, and demand put on this Monday must not reappear on every other Monday. So a date's
+ * own demand is keyed by ISO date, and a standing weekday rule is keyed by weekday index.
+ *
+ * A date's own demand wins over the weekday rule it would otherwise inherit — "every Tuesday
+ * needs eight" is a standing statement, and "this Tuesday is different" has to be able to
+ * override it without rewriting the rule. */
+export declare function useScheduleDemand(board: ScheduleBoardApi): {
+    byDate: Record<string, DemandPeriod[]>;
+    byWeekday: Record<number, DemandPeriod[]>;
+    demandFor: (dayIdx: number) => DemandPeriod[];
+    hasDemandOn: (dayIdx: number) => boolean;
+    demandIsOwn: (dayIdx: number) => boolean;
+    setDateDemand: (dayIdx: number, periods: DemandPeriod[]) => void;
+    clearDateDemand: (dayIdx: number) => void;
+    setWeekdayDemand: (weekday: number, periods: DemandPeriod[]) => void;
+    coverageAxis: (dayIdx: number) => ScheduleCoverageAxis;
+    coverageSegments: (dayIdx: number) => CoverageSegment[];
+    setPreview: (items: Proposal[]) => void;
+    segmentsWith: (dayIdx: number, employees: Employee[]) => CoverageSegment[];
+    dayHeadcount: (dayIdx: number) => {
+        crew: number;
+        peak: number;
+    };
+    coverageImpact: (dayIdx: number, empId: number | null, slot: DaySlot) => {
+        when: string;
+        pctBefore: number;
+        pctAfter: number;
+        stillShort: number;
+        before: {
+            required: number;
+            scheduled: number;
+        };
+        after: {
+            required: number;
+            scheduled: number;
+        };
+        beforeSegs: CoverageSegment[];
+        afterSegs: CoverageSegment[];
+        axis: ScheduleCoverageAxis;
+    } | null;
+    coveragePct: (dayIdx: number) => number | null;
+    shortSegs: (dayIdx: number) => CoverageSegment[];
+    shortInRange: (dayIdx: number, start: string, end: string) => number;
+    biggestGap: (dayIdx: number) => CoverageSegment | null;
+    rangeSummary: import("vue").ComputedRef<{
+        live: number;
+        set: number;
+        shortDays: number;
+    }>;
+};
+export type ScheduleDemandApi = ReturnType<typeof useScheduleDemand>;

package/dist/src/views/scheduling/composables/useScheduleDemandRow.d.ts

@@ -0,0 +1,45 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export type ScheduleSegState = 'met' | 'short' | 'over' | 'nodem';
+export interface ScheduleDemandSeg {
+    key: string;
+    from: number;
+    to: number;
+    state: ScheduleSegState;
+    /** Percentage of the day's axis this segment occupies — width means duration. */
+    width: string;
+    label: string;
+}
+export interface ScheduleDemandCell {
+    dayIdx: number;
+    closed: boolean;
+    /** No demand stated on this day — the cell carries its own "+ Set demand" instead. */
+    blank: boolean;
+    pct: number;
+    tone: '' | 'part' | 'short';
+    segs: ScheduleDemandSeg[];
+    hoursFrom: string;
+    hoursTo: string;
+    pctTitle: string;
+    title: string;
+}
+/** What the coverage band draws, one cell per visible day.
+ *
+ * The percentage is the headline and the strip is the reason — a day can be 81% covered with
+ * the missing fifth spread thinly or concentrated at six o'clock, and only one of those is a
+ * problem you act on tonight. */
+export declare function useScheduleDemandRow(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
+    cellFor: (dayIdx: number) => ScheduleDemandCell;
+    cells: import("vue").ComputedRef<{
+        dayIdx: number;
+        colIndex: number;
+        cell: ScheduleDemandCell;
+    }[]>;
+    lead: import("vue").ComputedRef<{
+        blank: boolean;
+        name: string;
+        meta: string;
+    }>;
+    dayTitle: (dayIdx: number) => string;
+};
+export type ScheduleDemandRowApi = ReturnType<typeof useScheduleDemandRow>;

package/dist/src/views/scheduling/composables/useScheduleDemandSheet.d.ts

@@ -0,0 +1,145 @@
+import type { DemandApplyMode, DemandPeriod } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export interface ScheduleDemandSuggestion {
+    why: string;
+    periods: DemandPeriod[];
+}
+export interface ScheduleDemandSheetOptions {
+    onToast?: (message: string) => void;
+    /** Positions the breakdown can name — the same list the shift editor offers. */
+    positionOptions: () => string[];
+    /** Called instead of a toast when "+ Position breakdown" is pressed and there is no position
+     * to name yet — the page opens its Add Position popup for that period. */
+    onNeedPosition?: (periodIdx: number, roleIdx: number) => void;
+}
+/** The demand sheet — editing happens on a DRAFT, so Save is a real commit and closing is a
+ * real cancel. The sheet also carries the recurrence choice, because "every Tuesday" is a
+ * property of the statement being made rather than a second screen. */
+export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand: ScheduleDemandApi, opts: ScheduleDemandSheetOptions): {
+    open: import("vue").Ref<boolean, boolean>;
+    dayIdx: import("vue").Ref<number | null, number | null>;
+    periods: import("vue").Ref<{
+        from: string;
+        to: string;
+        n: number;
+        roles?: {
+            position: string;
+            n: number;
+        }[] | undefined;
+    }[], DemandPeriod[] | {
+        from: string;
+        to: string;
+        n: number;
+        roles?: {
+            position: string;
+            n: number;
+        }[] | undefined;
+    }[]>;
+    apply: import("vue").Ref<DemandApplyMode, DemandApplyMode>;
+    applyOptions: import("vue").ComputedRef<({
+        on: boolean;
+        key: "day";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "every";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "weekdays";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "custom";
+        label: string;
+        sub: string;
+    })[]>;
+    weekdayButtons: import("vue").ComputedRef<{
+        i: number;
+        label: string;
+        on: boolean;
+    }[]>;
+    toggleCustomDay: (i: number) => void;
+    applyNote: import("vue").ComputedRef<string>;
+    overlapWarning: import("vue").ComputedRef<string>;
+    whenLabel: import("vue").ComputedRef<string>;
+    openFor: (idx: number) => void;
+    close: () => void;
+    addPeriod: () => void;
+    removePeriod: (i: number) => void;
+    setHeads: (i: number, value: number | string) => void;
+    addRole: (i: number) => void;
+    addRoleNamed: (i: number, position: string) => void;
+    requestNewPosition: (i: number, k: number) => void;
+    removeRole: (i: number, k: number) => void;
+    setRoleCount: (i: number, k: number, value: number | string) => void;
+    setRolePosition: (i: number, k: number, position: string) => void;
+    anyLeft: (p: DemandPeriod) => number;
+    coverageRows: import("vue").ComputedRef<{
+        when: string;
+        required: number;
+        scheduled: number;
+        varies: boolean;
+        pct: number;
+        tone: "short" | "part" | "met" | "over";
+        note: string;
+    }[]>;
+    coverageTotal: import("vue").ComputedRef<{
+        required: number;
+        scheduled: number;
+        pct: number;
+        tone: "short" | "part" | "met" | "over";
+        note: string;
+    }>;
+    saving: import("vue").Ref<boolean, boolean>;
+    save: () => Promise<void>;
+    suggestion: import("vue").Ref<{
+        why: string;
+        periods: {
+            from: string;
+            to: string;
+            n: number;
+            roles?: {
+                position: string;
+                n: number;
+            }[] | undefined;
+        }[];
+    } | null, ScheduleDemandSuggestion | {
+        why: string;
+        periods: {
+            from: string;
+            to: string;
+            n: number;
+            roles?: {
+                position: string;
+                n: number;
+            }[] | undefined;
+        }[];
+    } | null>;
+    suggestionRows: import("vue").ComputedRef<{
+        when: string;
+        n: number;
+        word: string;
+    }[]>;
+    suggest: () => void;
+    acceptSuggestion: () => void;
+    dismissSuggestion: () => void;
+    canCopy: import("vue").ComputedRef<boolean>;
+    copyOpen: import("vue").Ref<boolean, boolean>;
+    copyPicks: Record<number, boolean>;
+    copyRows: import("vue").ComputedRef<{
+        dayIdx: number;
+        label: string;
+        sub: string;
+    }[]>;
+    copySub: import("vue").ComputedRef<string>;
+    openCopy: () => void;
+    closeCopy: () => void;
+    confirmCopy: () => Promise<void>;
+    setApply: (k: DemandApplyMode) => DemandApplyMode;
+};
+export type ScheduleDemandSheetApi = ReturnType<typeof useScheduleDemandSheet>;

package/dist/src/views/scheduling/composables/useScheduleDragDrop.d.ts

@@ -0,0 +1,22 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleDragPayload {
+    empId: number;
+    dayIdx: number;
+}
+/** Native HTML5 drag & drop for moving an existing shift card between employee/day cells.
+ * The mockup's other drag source — a staff-rail row dragged onto an open shift — is an
+ * area-view feature (`r.draggable = viewMode === 'area'` there); this board is employee-view
+ * only, so that gesture doesn't exist here — filling an open shift goes through the Assign
+ * popover (click) instead. */
+export declare function useScheduleDragDrop(board: ScheduleBoardApi): {
+    dragging: import("vue").Ref<{
+        empId: number;
+        dayIdx: number;
+    } | null, ScheduleDragPayload | {
+        empId: number;
+        dayIdx: number;
+    } | null>;
+    startShiftDrag: (empId: number, dayIdx: number, ev: DragEvent) => void;
+    endDrag: () => void;
+    dropOnCell: (targetEmpId: number, targetDayIdx: number) => void;
+};

package/dist/src/views/scheduling/composables/useScheduleEmployeeIdentity.d.ts

@@ -0,0 +1,41 @@
+import type { Employee, Proposal } from '../types';
+/** The one form every SMALL avatar wears — `.sc-av`, `.ch-av`, `.ap-av`, `.tl-av`, and the
+ * shift editor's `.sp2-who-av`. A tint of the person's colour behind their own colour, never a
+ * solid fill with white text: at 17–30px the initials are the only identifier, and knocking
+ * them out to white on a saturated disc costs the contrast that makes them legible.
+ *
+ * None of those classes declare a background of their own, so they REQUIRE this — a bare
+ * `<span class="sc-av">` renders as an invisible disc.
+ *
+ * The big identity avatars are the opposite case and take no inline style at all: `.emp-avatar`,
+ * `.dp-emp-av` and `.pub-change-av` are neutral in CSS, because a name sits right beside them
+ * and a filled disc would out-shout it. */
+export declare function avatarTint(color?: string | null): Record<string, string>;
+export interface ScheduleEmployeeLoad {
+    emp: Employee;
+    hours: number;
+    cost: number;
+    contract: number;
+    partTime: boolean;
+    /** Hours as a fraction of contract, capped at 1 — the load bar's width. */
+    pct: number;
+    barColor: string;
+    otHours: number;
+    /** Of `hours`, how many are auto-schedule suggestions not yet on the board. */
+    proposedHours: number;
+    /** The board's own hours as a fraction of contract: where the fill ends and the suggested part starts. */
+    boardPct: number;
+    /** The suggested part's width on the bar, as a fraction of contract. With no contract to measure
+     * against it fills the track, so suggested hours still show. */
+    proposedPct: number;
+}
+/** This person's live (not rejected) suggestions in the week on screen. */
+export declare function proposedSlotsOf(emp: Employee, proposalAt?: (empId: number, dayIdx: number) => Proposal | undefined): Pick<Proposal, 'start' | 'end'>[];
+/** One person's load against their contract, derived from the shifts actually on the board
+ * rather than from the stored `weekHours` field, so the bar can never disagree with the row
+ * of cards beside it.
+ *
+ * The staff rail (area view) and the grid's name column (employee view) are the same list of
+ * the same people; they used to be two pieces of markup reading two different numbers. This
+ * is the single one — the mockup's own note on empIdentityHTML(). */
+export declare function employeeLoadOf(emp: Employee, proposed?: Pick<Proposal, 'start' | 'end'>[]): ScheduleEmployeeLoad;

package/dist/src/views/scheduling/composables/useScheduleEmployeeMenu.d.ts

@@ -0,0 +1,35 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleAnchorRect } from './schedule-popover-position';
+export type ScheduleEmployeeMenuAction = 'profile' | 'edit' | 'hl' | 'remove';
+export interface ScheduleEmployeeMenuState {
+    open: boolean;
+    empId: number | null;
+    anchor: ScheduleAnchorRect | null;
+    left: number;
+    top: number;
+}
+/** The ⋯ menu on a team member's row — V6.2's #empMenu: profile, update, highlight, remove. The actions that need a page-level surface (profile panel,
+ * edit wizard, confirm dialog) come in as handlers; highlight lives here. */
+export declare function useScheduleEmployeeMenu(board: ScheduleBoardApi, handlers: {
+    onProfile: (empId: number) => void;
+    onEdit: (empId: number) => void;
+    onRemove: (empId: number) => void;
+}): {
+    state: {
+        open: boolean;
+        empId: number | null;
+        anchor: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        } | null;
+        left: number;
+        top: number;
+    };
+    employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
+    openFor: (empId: number, anchor: HTMLElement) => void;
+    close: () => void;
+    go: (action: ScheduleEmployeeMenuAction) => void;
+};
+export type ScheduleEmployeeMenuApi = ReturnType<typeof useScheduleEmployeeMenu>;

package/dist/src/views/scheduling/composables/useScheduleEmployeeProfile.d.ts

@@ -0,0 +1,16 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleEmployeeProfileState {
+    open: boolean;
+    empId: number | null;
+}
+/** Employee profile side sheet — opened from the staff-rail row menu or by clicking
+ * an employee's identity block. */
+export declare function useScheduleEmployeeProfile(board: ScheduleBoardApi): {
+    state: {
+        open: boolean;
+        empId: number | null;
+    };
+    employee: import("vue").ComputedRef<import("../types").Employee | null>;
+    openFor: (empId: number) => void;
+    close: () => void;
+};

package/dist/src/views/scheduling/composables/useScheduleExport.d.ts

@@ -0,0 +1,26 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ExportShiftCell {
+    note: string;
+    shifts: {
+        when: string;
+        pos: string;
+    }[];
+}
+export interface ExportMatrix {
+    head: string[];
+    body: (string | ExportShiftCell)[][];
+    foot: string[];
+}
+/** The mockup's Share/export feature (buildExportMatrix/exportPDF/exportJPG) — no external
+ * PDF/canvas library anywhere in the mockup; PDF is an HTML preview handed to window.print(),
+ * JPG is a hand-drawn Canvas 2D table converted with toBlob. */
+export declare function useScheduleExport(board: ScheduleBoardApi): {
+    buildExportMatrix: () => ExportMatrix;
+    pdfPreviewOpen: import("vue").Ref<boolean, boolean>;
+    pdfHtml: import("vue").ComputedRef<string>;
+    openPdfPreview: () => void;
+    closePdfPreview: () => void;
+    printNow: () => void;
+    exportJpg: () => void;
+};
+export type ScheduleExportApi = ReturnType<typeof useScheduleExport>;

package/dist/src/views/scheduling/composables/useScheduleFilterBar.d.ts

@@ -0,0 +1,14 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export type ScheduleViewMode = 'area' | 'employee';
+export type ScheduleGranularity = 'day' | 'week';
+/** State for the filter-bar's mode/granularity selects. Granularity delegates straight to
+ * the board, which owns the day/week grid state — both area and employee grouping combine
+ * with either granularity. Outlet switching isn't modeled at all yet, so that control has
+ * no state here; it's a static label in the component. */
+export declare function useScheduleFilterBar(board: ScheduleBoardApi): {
+    mode: import("vue").Ref<ScheduleViewMode, ScheduleViewMode>;
+    granularity: import("vue").Ref<import("./useScheduleBoard").ScheduleGranularity, import("./useScheduleBoard").ScheduleGranularity>;
+    setMode: (value: ScheduleViewMode) => boolean;
+    setGranularity: (value: ScheduleGranularity) => boolean;
+};
+export type ScheduleFilterBarApi = ReturnType<typeof useScheduleFilterBar>;

package/dist/src/views/scheduling/composables/useScheduleGapPopover.d.ts

@@ -0,0 +1,82 @@
+import type { CoverageSegment } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+import type { ScheduleAssignApi } from './useScheduleAssign';
+export interface ScheduleGapActions {
+    /** Open the shift editor on a brand new shift for this day and these hours. */
+    addShift: (dayIdx: number, position: string, start: string, end: string) => void;
+}
+export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi, assign: ScheduleAssignApi, actions: ScheduleGapActions): {
+    state: {
+        open: boolean;
+        pinned: boolean;
+        peek: boolean;
+        wide: boolean;
+        left: number;
+        top: number;
+    };
+    ctx: import("vue").Ref<{
+        from: number;
+        to: number;
+        required: number;
+        scheduled: number;
+        short: number;
+        over: number;
+        roles: {
+            position: string;
+            n: number;
+            required: number;
+            got: number;
+            short: number;
+        }[];
+        anyReq: number;
+        anyGot: number;
+        none: boolean;
+        dayIdx: number;
+    } | null, (CoverageSegment & {
+        dayIdx: number;
+    }) | {
+        from: number;
+        to: number;
+        required: number;
+        scheduled: number;
+        short: number;
+        over: number;
+        roles: {
+            position: string;
+            n: number;
+            required: number;
+            got: number;
+            short: number;
+        }[];
+        anyReq: number;
+        anyGot: number;
+        none: boolean;
+        dayIdx: number;
+    } | null>;
+    view: import("vue").ComputedRef<{
+        crew: number;
+        peak: number;
+        when: string;
+        day: string;
+        none: boolean;
+        required: number;
+        scheduled: number;
+        short: number;
+        over: number;
+        missing: {
+            short: number;
+            position: string;
+        }[];
+        missingNote: string;
+    } | null>;
+    segEnter: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
+    segLeave: () => void;
+    hold: () => void;
+    segClick: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
+    segFocus: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
+    addShift: () => void;
+    suggestStaffing: () => void;
+    close: () => void;
+};
+export type ScheduleGapPopoverApi = ReturnType<typeof useScheduleGapPopover>;

package/dist/src/views/scheduling/composables/useScheduleLeave.d.ts

@@ -0,0 +1,70 @@
+import type { LeaveSlot } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** What a day off can be booked as. "Rest Day" leads: it is the most-used reason a day is not
+ * worked. */
+export declare const LEAVE_REASONS: string[];
+/** The type the menu's plain "Leave" row books. */
+export declare const DEFAULT_LEAVE_REASON = "Annual Leave";
+export type ScheduleLeaveMode = 'all' | 'am' | 'pm' | 'custom';
+export interface ScheduleLeaveState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    /** Booking a new record, rather than editing one that is already on the day. */
+    isNew: boolean;
+    reason: string;
+    mode: ScheduleLeaveMode;
+    /** The hours when mode is 'custom'. */
+    from: string;
+    to: string;
+}
+/** The leave editor — V6.2's "Book leave" dialog: a reason, how much of the day it covers, and
+ * what that does to the person's availability. Opened from the add popup's Rest Day / Leave rows
+ * (booking) and from an existing leave card (editing, or approving a pending request). */
+export declare function useScheduleLeave(board: ScheduleBoardApi): {
+    state: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        isNew: boolean;
+        reason: string;
+        mode: ScheduleLeaveMode;
+        from: string;
+        to: string;
+    };
+    employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
+    activeSlot: import("vue").ComputedRef<LeaveSlot | null>;
+    options: import("vue").ComputedRef<({
+        hrs: string;
+        mode: "custom";
+        name: "Specific hours";
+    } | {
+        hrs: string;
+        mode: "all";
+        name: "All day";
+    } | {
+        hrs: string;
+        mode: "am";
+        name: "Morning";
+    } | {
+        hrs: string;
+        mode: "pm";
+        name: "Afternoon";
+    })[]>;
+    span: import("vue").ComputedRef<{
+        from: string;
+        to: string;
+        hours: number;
+    }>;
+    valid: import("vue").ComputedRef<boolean>;
+    dayLabel: import("vue").ComputedRef<string>;
+    hoursText: import("vue").ComputedRef<string>;
+    coverText: import("vue").ComputedRef<string>;
+    openFor: (empId: number, dayIdx: number, reason?: string | null) => void;
+    close: () => void;
+    save: () => void;
+    approve: () => void;
+    reject: () => void;
+    remove: () => void;
+};
+export type ScheduleLeaveApi = ReturnType<typeof useScheduleLeave>;

package/dist/src/views/scheduling/composables/useScheduleLegend.d.ts

@@ -0,0 +1,15 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleCoverageBadge {
+    position: string;
+    required: number;
+    scheduled: number;
+    short: boolean;
+}
+/** Coverage badges for a day's header card — required vs. scheduled headcount per
+ * position, from the single active shift template's coverage matrix. */
+export declare function useScheduleLegend(board: ScheduleBoardApi): {
+    coveragePositions: import("vue").ComputedRef<string[]>;
+    coverageForDay: (dayIdx: number) => ScheduleCoverageBadge[];
+    dayIsShort: (dayIdx: number) => boolean;
+    dayCardTitle: (dayIdx: number) => string;
+};

package/dist/src/views/scheduling/composables/useScheduleLegendBar.d.ts

@@ -0,0 +1,35 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
+export type ScheduleLegendKey = 'empty' | 'draft' | 'pub' | 'open' | 'warn' | 'ot' | 'leave';
+export interface ScheduleLegendItem {
+    key: ScheduleLegendKey;
+    count: number;
+    label: string;
+    /** The warnings figure is the one worth acting on, so it renders as a control that
+     * cycles the grid through each conflict — see jumpToConflict(). */
+    action: boolean;
+    title?: string;
+}
+interface ScheduleConflictRef {
+    empId: number;
+    dayIdx: number;
+    name: string;
+}
+export interface ScheduleLegendBarOptions {
+    /** Toast for the conflict cycle — "Conflict 2 of 5 · Nadia, Wed". */
+    onJump?: (message: string) => void;
+}
+/** The footer legend under the scheduler: every state a card can be in, counted off the
+ * same records the grid renders. Ported from the mockup's renderLegend(). Every figure is
+ * scoped to the days currently on screen, except warnings — which counts the whole week, so
+ * the number stays stable while jumpToConflict() pages through days one at a time (the
+ * mockup's conflictCount() is likewise whole-data rather than span-scoped).
+ *
+ * Distinct from useScheduleLegend, which is the day header's coverage badges. */
+export declare function useScheduleLegendBar(board: ScheduleBoardApi, areaBoard: ScheduleAreaBoardApi, opts?: ScheduleLegendBarOptions): {
+    items: import("vue").ComputedRef<ScheduleLegendItem[]>;
+    conflicts: import("vue").ComputedRef<ScheduleConflictRef[]>;
+    jumpToConflict: () => void;
+};
+export type ScheduleLegendBarApi = ReturnType<typeof useScheduleLegendBar>;
+export {};