@feedmepos/mf-hrm-portal 2.2.5 → 2.3.0-dev.2

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

@@ -0,0 +1,63 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { Employee, WorkSlot } from '../types';
+export interface ScheduleAssignedSlot {
+    emp: Employee;
+    slot: WorkSlot;
+    /** This slot's position within the employee's day — what a drag of this card has to hand
+     * `board.moveShift`/`swapShifts` to pick the right period out of a day holding more than one. */
+    slotIndex: number;
+}
+export interface SchedulePositionCellMeta {
+    required: number;
+    filled: number;
+    open: number;
+    short: number;
+}
+/** Shared by the week and day area views, so a position's colour never disagrees between them. */
+export declare function positionSwatchClass(position: string): string;
+/** Where shifts and employees go that name no station at all — either because the outlet
+ * hasn't named its positions yet, or because a shift deliberately names none. Rostering
+ * shouldn't be blocked on the Positions page being filled in first, so this row exists
+ * whenever there's anyone or anything to put in it (see `positionRows`). */
+export declare const ANY_POSITION_ROW = "Any position";
+/** Every other row is named after the position its shifts carry, so the row name and the
+ * position key are the same string. This one differs: it collects records that name nothing,
+ * so anything that queries BY position — qualifiedFor, assignedOn, a new shift's role — has to
+ * ask for '' instead, or the row would answer "nobody holds Any position". */
+export declare function rowAsk(row: string): string;
+/** Whether this employee can be put on `position` — ported from the mockup's qualifiedFor().
+ * Nobody having a named position yet reads as "any station", the same way an unspecialised
+ * new-account roster does in the reference: rostering shouldn't be blocked on the Positions
+ * page being filled in first. */
+export declare function qualifiedFor(emp: Employee, position: string): boolean;
+/** Week-by-area grouping: rows are positions (a RULES.coverage.full key), not employees.
+ * Ported from the mockup's positionRows()/renderPositionBlock() — scoped to this board's single
+ * "Unassigned" section and its existing WorkSlot/OpenShift model, so no split shifts and
+ * no locked/closed-day states (neither exists anywhere in this port yet). */
+export declare function useScheduleAreaBoard(board: ScheduleBoardApi): {
+    positionRows: import("vue").ComputedRef<string[]>;
+    assignedOn: (dayIdx: number, position: string) => ScheduleAssignedSlot[];
+    unfilledOpenShiftsOn: (dayIdx: number, position: string) => {
+        id: number;
+        dayIdx: number;
+        position: string;
+        required: number;
+        filledBy: number | null;
+        sen?: "junior" | "senior" | undefined;
+        empType?: "full" | "part" | undefined;
+        name?: string | undefined;
+        start: string;
+        end: string;
+        breakMins?: number | undefined;
+    }[];
+    poolFor: (position: string) => Employee[];
+    cellMeta: (dayIdx: number, position: string) => SchedulePositionCellMeta;
+    positionWeekMeta: (position: string) => {
+        required: number;
+        filled: number;
+        open: number;
+        short: number;
+        pool: number;
+    };
+};
+export type ScheduleAreaBoardApi = ReturnType<typeof useScheduleAreaBoard>;

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

@@ -0,0 +1,18 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
+/** Dragging a person from the staff rail onto a position/day cell — ported from the mockup's
+ * dropStaffOnCell(), scoped to this board's model (no "unspecialised, so ask what they can
+ * do" grant flow, no split shifts): dropping fills an existing open shift for that position/day
+ * if there is one, otherwise opens the shift editor pre-filled with this person, day and
+ * position so the manager sets the hours. */
+export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, areaBoard: ScheduleAreaBoardApi, handlers: {
+    onFillOpenShift: (openId: number, empId: number) => void;
+    onCreateShift: (empId: number, dayIdx: number, position: string) => void;
+    onNotQualified: (empName: string, position: string) => void;
+}): {
+    draggingEmpId: import("vue").Ref<number | null, number | null>;
+    startRailDrag: (empId: number) => void;
+    endRailDrag: () => void;
+    dropOnCell: (dayIdx: number, position: string) => void;
+};
+export type ScheduleAreaDragDropApi = ReturnType<typeof useScheduleAreaDragDrop>;

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

@@ -0,0 +1,124 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleClashDetectionApi } from './useScheduleClashDetection';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+/** What this sitting is trying to fill — an on-screen open-shift row (never backed by a
+ * persisted Shift doc; `openShiftId` only ever identifies it within this session) or a raw
+ * demand gap. Either way the assignment created is a plain one-off, same shape as the +Add
+ * popover's — nothing here carries a shift/assignment linkage back to the server. */
+export interface ScheduleAssignTarget {
+    dayIdx: number;
+    position: string;
+    start: string;
+    end: string;
+    breakMins?: number;
+    openShiftId?: number;
+}
+export interface ScheduleAssignState {
+    open: boolean;
+    target: ScheduleAssignTarget | null;
+    /** How many heads this sitting is answering, and how many it has landed so far — the
+     * footer's "N still needed" note. Tracked locally rather than re-derived from
+     * `demand.coverageSegments` on every assign: a fresh assign can reshape segment boundaries
+     * entirely (met/short is a function of ALL current coverage, not just this one target), so a
+     * simple running count is the honest thing to show without re-deriving segment math here. */
+    required: number;
+    scheduled: number;
+}
+/** `free` — no shift that day, the ordinary case. `busy` — has a shift, but this is the
+ * manager's call to override (soft clash, asks first). `leave` — approved leave, a hard block:
+ * inert, not something a second tap should be able to push past. `mine` — already the one
+ * filling THIS open shift; only meaningful when the target has an `openShiftId` (a demand gap
+ * has no single "holder"), and the tile becomes the unassign control instead. */
+export type ScheduleAssignTileState = 'free' | 'busy' | 'leave' | 'mine';
+export interface ScheduleAssignTile {
+    id: number;
+    name: string;
+    initials: string;
+    weekHours: number;
+    cap: number;
+    over: boolean;
+    state: ScheduleAssignTileState;
+    title: string;
+}
+export interface ScheduleAssignGroup {
+    label: string;
+    tiles: ScheduleAssignTile[];
+}
+/** One entry in the day's shift rail — either the thing this sitting was opened to answer (the
+ * ORIGIN, always first), or another shift already on the same day, so a manager can jump to
+ * reassigning it without leaving the panel. Every entry is a `target` the tile grid can be
+ * pointed at via `switchTo`. */
+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;
+    full: boolean;
+    sub: string;
+    who: string;
+    whoNone: boolean;
+    on: boolean;
+    target: ScheduleAssignTarget;
+    required: number;
+    scheduled: number;
+}
+/** Assign panel — the one modal both the open-shifts row and a demand gap's "Assign employee"
+ * button open, per the reference's own note that they are "the same assign panel". Every pick
+ * lands immediately (through the canonical `commitShift` mutator, so it persists exactly like
+ * any other assignment); a soft clash — the person already has a shift that day — asks first via
+ * the shared clash-confirmation dialog, and approved leave is a hard block the tile itself
+ * refuses rather than asking about. */
+export declare function useScheduleAssign(board: ScheduleBoardApi, demand: ScheduleDemandApi, clash: ScheduleClashDetectionApi, options?: {
+    onToast?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}): {
+    state: {
+        open: boolean;
+        target: {
+            dayIdx: number;
+            position: string;
+            start: string;
+            end: string;
+            breakMins?: number | undefined;
+            openShiftId?: number | undefined;
+        } | null;
+        required: number;
+        scheduled: number;
+    };
+    search: import("vue").Ref<string, string>;
+    activeOpenShift: import("vue").ComputedRef<{
+        id: number;
+        dayIdx: number;
+        position: string;
+        required: number;
+        filledBy: number | null;
+        sen?: "junior" | "senior" | undefined;
+        empType?: "full" | "part" | undefined;
+        name?: string | undefined;
+        start: string;
+        end: string;
+        breakMins?: number | undefined;
+    } | null>;
+    title: 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;
+    close: () => void;
+    fillOpenShift: (openShiftId: number, empId: number) => void;
+    armAssign: (empId: number) => void;
+};
+export type ScheduleAssignApi = ReturnType<typeof useScheduleAssign>;

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

@@ -0,0 +1,13 @@
+import type { DaySlot, Employee, WorkSlot } from '../types';
+export interface ScheduleAssignmentMutationOptions {
+    dateFor: (offset: number, dayIdx: number) => string | null;
+    employeeAt: (offset: number, employeeId: number) => Employee | undefined;
+    currentOffset: () => number;
+    onPersistError?: (message: string) => void;
+}
+export declare function useScheduleAssignmentMutations(options: ScheduleAssignmentMutationOptions): {
+    persistSlot: (empId: number, dayIdx: number, oldSlot: DaySlot, newSlot: WorkSlot | WorkSlot[], dateOverride?: string | null, offset?: number, restoreDaySlot?: DaySlot) => Promise<void>;
+    persistRemoval: (oldSlot: DaySlot) => Promise<void>;
+    persistMove: (toEmpId: number, dayIdx: number, slot: WorkSlot | WorkSlot[], dateOverride?: string | null) => Promise<void>;
+    recoverPersistFailure: (error: unknown, fallback: string) => Promise<void>;
+};

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

@@ -0,0 +1,289 @@
+import type { FdtoScheduleAutoScheduleObjective, FdtoScheduleAutoSchedulePlanner } from '@/types/schedule';
+import type { Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export type ScheduleAutoScheduleStep = 'options' | 'summary';
+export interface ScheduleAutoScheduleOptions {
+    fillGaps: boolean;
+    objective: FdtoScheduleAutoScheduleObjective;
+    planner: FdtoScheduleAutoSchedulePlanner;
+    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 — the engine lives in hr-backend;
+ * this composable only maps its result onto the board and lets a manager review it. Generation
+ * never writes; accepted proposals use the board's existing assignment persistence path. */
+export declare function useScheduleAutoSchedule(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
+    wizardOpen: import("vue").Ref<boolean, boolean>;
+    step: import("vue").Ref<ScheduleAutoScheduleStep, ScheduleAutoScheduleStep>;
+    options: {
+        fillGaps: boolean;
+        objective: FdtoScheduleAutoScheduleObjective;
+        planner: FdtoScheduleAutoSchedulePlanner;
+        allowOvertime: boolean;
+        respectAvailability: boolean;
+        followPatterns: boolean;
+        costEfficient: boolean;
+    };
+    planners: import("vue").Ref<("GREEDY" | "LLM")[], ("GREEDY" | "LLM")[]>;
+    plannerChoice: import("vue").ComputedRef<boolean>;
+    generating: import("vue").Ref<boolean, boolean>;
+    generateError: import("vue").Ref<string | null, string | null>;
+    result: import("vue").Ref<{
+        objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
+        allowOvertime: boolean;
+        proposals: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            positionId: string | null;
+            employeeId: string;
+            employeeName: string;
+            position: string;
+            reason: string;
+        }[];
+        unfilledCount: number;
+        unfilledNeeds: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string | null;
+            short: number;
+            excluded: {
+                occupied: number;
+                notQualified: number;
+                weeklyCap: number;
+                rest: number;
+                dayOff: number;
+                dayCap: number;
+            };
+        }[];
+        metrics: {
+            minimumCoveragePercent: number;
+            recommendedCoveragePercent: number;
+            totalHours: number;
+            estimatedLabourCost: number | null;
+            costCoveragePercent: number;
+            overtimeHours: number;
+            targetHoursVariance: number;
+            unfilledIntervals: number;
+        };
+        readiness: {
+            ready: boolean;
+            capabilities: string[];
+            issues: {
+                code: string;
+                message: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+            }[];
+            coverage: {
+                wage: number;
+                availability: number;
+                position: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+        week: {
+            from: string;
+            to: string;
+        };
+        timing: {
+            totalMs: number;
+            modelMs: number | null;
+        };
+    } | null, {
+        objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
+        allowOvertime: boolean;
+        proposals: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            positionId: string | null;
+            employeeId: string;
+            employeeName: string;
+            position: string;
+            reason: string;
+        }[];
+        unfilledCount: number;
+        unfilledNeeds: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string | null;
+            short: number;
+            excluded: {
+                occupied: number;
+                notQualified: number;
+                weeklyCap: number;
+                rest: number;
+                dayOff: number;
+                dayCap: number;
+            };
+        }[];
+        metrics: {
+            minimumCoveragePercent: number;
+            recommendedCoveragePercent: number;
+            totalHours: number;
+            estimatedLabourCost: number | null;
+            costCoveragePercent: number;
+            overtimeHours: number;
+            targetHoursVariance: number;
+            unfilledIntervals: number;
+        };
+        readiness: {
+            ready: boolean;
+            capabilities: string[];
+            issues: {
+                code: string;
+                message: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+            }[];
+            coverage: {
+                wage: number;
+                availability: number;
+                position: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+        week: {
+            from: string;
+            to: string;
+        };
+        timing: {
+            totalMs: number;
+            modelMs: number | null;
+        };
+    } | {
+        objective: "BALANCED" | "SERVICE" | "LOWER_COST" | "STABLE_HOURS";
+        allowOvertime: boolean;
+        proposals: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            positionId: string | null;
+            employeeId: string;
+            employeeName: string;
+            position: string;
+            reason: string;
+        }[];
+        unfilledCount: number;
+        unfilledNeeds: {
+            date: string;
+            startTime: string;
+            endTime: string;
+            position: string | null;
+            short: number;
+            excluded: {
+                occupied: number;
+                notQualified: number;
+                weeklyCap: number;
+                rest: number;
+                dayOff: number;
+                dayCap: number;
+            };
+        }[];
+        metrics: {
+            minimumCoveragePercent: number;
+            recommendedCoveragePercent: number;
+            totalHours: number;
+            estimatedLabourCost: number | null;
+            costCoveragePercent: number;
+            overtimeHours: number;
+            targetHoursVariance: number;
+            unfilledIntervals: number;
+        };
+        readiness: {
+            ready: boolean;
+            capabilities: string[];
+            issues: {
+                code: string;
+                message: string;
+                severity: "BLOCKER" | "WARNING" | "INFO";
+            }[];
+            coverage: {
+                wage: number;
+                availability: number;
+                position: number;
+                targetHours: number;
+            };
+        };
+        explanations: string[];
+        solver: string;
+        week: {
+            from: string;
+            to: string;
+        };
+        timing: {
+            totalMs: number;
+            modelMs: number | null;
+        };
+    } | 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").ComputedRef<boolean>;
+    proposals: import("vue").ComputedRef<{
+        id: number;
+        empId: number;
+        dayIdx: number;
+        start: string;
+        end: string;
+        role: string;
+        positionId?: string | null | undefined;
+        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>;
+    removedCount: import("vue").ComputedRef<number>;
+    changedCount: import("vue").ComputedRef<number>;
+    unqualifiedCount: import("vue").ComputedRef<number>;
+    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;
+    apply: () => Promise<number | null>;
+    applying: import("vue").Ref<boolean, boolean>;
+    applyRejections: import("vue").Ref<{
+        employeeName: string;
+        day: string;
+        time: string;
+        message: string;
+    }[], {
+        employeeName: string;
+        day: string;
+        time: string;
+        message: string;
+    }[] | {
+        employeeName: string;
+        day: string;
+        time: string;
+        message: string;
+    }[]>;
+    applyError: import("vue").Ref<string | null, string | null>;
+    detailsOpen: import("vue").Ref<boolean, boolean>;
+    toggleDetails: () => void;
+};
+export type ScheduleAutoScheduleApi = ReturnType<typeof useScheduleAutoSchedule>;