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

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

@@ -1,11 +1,5 @@
 import type { ScheduleBoardApi } from './useScheduleBoard';
-export interface ExportShiftCell {
-    note: string;
-    shifts: {
-        when: string;
-        pos: string;
-    }[];
-}
+import type { ExportShiftCell } from './schedule-export-matrix';
 export interface ExportMatrix {
     head: string[];
     body: (string | ExportShiftCell)[][];
@@ -15,19 +9,33 @@ export interface ExportMatrix {
      * and a fully-staffed week with nobody over contract totals 0.0 there. */
     shiftTotal: number;
 }
+export { cellText, dayCellLines, dayHeaderLabel, esc } from './schedule-export-matrix';
+export type { ExportShiftCell } from './schedule-export-matrix';
 /** 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. */
+ * PDF/canvas library here; both PDF and JPG are the same hand-drawn Canvas 2D table
+ * (`buildJpgCanvas`). PDF used to be a separate HTML/`<table>` rendering handed to
+ * window.print(), but printing the live page and CSS-hiding everything around the sheet proved
+ * unreliable (see printNow's own comment) — "Save as PDF" now wraps that same canvas image into a
+ * standalone print window instead, so PDF and JPG are guaranteed to look identical. */
 export declare function useScheduleExport(board: ScheduleBoardApi): {
     buildExportMatrix: () => ExportMatrix;
     pdfPreviewOpen: import("vue").Ref<boolean, boolean>;
-    pdfHtml: import("vue").ComputedRef<string>;
     pdfBarMeta: import("vue").ComputedRef<string>;
     openPdfPreview: () => void;
     closePdfPreview: () => void;
     printNow: () => void;
-    exportJpg: () => void;
+    jpgPreviewOpen: import("vue").Ref<boolean, boolean>;
+    jpgPreviewUrl: import("vue").Ref<string | null, string | null>;
+    jpgPreviewWidth: import("vue").Ref<number, number>;
+    jpgPreviewHeight: import("vue").Ref<number, number>;
+    jpgFilename: import("vue").Ref<string, string>;
+    jpgBarMeta: import("vue").ComputedRef<string>;
+    openJpgPreview: () => void;
+    closeJpgPreview: () => void;
+    saveJpgPreview: () => void;
     exportDoneOpen: import("vue").Ref<boolean, boolean>;
+    exportDoneTitle: import("vue").Ref<string, string>;
+    exportDoneDescription: import("vue").Ref<string, string>;
     exportDoneRecap: import("vue").Ref<{
         label: string;
         value: string;

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

@@ -1,11 +1,9 @@
 import type { CoverageSegment } from '../types';
 import type { ScheduleBoardApi } from './useScheduleBoard';
 import type { ScheduleDemandApi } from './useScheduleDemand';
-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, actions: ScheduleGapActions): {
+/** The gap popover: what a striped stretch of the coverage bar means. Read-only — it states the
+ * shortfall and which positions are missing; nothing here writes. */
+export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
     state: {
         open: boolean;
         pinned: boolean;
@@ -74,7 +72,6 @@ export declare function useScheduleGapPopover(board: ScheduleBoardApi, demand: S
     hold: () => void;
     segClick: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
     segFocus: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
-    addShift: () => void;
     close: () => void;
 };
 export type ScheduleGapPopoverApi = ReturnType<typeof useScheduleGapPopover>;

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

@@ -0,0 +1,58 @@
+import { type ComputedRef } from 'vue';
+import type { Employee } from '../types';
+import type { AvailRow, ScheduleOnboardingDayHours, TeamRow } from './onboarding-types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+type EmployeeRow = {
+    emp: Employee;
+    row: TeamRow;
+};
+type BulkMark = '' | 'y' | 'n';
+export interface ScheduleOnboardingAvailabilityOptions {
+    board: ScheduleBoardApi;
+    hours: ScheduleOnboardingDayHours[];
+    openDays: ComputedRef<number[]>;
+    employeeRows: ComputedRef<EmployeeRow[]>;
+    isShut: (dayIdx: number) => boolean;
+    pendingAvail: Map<number, Array<{
+        dayOfWeek: number;
+        start: string;
+        end: string;
+    }>>;
+}
+export declare function useScheduleOnboardingAvailability(options: ScheduleOnboardingAvailabilityOptions): {
+    avail: Record<number, AvailRow>;
+    avTab: import("vue").Ref<"full" | "part", "full" | "part">;
+    avPicked: Record<number, boolean>;
+    avVary: Record<number, boolean>;
+    avBulkOpen: import("vue").Ref<boolean, boolean>;
+    avBulk: {
+        off: BulkMark[];
+        on: BulkMark[];
+        from: string;
+        to: string;
+    };
+    seedAvailability: (missingOnly?: boolean) => void;
+    avFulls: ComputedRef<EmployeeRow[]>;
+    avParts: ComputedRef<EmployeeRow[]>;
+    avGroup: ComputedRef<EmployeeRow[]>;
+    avSelected: ComputedRef<EmployeeRow[]>;
+    restDays: (empId: number) => number[];
+    avFullDone: ComputedRef<number>;
+    avPartDone: ComputedRef<number>;
+    avOffCount: (dayIdx: number) => number | null;
+    avFullSub: (empId: number) => string;
+    avPartSummary: (empId: number) => string;
+    avShowsByDay: (empId: number) => boolean;
+    canDays: (empId: number) => number[];
+    avPickAll: (checked: boolean) => void;
+    toggleOff: (empId: number, dayIdx: number) => void;
+    toggleCan: (empId: number, dayIdx: number) => void;
+    setAvailTime: (empId: number, dayIdx: number | null, field: "from" | "to", value: string) => void;
+    toggleVary: (empId: number) => void;
+    bulkDay: (which: "off" | "on", dayIdx: number) => void;
+    avBulkReady: ComputedRef<boolean>;
+    applyAvBulk: () => void;
+    saveAvailability: () => void;
+};
+export type ScheduleOnboardingAvailabilityApi = ReturnType<typeof useScheduleOnboardingAvailability>;
+export {};

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

@@ -0,0 +1,45 @@
+import { type Ref } from 'vue';
+import type { ScheduleOnboardingDayHours, ScheduleOnboardingRange } from './onboarding-types';
+import type { SchedulePositionsApi } from './useSchedulePositions';
+export declare function useScheduleOnboardingDemand(hours: ScheduleOnboardingDayHours[], positions: SchedulePositionsApi, note: Ref<string>): {
+    demand: import("vue").Reactive<ScheduleOnboardingRange[][]>;
+    dmDay: Ref<number, number>;
+    staffingSaving: Ref<boolean, boolean>;
+    note: Ref<string, string>;
+    isShut: (dayIdx: number) => boolean;
+    dayClosedConfirm: {
+        state: {
+            open: boolean;
+            message: string;
+            title: string | null;
+            confirmLabel: string | null;
+            onConfirm: (() => void) | null;
+        };
+        ask: (message: string, onConfirm: () => void, opts?: {
+            title?: string;
+            confirmLabel?: string;
+        }) => void;
+        confirm: () => void;
+        close: () => void;
+    };
+    shutAcknowledged: Record<number, boolean>;
+    dmPeak: (dayIdx: number) => number;
+    namedPositions: import("vue").ComputedRef<string[]>;
+    remainingCommon: import("vue").ComputedRef<string[]>;
+    suggestedPositions: import("vue").ComputedRef<string[]>;
+    openDays: import("vue").ComputedRef<number[]>;
+    daysSet: import("vue").ComputedRef<number>;
+    daySpan: (dayIdx: number) => string;
+    seedDemand: () => void;
+    selectDay: (dayIdx: number) => void;
+    setRangeTime: (index: number, field: "from" | "to", value: string) => void;
+    setRangeCount: (index: number, value: string) => void;
+    addRange: () => void;
+    removeRange: (index: number) => void;
+    addRole: (index: number) => void;
+    setRole: (index: number, roleIndex: number, field: "position" | "n", value: string) => void;
+    removeRole: (index: number, roleIndex: number) => void;
+    namedTotal: (range: ScheduleOnboardingRange) => number;
+    copyDay: (mode: "all" | "wk" | "we") => void;
+};
+export type ScheduleOnboardingDemandApi = ReturnType<typeof useScheduleOnboardingDemand>;

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

@@ -0,0 +1,187 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { TeamBasis, TeamEmployment, TeamRow } from './onboarding-types';
+export interface ScheduleOnboardingEmployeesOptions {
+    board: ScheduleBoardApi;
+    note: {
+        value: string;
+    };
+}
+export declare function useScheduleOnboardingEmployees(options: ScheduleOnboardingEmployeesOptions): {
+    team: Record<number, TeamRow>;
+    employeeRows: import("vue").ComputedRef<{
+        emp: {
+            id: number;
+            sourceId: string;
+            name: string;
+            employmentType: "FULLTIME" | "PARTTIME";
+            role: string;
+            initials: string;
+            color: string;
+            weekHours: number;
+            pct: number;
+            contractHours?: number | undefined;
+            rate: number;
+            positions: string[];
+            shifts: ({
+                start: string;
+                end: string;
+                role: string;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
+                assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
+                splitGroupId?: string | undefined;
+            } | {
+                timeOff: "approved" | "pending";
+                requestId?: string | undefined;
+                type?: "OFF_DAY" | "LEAVE" | undefined;
+                leaveType?: "ANNUAL" | "MEDICAL" | "EMERGENCY" | "UNPAID" | undefined;
+                reason: string;
+                half?: boolean | undefined;
+                halfPart?: "AM" | "PM" | undefined;
+                from?: string | undefined;
+                to?: string | undefined;
+                appliedOn?: string | undefined;
+                note?: string | undefined;
+                cert?: {
+                    name: string;
+                    size: string;
+                } | null | undefined;
+                bal?: {
+                    type: string;
+                    entitled: number;
+                    used: number;
+                } | undefined;
+            } | {
+                start: string;
+                end: string;
+                role: string;
+                status: import("../types").ShiftStatus;
+                clock?: {
+                    in: string | null;
+                    out: string | null;
+                    status: "on-time" | "late" | "early-out" | "absent";
+                } | undefined;
+                conflict?: boolean | undefined;
+                conflictReason?: string | undefined;
+                openId?: number | undefined;
+                breakMins?: number | undefined;
+                breaks?: ({
+                    type: "DURATION";
+                    minutes: number;
+                    breakPayType: "PAID" | "UNPAID";
+                } | {
+                    type: "TIME_RANGE";
+                    startTime: string;
+                    endTime: string;
+                    breakPayType: "PAID" | "UNPAID";
+                })[] | undefined;
+                assignmentId?: string | undefined;
+                updatedAt?: string | undefined;
+                splitGroupId?: string | undefined;
+            }[] | null)[];
+            remarks: {
+                author: string;
+                date: string;
+                type: "note" | "warning" | "praise";
+                text: string;
+            }[];
+            section: string;
+            compGroup?: string | undefined;
+            mobile?: string | undefined;
+            dial?: string | undefined;
+            locations?: string[] | undefined;
+            payBasis?: "hourly" | "monthly" | undefined;
+            payAmount?: number | undefined;
+            maxHours?: number | undefined;
+            maxOtHours?: number | undefined;
+            minHours?: number | undefined;
+            otAfterDaily?: number | undefined;
+            preferences?: string[] | undefined;
+            seniority?: "senior" | "junior" | "" | undefined;
+            availDays?: boolean[] | undefined;
+            availHours?: {
+                from: string;
+                to: string;
+            }[] | undefined;
+            passcode?: string | undefined;
+            masterUser?: boolean | undefined;
+        };
+        row: TeamRow;
+    }[]>;
+    employeePicked: import("vue").ComputedRef<number>;
+    employeeAllPicked: import("vue").ComputedRef<boolean>;
+    employeeSomePicked: import("vue").ComputedRef<boolean>;
+    pendingTeam: Set<number>;
+    pendingAvail: Map<number, {
+        dayOfWeek: number;
+        start: string;
+        end: string;
+    }[]>;
+    rawEmployee: (empId: number) => {
+        name: string;
+        employeeId: string;
+        employmentType: "FULLTIME" | "PARTTIME";
+        workingHour: number;
+        wage: {
+            type: "HOURLY" | "MONTHLY";
+            amount: number;
+        };
+        primaryPosition: {
+            positionId: string;
+            positionName: string;
+        } | null;
+        secondaryPositions: {
+            positionId: string;
+            positionName: string;
+        }[];
+        availability: {
+            dayOfWeek: number;
+            start: string;
+            end: string;
+        }[];
+    } | undefined;
+    seedEmployees: (missingOnly?: boolean) => void;
+    pickAll: (checked: boolean) => void;
+    setPosition: (empId: number, value: string) => void;
+    setEmployment: (empId: number, kind: TeamEmployment) => void;
+    setHours: (empId: number, value: string) => void;
+    setRate: (empId: number, value: string) => void;
+    bulkOpen: import("vue").Ref<boolean, boolean>;
+    bulk: {
+        scope: "all" | "full" | "part" | "nopos" | "nopay";
+        position: string;
+        second: string;
+        employment: "" | TeamEmployment;
+        maxHours: string;
+        rate: string;
+        basis: "" | TeamBasis;
+    };
+    bulkCount: import("vue").ComputedRef<number>;
+    applyBulk: () => void;
+    BULK_NONE: string;
+    validateEmployees: () => string | null;
+    saveEmployees: () => void;
+    note: {
+        value: string;
+    };
+};
+export type ScheduleOnboardingEmployeesApi = ReturnType<typeof useScheduleOnboardingEmployees>;

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

@@ -0,0 +1,15 @@
+import type { ScheduleOnboardingDayHours } from './onboarding-types';
+export declare const MAX_OPERATIONAL_SESSIONS = 2;
+export declare function useScheduleOnboardingHours(): {
+    hours: import("vue").Reactive<ScheduleOnboardingDayHours[]>;
+    profileSnapshot: import("vue").Ref<string, string>;
+    hoursSnapshot: () => string;
+    hoursMatchProfile: import("vue").ComputedRef<boolean>;
+    openDayCount: import("vue").ComputedRef<number>;
+    resetHours: () => void;
+    toggleDay: (dayIdx: number) => void;
+    addSession: (dayIdx: number) => void;
+    removeSession: (dayIdx: number, sessionIdx: number) => void;
+    setSessionTime: (dayIdx: number, sessionIdx: number, field: "from" | "to", value: string) => void;
+};
+export type ScheduleOnboardingHoursApi = ReturnType<typeof useScheduleOnboardingHours>;

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

@@ -0,0 +1,11 @@
+import type { ScheduleOnboardingStep } from './onboarding-types';
+export declare function useScheduleOnboardingNavigation(): {
+    step: import("vue").Ref<ScheduleOnboardingStep, ScheduleOnboardingStep>;
+    stepIndex: import("vue").ComputedRef<number>;
+    isFirstStep: import("vue").ComputedRef<boolean>;
+    isLastStep: import("vue").ComputedRef<boolean>;
+    totalSteps: number;
+    steps: ScheduleOnboardingStep[];
+    isSkippable: import("vue").ComputedRef<boolean>;
+};
+export type ScheduleOnboardingNavigationApi = ReturnType<typeof useScheduleOnboardingNavigation>;