@feedmepos/mf-hrm-portal 2.3.2-dev → 2.3.2-dev.3

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

@@ -0,0 +1,137 @@
+import type { Employee } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import { type ScheduleAddEmployeeMode, type ScheduleAddEmployeeStep } from './schedule-add-employee-form';
+export type { ScheduleAddEmployeeForm, ScheduleAddEmployeeMode, ScheduleAddEmployeeStep, } from './schedule-add-employee-form';
+/** Add-employee wizard: a "how do you want to add them" step, then one detail form covering
+ * identity, locations, pay, scheduling caps, availability, positions and POS access — plus
+ * the "select existing POS staff" side dialog the first step can hand off to. */
+export declare function useScheduleAddEmployee(board: ScheduleBoardApi, options?: {
+    notify?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}): {
+    open: import("vue").Ref<boolean, boolean>;
+    selectExistingOpen: import("vue").Ref<boolean, boolean>;
+    step: import("vue").Ref<ScheduleAddEmployeeStep, ScheduleAddEmployeeStep>;
+    mode: import("vue").Ref<ScheduleAddEmployeeMode, ScheduleAddEmployeeMode>;
+    form: {
+        name: string;
+        mobile: string;
+        dial: string;
+        employment: "full" | "part";
+        locations: string[];
+        payBasis: "hourly" | "monthly";
+        payAmount: string;
+        maxHours: string;
+        maxHoursPerDay: string;
+        minHours: string;
+        workingHoursEnabled: boolean;
+        overtimeEnabled: boolean;
+        maxHoursPerMonth: string;
+        availDays: boolean[];
+        availHours: {
+            from: string;
+            to: string;
+        }[];
+        preferences: string;
+        primaryPosition: string;
+        secondaryPositions: string[];
+        seniority: "" | "senior" | "junior";
+        passcode: string[];
+        masterUser: boolean;
+        masterCode: string;
+        posAccessEnabled: boolean;
+        posRoles: {
+            outlet: string;
+            roleId: string;
+        }[];
+    };
+    sectionId: import("vue").Ref<string, string>;
+    isEditing: import("vue").ComputedRef<boolean>;
+    editingEmployeeId: import("vue").Ref<number | null, number | null>;
+    locOpen: import("vue").Ref<boolean, boolean>;
+    secOpen: import("vue").Ref<boolean, boolean>;
+    secondaryOptions: import("vue").ComputedRef<string[]>;
+    isPart: import("vue").ComputedRef<boolean>;
+    dayLit: (index: number) => boolean;
+    avLabel: import("vue").ComputedRef<string>;
+    avAllLabel: import("vue").ComputedRef<string>;
+    maxHoursPlaceholder: import("vue").ComputedRef<string>;
+    minHoursPlaceholder: import("vue").ComputedRef<string>;
+    maxHoursPerDayPlaceholder: import("vue").ComputedRef<string>;
+    maxHoursPerMonthPlaceholder: import("vue").ComputedRef<string>;
+    toggleOvertime: () => void;
+    payUnit: import("vue").ComputedRef<string>;
+    effectiveRate: import("vue").ComputedRef<number>;
+    passcodeValue: import("vue").ComputedRef<string>;
+    passcodeOk: import("vue").ComputedRef<boolean>;
+    currentLocationLabel: import("vue").ComputedRef<string>;
+    locationOptions: import("vue").Reactive<string[]>;
+    isNewUser: import("vue").ComputedRef<boolean>;
+    footerHint: import("vue").ComputedRef<string>;
+    primaryRoleLabel: import("vue").ComputedRef<string>;
+    locationsSummary: import("vue").ComputedRef<string>;
+    payLine: import("vue").ComputedRef<string>;
+    nameError: import("vue").ComputedRef<boolean>;
+    passError: import("vue").ComputedRef<boolean>;
+    posRolesError: import("vue").ComputedRef<boolean>;
+    availabilityError: import("vue").ComputedRef<boolean>;
+    saving: import("vue").Ref<boolean, boolean>;
+    saveError: import("vue").Ref<string | null, string | null>;
+    deferScheduleWrites: import("vue").Ref<boolean, boolean>;
+    candidatesLoading: import("vue").Ref<boolean, boolean>;
+    candidatesError: import("vue").Ref<string | null, string | null>;
+    selectingExisting: import("vue").Ref<boolean, boolean>;
+    candidates: import("vue").Ref<{
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[], import("../types").ExistingStaffCandidate[] | {
+        employeeId: string;
+        name: string;
+        otherOutlets: string[];
+        locations: string[];
+    }[]>;
+    candidatesTotal: import("vue").Ref<number, number>;
+    candidatesPage: import("vue").Ref<number, number>;
+    candidatesPageItemCount: import("vue").Ref<number, number>;
+    candidatesPageSize: number;
+    searchExisting: (search: string) => void;
+    goToExistingPage: (page: number, search: string) => void;
+    openWizard: (section: string) => void;
+    openEditFor: (emp: Employee) => void;
+    confirmClose: () => void;
+    close: () => void;
+    setMode: (m: ScheduleAddEmployeeMode) => void;
+    openSelectExisting: () => void;
+    closeSelectExisting: () => void;
+    pickExisting: (employeeId: string) => Promise<void>;
+    next: () => void;
+    back: () => void;
+    toggleMulti: (which: "loc" | "sec") => void;
+    toggleLocation: (location: string) => void;
+    removeLocation: (location: string) => void;
+    toggleSecondary: (position: string) => void;
+    removeSecondary: (position: string) => void;
+    setPrimaryPosition: (position: string) => void;
+    setPayBasis: (basis: "hourly" | "monthly") => void;
+    toggleAvailDay: (index: number) => void;
+    availAll: () => void;
+    setAvailHour: (index: number, field: "from" | "to", value: string) => void;
+    copyAvailHourDown: (index: number) => void;
+    setPasscodeDigit: (index: number, value: string) => void;
+    generatePasscode: () => Promise<void>;
+    isGeneratingPasscode: import("vue").Ref<boolean, boolean>;
+    togglePosAccess: () => void;
+    addPosRoleRow: () => void;
+    removePosRoleRow: (index: number) => void;
+    isCurrentOutletRow: (index: number) => boolean;
+    setPosRoleOutlet: (index: number, outlet: string) => void;
+    setPosRoleId: (index: number, roleId: string) => void;
+    posRoleOptionsFor: (outlet: string) => import("../../../types/role").Role[];
+    isPosRoleUsable: (role: import("../../../types/role").Role) => boolean;
+    setMasterUserRoleAccess: (roleIds: string[] | null | undefined) => void;
+    isPosOutletUsable: (outlet: string) => boolean;
+    posRolesHint: import("vue").ComputedRef<string>;
+    create: () => Promise<boolean>;
+};
+export type ScheduleAddEmployeeApi = ReturnType<typeof useScheduleAddEmployee>;

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

@@ -0,0 +1,75 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type QuickPickCandidate } from './schedule-quick-pick';
+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;
+    top: number;
+}
+export interface ScheduleAddPickLeaveOption {
+    reason: string;
+    /** i18n key for the row's label — `reason` itself is an id and stays English. */
+    labelKey: string;
+    swatch: string;
+}
+/** The "+ Add" quick-pick popover on an employee's empty cell — ported from the mockup's
+ * openAddShiftPicker()/renderAddPickList(), scoped to what this board actually has: our one
+ * active shift pattern, a fixed leave-reason list, and a demand-gap suggestion, all committed
+ * directly (no clash confirmation dialogs — this board has no such infrastructure yet, and none
+ * of its existing write paths gate on one either). Leave picks write a full-day approved leave
+ * immediately rather than opening a creation form — there's no "book a leave" authoring flow
+ * anywhere in this port yet, only the existing pending-request review modal, which assumes the
+ * leave already exists. The mockup's "On this day" (join an existing open-shift group) section is
+ * left out — it needs split-shift/group-joining machinery this board doesn't model. */
+export declare function useScheduleAddPick(board: ScheduleBoardApi, demand: ScheduleDemandApi, handlers: {
+    onCommitted: (message: string) => void;
+    onOpenFullEditor: (empId: number, dayIdx: number, slotIndex: 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;
+    };
+    query: import("vue").Ref<string, string>;
+    parsedRange: import("vue").ComputedRef<{
+        start: string;
+        end: string;
+    } | null>;
+    suggestions: import("vue").ComputedRef<QuickPickCandidate[]>;
+    filteredPatterns: import("vue").ComputedRef<{
+        key: string;
+        label: string;
+        start: string;
+        end: string;
+        color: string;
+        active: boolean;
+        breakMins: number;
+    }[]>;
+    filteredLeaves: import("vue").ComputedRef<ScheduleAddPickLeaveOption[]>;
+    hasResults: import("vue").ComputedRef<boolean>;
+    openFor: (empId: number, dayIdx: number, anchor: HTMLElement) => void;
+    close: () => void;
+    pickSuggested: (index: number) => void;
+    pickPattern: (key: string) => void;
+    pickTypedRange: (start: string, end: string) => void;
+    pickLeave: (reason: string) => void;
+    submitQuery: () => void;
+    openBlank: () => void;
+};
+export type ScheduleAddPickApi = ReturnType<typeof useScheduleAddPick>;

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

@@ -0,0 +1,50 @@
+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[];
+    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,11 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** Dragging a person from the staff rail onto a position/day cell opens a normal assigned shift. */
+export declare function useScheduleAreaDragDrop(board: ScheduleBoardApi, handlers: {
+    onCreateShift: (empId: number, dayIdx: number, 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/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,301 @@
+import type { FdtoScheduleAutoScheduleObjective } 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;
+    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;
+        allowOvertime: boolean;
+        respectAvailability: boolean;
+        followPatterns: boolean;
+        costEfficient: 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;
+        model: string | null;
+        proposals: {
+            rejectReason?: string | null | undefined | undefined;
+            date: string;
+            startTime: string;
+            endTime: string;
+            employeeId: string;
+            positionId: string | null;
+            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;
+                dailyCap: number;
+                rest: number;
+                dayOff: 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;
+        model: string | null;
+        proposals: {
+            rejectReason?: string | null | undefined;
+            date: string;
+            startTime: string;
+            endTime: string;
+            employeeId: string;
+            positionId: string | null;
+            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;
+                dailyCap: number;
+                rest: number;
+                dayOff: 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;
+        model: string | null;
+        proposals: {
+            rejectReason?: string | null | undefined | undefined;
+            date: string;
+            startTime: string;
+            endTime: string;
+            employeeId: string;
+            positionId: string | null;
+            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;
+                dailyCap: number;
+                rest: number;
+                dayOff: 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: (fromSetup?: boolean) => void;
+    closeWizard: () => void;
+    next: () => void;
+    back: () => void;
+    generate: () => Promise<void>;
+    reviewMode: import("vue").ComputedRef<boolean>;
+    hasPendingChanges: 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;
+        rejectReason?: 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;
+    completionOpen: import("vue").Ref<boolean, boolean>;
+    completionCount: import("vue").Ref<number, number>;
+    completionPublished: import("vue").Ref<boolean, boolean>;
+    completionFromSetup: import("vue").Ref<boolean, boolean>;
+    closeCompletion: () => void;
+    leaveReviewOpen: import("vue").Ref<boolean, boolean>;
+    confirmLeaveReview: () => void;
+    cancelLeaveReview: () => void;
+    apply: (showCompletion?: boolean, status?: "DRAFT" | "PUBLISHED") => 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>;