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

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

@@ -0,0 +1,214 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+import { type ScheduleShiftSegment } from './schedule-shift-time';
+export type { ScheduleBreakChoice, ScheduleShiftSegment } from './schedule-shift-time';
+export interface ScheduleHeadcountRole {
+    position: string;
+    count: number;
+    sen: '' | 'senior' | 'junior';
+}
+/** The unified shift popover — ported from the mockup's single `.shift-pop`, which answers
+ * both "who is on this shift" and "what does this shift need" from one form. Picking a real
+ * person in the `who` select turns it into an assignment; leaving it on "Empty shift" turns
+ * it into open demand. Opened three ways: for an employee's cell (assign/edit), for a brand
+ * new open shift (multi-position headcount authoring), or to edit one existing open-shift
+ * record (single position, like an assigned shift's "Position needed" row). */
+export declare function useScheduleShiftPopover(board: ScheduleBoardApi, demand: ScheduleDemandApi, options?: {
+    onToast?: (message: string, type?: 'success' | 'error' | 'info') => void;
+}): {
+    open: import("vue").Ref<boolean, boolean>;
+    dayIdx: import("vue").Ref<number | null, number | null>;
+    empId: import("vue").Ref<number | null, number | null>;
+    originalEmpId: import("vue").Ref<number | null, number | null>;
+    editingOpenShiftId: import("vue").Ref<number | null, number | null>;
+    isNew: import("vue").Ref<boolean, boolean>;
+    name: import("vue").Ref<string, string>;
+    segments: import("vue").Ref<{
+        start: string;
+        end: string;
+    }[], ScheduleShiftSegment[] | {
+        start: string;
+        end: string;
+    }[]>;
+    role: import("vue").Ref<string, string>;
+    required: import("vue").Ref<number, number>;
+    sen: import("vue").Ref<"" | "senior" | "junior", "" | "senior" | "junior">;
+    empType: import("vue").Ref<"" | "full" | "part", "" | "full" | "part">;
+    roles: import("vue").Ref<{
+        position: string;
+        count: number;
+        sen: "" | "senior" | "junior";
+    }[], import("./useScheduleShiftDraft").ScheduleHeadcountRole[] | {
+        position: string;
+        count: number;
+        sen: "" | "senior" | "junior";
+    }[]>;
+    impact: import("vue").ComputedRef<{
+        when: string;
+        pctBefore: number;
+        pctAfter: number;
+        stillShort: number;
+        before: {
+            required: number;
+            scheduled: number;
+        };
+        after: {
+            required: number;
+            scheduled: number;
+        };
+        beforeSegs: import("../types").CoverageSegment[];
+        afterSegs: import("../types").CoverageSegment[];
+        axis: import("./schedule-demand-domain").ScheduleCoverageAxis;
+    } | null>;
+    requiresAssignment: import("vue").ComputedRef<boolean>;
+    saveDisabled: import("vue").ComputedRef<boolean>;
+    saveTitle: import("vue").ComputedRef<"" | "Choose who covers it — this shift is answering a staffing gap, and a shift with nobody on it leaves that gap exactly as it is">;
+    saveLabel: import("vue").ComputedRef<"Create & assign" | "Save">;
+    breakChoice: import("vue").Ref<import("./schedule-shift-time").ScheduleBreakChoice, import("./schedule-shift-time").ScheduleBreakChoice>;
+    breakCustomMins: import("vue").Ref<number, number>;
+    breakCustomUnit: import("vue").Ref<"mins" | "hrs", "mins" | "hrs">;
+    breakMode: import("vue").Ref<"time" | "duration", "time" | "duration">;
+    breakStartTime: import("vue").Ref<string, string>;
+    breakEndTime: import("vue").Ref<string, string>;
+    repeatDays: import("vue").Ref<boolean[], boolean[]>;
+    gapNote: import("vue").Ref<string | null, string | null>;
+    conflictNote: import("vue").Ref<string | null, string | null>;
+    grantSkill: import("vue").Ref<boolean, boolean>;
+    showGrantSkill: import("vue").ComputedRef<boolean>;
+    unassignMode: import("vue").Ref<boolean, boolean>;
+    positionOptions: import("vue").ComputedRef<string[]>;
+    whoOptions: import("vue").ComputedRef<{
+        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;
+    }[]>;
+    isAssigned: import("vue").ComputedRef<boolean>;
+    isReleasingToOpen: import("vue").ComputedRef<boolean>;
+    isEditingOpenShift: import("vue").ComputedRef<boolean>;
+    isNewOpenShift: import("vue").ComputedRef<boolean>;
+    isSingleOpenRecord: import("vue").ComputedRef<boolean>;
+    totalHours: import("vue").ComputedRef<number>;
+    totalLabel: import("vue").ComputedRef<string>;
+    warnings: import("vue").ComputedRef<string[]>;
+    openForEmployee: (forEmpId: number, day: number, roleHint?: string, hours?: ScheduleShiftSegment, slotIndex?: number) => void;
+    openForNewOpenShift: (day: number, roleHint?: string, hours?: ScheduleShiftSegment) => void;
+    openForEditOpenShift: (openShiftId: number) => void;
+    close: () => void;
+    removeSegment: (i: number) => void;
+    addRole: () => void;
+    removeRole: (i: number) => void;
+    save: () => void;
+    remove: () => void;
+};
+export type ScheduleShiftPopoverApi = ReturnType<typeof useScheduleShiftPopover>;

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

@@ -0,0 +1,27 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleCostRailApi } from './useScheduleCostRail';
+import type { useScheduleLegend } from './useScheduleLegend';
+/** The collapsible weekly-summary band under the day header: totals when collapsed,
+ * a per-day cost/hours/forecast breakdown when open. Ported from the mockup's
+ * buildStatsRow() — the band always mirrors whatever days the grid currently shows
+ * (board.visibleDayIndices), collapsing to one day's figures in Daily view exactly like
+ * the reference's renderedDays()-scoped totals. The 7-day RULES.salesForecast/SALES_CURVE
+ * baseline underneath it stays weekly regardless — only the on-screen total and the
+ * redistribution on edit are span-scoped. */
+export declare function useScheduleStatsRow(board: ScheduleBoardApi, costRail: ScheduleCostRailApi, legend: ReturnType<typeof useScheduleLegend>, handlers?: {
+    onPersistError?: (message: string) => void;
+    onPersistSuccess?: (message: string) => void;
+}): {
+    open: import("vue").Ref<boolean, boolean>;
+    toggle: () => void;
+    forecast: import("vue").Ref<number, number>;
+    visibleForecast: import("vue").ComputedRef<number>;
+    visibleCost: import("vue").ComputedRef<number>;
+    visibleHours: import("vue").ComputedRef<number>;
+    salesFor: (dayIdx: number) => number;
+    isDayOverridden: (dayIdx: number) => boolean;
+    setDayForecast: (dayIdx: number, value: string) => void;
+    labourPct: (dayIdx: number) => number | null;
+    isShort: (dayIdx: number) => boolean;
+};
+export type ScheduleStatsRowApi = ReturnType<typeof useScheduleStatsRow>;

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

@@ -0,0 +1,49 @@
+export interface ScheduleTimePickerOption {
+    value: string;
+    label: string;
+    am: boolean;
+    sel: boolean;
+    typed: boolean;
+    /** An existing value that doesn't land on the half hour — kept in the list rather than
+     * snapped, because silently moving somebody's 11:20 start is a change to their shift, not
+     * a rounding. */
+    odd: boolean;
+}
+export interface ScheduleTimePickerState {
+    open: boolean;
+    /** The field's own value when the popover opened — what `.sel` marks, and what an off-grid
+     * value gets read from to appear in the list at all. */
+    value: string;
+    query: string;
+    /** Which trigger button opened it, so only that one wears the open state. */
+    key: string;
+    left: number;
+    top: number;
+}
+/** "8:00 AM", "10:15 PM" — the picker's own display face, and the trigger button's label. */
+export declare function formatTime12(hhmm: string): string;
+/** The time-of-day combobox behind every `sp2-time.tp-btn` field on the board (demand periods,
+ * shift segments) — one popover instance shared across all of them, the same way the add-pick
+ * and gap popovers are. Half-hour options grouped AM/PM, plus a type-in field for anything the
+ * grid doesn't land on and a search over the same list. */
+export declare function useScheduleTimePicker(): {
+    state: {
+        open: boolean;
+        value: string;
+        query: string;
+        key: string;
+        left: number;
+        top: number;
+    };
+    options: import("vue").ComputedRef<ScheduleTimePickerOption[]>;
+    amOptions: import("vue").ComputedRef<ScheduleTimePickerOption[]>;
+    pmOptions: import("vue").ComputedRef<ScheduleTimePickerOption[]>;
+    typedValue: import("vue").ComputedRef<string | null>;
+    openFor: (anchor: HTMLElement, value: string, pick: (hhmm: string) => void, key?: string) => void;
+    anchorRect: () => DOMRect | null;
+    isOpenFor: (key: string) => boolean;
+    close: () => void;
+    pick: (value: string) => void;
+    submitQuery: () => void;
+};
+export type ScheduleTimePickerApi = ReturnType<typeof useScheduleTimePicker>;

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

@@ -0,0 +1,95 @@
+import { type Ref } from 'vue';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandRowApi } from './useScheduleDemandRow';
+import type { ScheduleDemandSheetApi } from './useScheduleDemandSheet';
+import type { ScheduleGapPopoverApi } from './useScheduleGapPopover';
+import type { ScheduleAutoScheduleApi } from './useScheduleAutoSchedule';
+import type { SchedulePublishApi } from './useSchedulePublish';
+import type { ScheduleExportApi } from './useScheduleExport';
+import type { IntroRecapRow } from './onboarding-types';
+interface TourDeps {
+    rootEl: Ref<HTMLElement | null>;
+    board: ScheduleBoardApi;
+    demandRow: ScheduleDemandRowApi;
+    demandSheet: ScheduleDemandSheetApi;
+    gap: ScheduleGapPopoverApi;
+    autoSchedule: ScheduleAutoScheduleApi;
+    publish: SchedulePublishApi;
+    exportApi: ScheduleExportApi;
+    onToast: (message: string) => void;
+}
+/** The guided tour: one coachmark at a time, walking from where demand is set through to
+ * sharing the published week. Ported from V6.2's `OBA_TOUR` / `obaTourGo` — same six stops,
+ * same "open the real surface, then point at it" steps for the demand sheet and the gap
+ * popover. No Back button, matching the source: the only way on is Next or Skip. */
+export declare function useScheduleTour(deps: TourDeps): {
+    coach: {
+        open: Ref<boolean, boolean>;
+        placing: Ref<boolean, boolean>;
+        tip: Ref<{
+            title: string;
+            body: string;
+            count?: string | undefined;
+            nextLabel?: string | undefined;
+            skipLabel?: string | undefined;
+            next?: (() => void) | undefined;
+            skip?: (() => void) | undefined;
+        } | null, import("./useScheduleCoach").CoachTipData | {
+            title: string;
+            body: string;
+            count?: string | undefined;
+            nextLabel?: string | undefined;
+            skipLabel?: string | undefined;
+            next?: (() => void) | undefined;
+            skip?: (() => void) | undefined;
+        } | null>;
+        maskT: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskB: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskL: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskR: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        spot: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        tipPos: {
+            left: number;
+            top: number;
+        };
+        arrow: {
+            side: "top" | "bottom" | "left" | "right";
+            offset: number;
+        };
+        start: (el: HTMLElement, data: import("./useScheduleCoach").CoachTipData, onMiss?: () => void) => void;
+        end: () => void;
+        next: () => void;
+        skip: () => void;
+    };
+    start: () => void;
+    allSetOpen: Ref<boolean, boolean>;
+    allSetRecap: import("vue").ComputedRef<IntroRecapRow[]>;
+    closeAllSet: () => void;
+};
+export type ScheduleTourApi = ReturnType<typeof useScheduleTour>;
+export {};

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

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+/** Pins the scheduling screen to the viewport so only the grid scrolls.
+ *
+ * `PortalShell` wraps every route in two unstyled divs, and the height chain above them is the
+ * host app's, not ours: with no definite height anywhere up there, `.sch { height: 100% }` has
+ * nothing to resolve against, the whole page grows to its content and the browser scrolls it —
+ * header rows included. Measuring where the shell starts and giving it the rest of the viewport
+ * is the one thing that does not depend on how the host lays itself out. */
+export declare function useScheduleViewportFit(rootEl: Ref<HTMLElement | null | undefined>): void;

package/dist/src/views/scheduling/country-rules/index.d.ts

@@ -0,0 +1,24 @@
+import type { PayRate } from '../types';
+export interface CountryScheduleRules {
+    countryCode: string;
+    timezone: string;
+    payRate: PayRate;
+    overtime: {
+        maxMonthlyHours: number | null;
+        afterDailyHours: number | null;
+    };
+    workingHours: {
+        standardWeeklyHours: number | null;
+        maxDailyHours: number | null;
+    };
+    recurringPublicHolidays: Array<{
+        month: number;
+        day: number;
+        name: string;
+    }>;
+    publicHolidays: Record<string, Record<string, string>>;
+}
+export declare function normalizeCountryCode(country: unknown): string;
+export declare function getCountryScheduleRules(country?: unknown): CountryScheduleRules;
+export declare function holidayNameForDate(rules: CountryScheduleRules, date: string): string | null;
+export declare const SUPPORTED_SCHEDULE_COUNTRIES: string[];

package/dist/src/views/scheduling/data.d.ts

@@ -0,0 +1,102 @@
+import type { Employee, OpenShift, Section } from './types';
+import type { FdtoSchedulePositionSelectorReq } from '@/types/schedule';
+export { COMPGRP_META, COMPGRP_OPTIONS, DEPT_OPTIONS, EXISTING_STAFF, LOCATION_LABEL_BY_ID, LOCATION_OPTIONS, OUTLET, POSITION_RECORDS, POSITIONS, ROLE_POSITIONS, RULES, SHIFT_TEMPLATES, } from './schedule-state';
+export declare const UNASSIGNED = "unassigned";
+export declare const WEEKDAYS: string[];
+export declare const ALL_STATIONS = "All Stations";
+/** Employment seniority is a closed set in the model, not something an outlet configures. */
+export declare const SENIORITY_OPTIONS: Array<'senior' | 'junior'>;
+/** The one section every board has. Scheduling sections are not a Mongo concept yet, so the
+ * whole roster sits in this bucket and its `roles` list stays empty. Labelled "Assigned" rather
+ * than the id's own `UNASSIGNED` — this is where every shift's actual cost lives (the cost rail
+ * is the only place this label shows), and "Unassigned" read like a warning that nobody was
+ * covering those hours rather than just "not sorted into a work area yet". */
+export declare const SECTIONS: Section[];
+/** The position catalogue, from the Positions collection. Name-only: this is read as plain
+ * strings everywhere on this board (dropdown options, coverage-matrix keys, role lookups), and
+ * changing its shape would touch every one of those. */
+/** The same catalogue, kept with its real backend id — the id-less `POSITIONS` above can't
+ * identify which document to edit or delete. Only the Position management page reads this. */
+/** Resolves a position name (every picker on this board only ever offers a name — see
+ * `POSITIONS` above) to its backend id, for save requests that can now name a position by id
+ * instead. `undefined` when the catalogue hasn't loaded yet or the name no longer matches one —
+ * callers still send the name alongside, so the backend's own by-name lookup is the fallback. */
+export declare function positionIdOf(name: string): string | undefined;
+/** The selector shape every position-carrying save request wants — `undefined` for a blank
+ * name (the field itself has nothing to name), a resolved id alongside the name otherwise. */
+export declare function positionSelectorOf(name: string | undefined): FdtoSchedulePositionSelectorReq | undefined;
+/** Which coverage positions a station label counts toward. Positions ARE the roles in this
+ * model — a shift records the position it is for — so nothing needs translating and this stays
+ * empty, which makes `positionKeyOf()` pass a role through unchanged. */
+/** The outlet this board is scheduling, from the Restaurants document. An object rather than a
+ * bare string so the two components that name it re-render when it arrives. */
+/** Outlets a person may be rostered at. Filled by useScheduleOutlet from the restaurant store
+ * — the board payload only ever describes the one outlet it was asked for. */
+/** Outlet id → name, so a person's POS `restaurantRole` (outlet ids) can be shown as the same
+ * labels LOCATION_OPTIONS offers. Filled alongside it by useScheduleOutlet. */
+/** No Mongo source: departments and compensation groups are not modelled. The Add Employee
+ * form renders these as empty pickers rather than offering choices nobody configured. */
+/** Candidates for "add an employee who already exists elsewhere in the business". No source
+ * yet — EmployeeProfiles is per-outlet, and the business-wide directory lives in CouchDB. */
+/** The venue's shift patterns. No collection holds these yet; consumers already handle an empty
+ * list by falling back to the trading window in RULES. */
+/** Mon → Sun weighting used to spread a weekly sales forecast across days. Flat while there is
+ * no real forecast to shape: a curve invented here would make one day look busier than another
+ * for no reason anybody could point at. */
+export declare const SALES_CURVE: number[];
+/** Scheduling configuration, from two places and no others: pay rates, setup state, and the
+ * monthly OT cap come from the ScheduleSettings document, and the trading window comes from the
+ * outlet's own Restaurants profile (see `restaurantProfile` on the DTO).
+ *
+ * The fields with no Mongo source stay zero rather than being guessed: `coverage` (per-template
+ * headcount matrices), `salesForecast`, `labourTarget`, `budget`, and notification channels.
+ * Nothing on screen derived from them is a figure this file made up.
+ *
+ * `openFrom`/`openTo` are the one pair that must never be blank — they are the axis every
+ * coverage bar, day timeline and shift form is drawn against, and there is no such thing as a
+ * zero-length day to draw. A neutral 00:00–24:00 stands in until a real window lands.
+ *
+ * `payRate` defaults to the same statutory baseline the API does when an outlet hasn't saved its
+ * own rates: 1.5× normal-day OT, 2× off-day OT, 3× public-holiday OT; 1× off-day regular, 2×
+ * public-holiday regular. */
+/** JS `getDay()` (0 = Sunday) → grid column (0 = Monday). */
+export declare function gridDayIdx(dayOfWeek: number): number;
+/** Grid column (0 = Monday) → JS `getDay()` (0 = Sunday). Inverse of gridDayIdx — needed
+ * wherever the board writes a day back to Mongo instead of reading one from it. */
+export declare function jsDayOfWeek(gridIdx: number): number;
+export declare function employeeIdOf(num: number): string | undefined;
+export declare function employeeNumberOf(employeeId: string): number;
+/** Stable identity for change tracking. Keep the numeric id only for legacy board lookups. */
+export declare function employeeKeyOf(employee: Pick<Employee, 'sourceId' | 'id'>): string;
+/** The outlets a person is rostered at, by name, from the POS roster's `restaurantRole`. */
+/** The outlet being scheduled goes first in a list of locations; the rest keep their order. */
+export declare function currentLocationFirst(locations: string[]): string[];
+export declare function createScheduleEmployees(dates?: Date[]): Employee[];
+/** Open shifts backed by a persisted Shift requirement never shipped — the backend never
+ * carried that collection, so this always produced an empty list in practice. Kept as a stub,
+ * rather than removed, so the week cache's seed call (`schedule-week-cache.ts`) doesn't need
+ * its own special-casing: every open-shift row on the board today is added ad hoc through the
+ * shift popover instead (`useScheduleShiftPopover`'s `pushOpenShift`), entirely in local state. */
+export declare function createScheduleOpenShifts(): OpenShift[];
+/** Staffing demand for the held window, in the shape useScheduleDemand stores it: dated
+ * overrides keyed by ISO date, standing rules keyed by grid weekday. */
+export declare function scheduleDemand(): {
+    byDate: Record<string, Array<{
+        from: string;
+        to: string;
+        n: number;
+        roles: Array<{
+            position: string;
+            n: number;
+        }>;
+    }>>;
+    byWeekday: Record<number, Array<{
+        from: string;
+        to: string;
+        n: number;
+        roles: Array<{
+            position: string;
+            n: number;
+        }>;
+    }>>;
+};