@feedmepos/mf-hrm-portal 2.2.5-dev.7 → 2.2.5-dev.9

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

@@ -19,6 +19,7 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
         payBasis: "hourly" | "monthly";
         payAmount: string;
         maxHours: string;
+        minHours: string;
         otAfterDaily: string;
         maxOtHours: string;
         availDays: boolean[];
@@ -32,6 +33,8 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
         seniority: "" | "senior" | "junior";
         passcode: string[];
         masterUser: boolean;
+        roleId: string;
+        masterCode: string;
     };
     sectionId: import("vue").Ref<string, string>;
     isEditing: import("vue").ComputedRef<boolean>;
@@ -48,6 +51,15 @@ export declare function useScheduleAddEmployee(board: ScheduleBoardApi): {
     effectiveRate: import("vue").ComputedRef<number>;
     passcodeValue: import("vue").ComputedRef<string>;
     passcodeOk: import("vue").ComputedRef<boolean>;
+    currentLocationLabel: import("vue").ComputedRef<string>;
+    roleOptions: import("vue").ComputedRef<{
+        value: string;
+        label: string;
+    }[]>;
+    roleError: import("vue").ComputedRef<boolean>;
+    masterCodeError: import("vue").ComputedRef<boolean>;
+    isNewUser: import("vue").ComputedRef<boolean>;
+    needsRole: import("vue").ComputedRef<boolean>;
     footerHint: import("vue").ComputedRef<"Pick who — this outlet's own pay, position and hours are still set here." | "One short form. Rest days are set on their profile afterwards.">;
     primaryRoleLabel: import("vue").ComputedRef<string>;
     locationsSummary: import("vue").ComputedRef<string>;

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

@@ -1,16 +1,15 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type ScheduleAnchorRect } from './schedule-popover-position';
 export interface ScheduleAddPickState {
     open: boolean;
     empId: number | null;
     dayIdx: number | null;
+    /** Measured rect of the cell the popup opened from; the popup component places itself from it
+     * once rendered (V6.2 placePopover), writing the result to `left`/`top`. */
+    anchor: ScheduleAnchorRect | null;
     left: number;
-    /** Only one of `top`/`bottom` is live at a time, picked by `openAbove` — anchoring from the
-     * bottom when flipped up lets the box grow with its own content (the query input plus
-     * however many pick-list rows there are) instead of a height guessed in JS. */
     top: number;
-    bottom: number;
-    openAbove: boolean;
 }
 export interface ScheduleAddPickLeaveOption {
     reason: string;
@@ -21,6 +20,8 @@ export interface ScheduleAddPickSuggestion {
     end: string;
     short: number;
     label: string;
+    /** "Covers 16:00–22:00 demand" — the demand this offer answers, shown under the label. */
+    covers: string;
     title: string;
 }
 /** The "+ Add" quick-pick popover on an employee's empty cell — ported from the mockup's
@@ -35,15 +36,21 @@ export interface ScheduleAddPickSuggestion {
 export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: ScheduleDemandApi, handlers: {
     onCommitted: (message: string) => void;
     onOpenFullEditor: (empId: number, dayIdx: number) => void;
+    /** The leave editor, on this cell. `reason` is the row's own type, or null for the plain "Leave" row. */
+    onOpenLeave: (empId: number, dayIdx: number, reason: string | null) => void;
 }): {
     state: {
         open: boolean;
         empId: number | null;
         dayIdx: number | null;
+        anchor: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        } | null;
         left: number;
         top: number;
-        bottom: number;
-        openAbove: boolean;
     };
     query: import("vue").Ref<string, string>;
     parsedRange: import("vue").ComputedRef<{

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

@@ -51,6 +51,11 @@ export interface ScheduleAssignGroup {
 export interface ScheduleAssignSlot {
     key: string;
     position: string;
+    /** One requirement of a demand gap: shows whether the people scheduled fulfil it (progress bar),
+     * and can be picked to assign people as that position. */
+    tracker?: boolean;
+    /** 0–100, for a tracker's progress bar. */
+    pct?: number;
     start: string;
     end: string;
     chip: string;
@@ -98,14 +103,18 @@ export declare function useScheduleAssign(board: ScheduleBoardApi, demand: Sched
         breakMins?: number | undefined;
     } | null>;
     title: import("vue").ComputedRef<string>;
-    sub: import("vue").ComputedRef<string>;
+    subParts: import("vue").ComputedRef<{
+        position: string;
+        range: string;
+        duration: string;
+    } | null>;
     footLead: import("vue").ComputedRef<string>;
     footRest: import("vue").ComputedRef<string>;
     groups: import("vue").ComputedRef<ScheduleAssignGroup[]>;
     shiftSlots: import("vue").ComputedRef<ScheduleAssignSlot[]>;
     switchTo: (slot: ScheduleAssignSlot) => void;
     openFor: (openShiftId: number) => void;
-    openForGap: (dayIdx: number, position: string, start: string, end: string, required: number, scheduled: number, gapFrom: number, gapTo: number) => void;
+    openForGap: (dayIdx: number, _position: string, start: string, end: string, required: number, scheduled: number, gapFrom: number, gapTo: number) => void;
     close: () => void;
     fillOpenShift: (openShiftId: number, empId: number) => void;
     armAssign: (empId: number) => void;

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

@@ -7,6 +7,11 @@ export interface ScheduleAutoScheduleOptions {
     fillGaps: boolean;
     objective: FdtoScheduleAutoScheduleObjective;
     allowOvertime: boolean;
+    /** Shown as preferences in the dialog but not sent: the generator takes no input for them yet
+     * (availability and time off are always respected; patterns and cost ride on the objective). */
+    respectAvailability: boolean;
+    followPatterns: boolean;
+    costEfficient: boolean;
 }
 /** Backend-powered draft generation and local proposal review. Generation never writes;
  * accepted proposals use the board's existing assignment persistence path. */
@@ -17,6 +22,9 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
         fillGaps: boolean;
         objective: FdtoScheduleAutoScheduleObjective;
         allowOvertime: boolean;
+        respectAvailability: boolean;
+        followPatterns: boolean;
+        costEfficient: boolean;
     };
     generating: import("vue").Ref<boolean, boolean>;
     generateError: import("vue").Ref<string | null, string | null>;
@@ -94,22 +102,16 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
         solver: string;
     } | null>;
     gapCount: import("vue").ComputedRef<number>;
+    hasDemand: import("vue").ComputedRef<boolean>;
+    noDemandOpen: import("vue").Ref<boolean, boolean>;
+    rangeLabel: import("vue").ComputedRef<string>;
     openWizard: () => void;
     closeWizard: () => void;
     next: () => void;
     back: () => void;
     generate: () => Promise<void>;
-    reviewMode: import("vue").Ref<boolean, boolean>;
-    proposals: import("vue").Ref<{
-        id: number;
-        empId: number;
-        dayIdx: number;
-        start: string;
-        end: string;
-        role: string;
-        openId?: number | undefined;
-        status: "pending" | "rejected";
-    }[], Proposal[] | {
+    reviewMode: import("vue").ComputedRef<boolean>;
+    proposals: import("vue").ComputedRef<{
         id: number;
         empId: number;
         dayIdx: number;
@@ -118,7 +120,10 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
         role: string;
         openId?: number | undefined;
         status: "pending" | "rejected";
+        weekKey?: string | undefined;
+        reason?: string | undefined;
     }[]>;
+    weekHasProposals: import("vue").ComputedRef<boolean>;
     unmetCount: import("vue").Ref<number, number>;
     acceptedCount: import("vue").ComputedRef<number>;
     rejectedCount: import("vue").ComputedRef<number>;
@@ -128,6 +133,8 @@ export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand:
     conflictCount: import("vue").ComputedRef<number>;
     projectedCost: import("vue").ComputedRef<number | null>;
     proposalAt: (empId: number, dayIdx: number) => Proposal | undefined;
+    draggingId: import("vue").Ref<number | null, number | null>;
+    moveProposal: (id: number, empId: number, dayIdx: number) => string | null;
     toggleReject: (id: number) => void;
     rejectAll: () => void;
     exitReview: () => void;

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

@@ -56,6 +56,8 @@ export declare function useScheduleBoard(handlers?: {
             reason: string;
             half?: boolean | undefined;
             halfPart?: "AM" | "PM" | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
             appliedOn?: string | undefined;
             note?: string | undefined;
             cert?: {
@@ -98,6 +100,7 @@ export declare function useScheduleBoard(handlers?: {
         payAmount?: number | undefined;
         maxHours?: number | undefined;
         maxOtHours?: number | undefined;
+        minHours?: number | undefined;
         otAfterDaily?: number | undefined;
         preferences?: string[] | undefined;
         seniority?: "senior" | "junior" | "" | undefined;
@@ -139,6 +142,8 @@ export declare function useScheduleBoard(handlers?: {
             reason: string;
             half?: boolean | undefined;
             halfPart?: "AM" | "PM" | undefined;
+            from?: string | undefined;
+            to?: string | undefined;
             appliedOn?: string | undefined;
             note?: string | undefined;
             cert?: {
@@ -181,6 +186,7 @@ export declare function useScheduleBoard(handlers?: {
         payAmount?: number | undefined;
         maxHours?: number | undefined;
         maxOtHours?: number | undefined;
+        minHours?: number | undefined;
         otAfterDaily?: number | undefined;
         preferences?: string[] | undefined;
         seniority?: "senior" | "junior" | "" | undefined;
@@ -228,6 +234,7 @@ export declare function useScheduleBoard(handlers?: {
         end: string;
         breakMins?: number | undefined;
     }[]>;
+    highlightEmpId: import("vue").Ref<number | null, number | null>;
     rangeStart: import("vue").Ref<Date, Date>;
     weekOffset: import("vue").ComputedRef<number>;
     peekWeek: (offset: number) => import("./schedule-week-cache").WeekBucket;
@@ -283,6 +290,8 @@ export declare function useScheduleBoard(handlers?: {
                 reason: string;
                 half?: boolean | undefined;
                 halfPart?: "AM" | "PM" | undefined;
+                from?: string | undefined;
+                to?: string | undefined;
                 appliedOn?: string | undefined;
                 note?: string | undefined;
                 cert?: {
@@ -342,6 +351,8 @@ export declare function useScheduleBoard(handlers?: {
                 reason: string;
                 half?: boolean | undefined;
                 halfPart?: "AM" | "PM" | undefined;
+                from?: string | undefined;
+                to?: string | undefined;
                 appliedOn?: string | undefined;
                 note?: string | undefined;
                 cert?: {

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

@@ -10,8 +10,10 @@ export interface ScheduleCopySkipReport {
  * board's per-week-offset bucket cache instead of the mockup's absolute 91-day horizon. Split
  * shifts (copyUnitsOf in the mockup) aren't ported — WorkSlot has no splitId concept in this
  * data model, so each slot is copied as its own unit. */
-export declare function useScheduleCopyWeek(board: ScheduleBoardApi): {
-    copyLastWeek: (mode: "staffed" | "open") => void;
-    copyThisWeekForward: (mode: "staffed" | "open") => void;
+export declare function useScheduleCopyWeek(board: ScheduleBoardApi, handlers?: {
+    onDemandChanged?: () => void;
+}): {
+    copyLastWeek: (mode: "staffed" | "open") => Promise<void>;
+    copyThisWeekForward: (mode: "staffed" | "open") => Promise<void>;
 };
 export type ScheduleCopyWeekApi = ReturnType<typeof useScheduleCopyWeek>;

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

@@ -41,11 +41,6 @@ export interface ScheduleHourCell {
     title: string;
     n: number;
 }
-/** The day's hourly timeline (rows with shift bars placed by time), replacing the multi-day
- * grid for the one day Daily view is looking at. Ported from the mockup's
- * renderDayTimeline() + renderHourFooter() — the `else` (area) branch groups rows by position
- * instead of by employee, reusing the same axis/bar/lane geometry. Auto-Schedule proposal
- * review isn't carried over here; it stays week-view-only for now. */
 export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, handlers: {
     onAddShift: (empId: number, dayIdx: number) => void;
     onEditShift: (empId: number, dayIdx: number) => void;

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

@@ -1,4 +1,4 @@
-import type { CoverageSegment, DaySlot, DemandPeriod } from '../types';
+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;
@@ -8,8 +8,7 @@ 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 terse form the timeline's two end labels use — "8a", "10:30p". At 8.5px there is room
- * for the hour and not for the meridiem spelled out. */
+/** 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;
@@ -41,8 +40,17 @@ export declare function useScheduleDemand(board: ScheduleBoardApi): {
     setWeekdayDemand: (weekday: number, periods: DemandPeriod[]) => void;
     coverageAxis: (dayIdx: number) => ScheduleCoverageAxis;
     coverageSegments: (dayIdx: number) => CoverageSegment[];
-    coverageImpact: (dayIdx: number, empId: number, slot: DaySlot) => {
+    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;

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

@@ -9,6 +9,9 @@ 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
@@ -41,7 +44,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         sub: string;
     } | {
         on: boolean;
-        key: "weekday";
+        key: "every";
         label: string;
         sub: string;
     } | {
@@ -70,6 +73,8 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
     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;
@@ -78,6 +83,7 @@ export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand:
         when: string;
         required: number;
         scheduled: number;
+        varies: boolean;
         pct: number;
         tone: "short" | "part" | "met" | "over";
         note: string;

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

@@ -1,4 +1,4 @@
-import type { Employee } from '../types';
+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
@@ -21,7 +21,16 @@ export interface ScheduleEmployeeLoad {
     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.
@@ -29,4 +38,4 @@ export interface ScheduleEmployeeLoad {
  * 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): ScheduleEmployeeLoad;
+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/useScheduleGapPopover.d.ts

@@ -55,6 +55,8 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
         dayIdx: number;
     } | null>;
     view: import("vue").ComputedRef<{
+        crew: number;
+        peak: number;
         when: string;
         day: string;
         none: boolean;

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

@@ -1,20 +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;
 }
-/** Approve / reject / remove a leave record on a day — the mockup's leave editor modal. */
+/** 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;
     };
-    activeSlot: import("vue").ComputedRef<import("../types").LeaveSlot | null>;
-    openFor: (empId: number, dayIdx: number) => void;
+    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>;