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

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

@@ -0,0 +1,311 @@
+export type ShiftStatus = 'confirmed' | 'pending' | 'ot';
+export interface ShiftClock {
+    in: string | null;
+    out: string | null;
+    status: 'on-time' | 'late' | 'early-out' | 'absent';
+}
+export interface WorkSlot {
+    start: string;
+    end: string;
+    role: string;
+    status: ShiftStatus;
+    clock?: ShiftClock;
+    conflict?: boolean;
+    conflictReason?: string;
+    /** Set when this slot is the filled form of an OpenShift record. */
+    openId?: number;
+    /** Unpaid break length in minutes, authored in the shift popover. Not currently
+     * subtracted by the cost rail / stats row's hour totals — those stay gross-hours,
+     * matching how this board priced shifts before the popover surfaced a break field. */
+    breakMins?: number;
+    /** The ShiftAssignments document this slot is saved as, once it has one — see
+     * useScheduleBoard's commitShift/removeShift/moveShift. Absent means either it hasn't
+     * round-tripped to the backend yet, or it's an OpenShift fill (see openId), which has its
+     * own record shape and no write path of its own yet. */
+    assignmentId?: string;
+}
+export interface LeaveBalance {
+    type: string;
+    entitled: number;
+    used: number;
+}
+export interface LeaveSlot {
+    timeOff: 'approved' | 'pending';
+    reason: string;
+    half?: boolean;
+    halfPart?: 'AM' | 'PM';
+    appliedOn?: string;
+    note?: string;
+    cert?: {
+        name: string;
+        size: string;
+    } | null;
+    bal?: LeaveBalance;
+}
+export type DaySlot = WorkSlot | WorkSlot[] | LeaveSlot | null;
+export interface EmployeeRemark {
+    author: string;
+    date: string;
+    type: 'note' | 'warning' | 'praise';
+    text: string;
+}
+/** One weekday's availability window, used only for the part-timer "hours they can work"
+ * editor on the Add Employee form — informational HR data, not read by the grid. This board
+ * has no standing weekly rest-day pattern (see cellStateClasses); a day someone is actually
+ * away is booked as dated leave, not derived from this. */
+export interface EmployeeAvailHours {
+    from: string;
+    to: string;
+}
+export interface Employee {
+    id: number;
+    name: string;
+    role: string;
+    initials: string;
+    color: string;
+    weekHours: number;
+    /** Full-time-equivalent percentage, e.g. 100 for a full-timer, 60 for 0.6 FTE. */
+    pct: number;
+    /** Hours per week this person is contracted to, as agreed with them. Per-person rather than
+     * a venue default: ScheduleSettings holds pay rates only, and EmployeeProfiles.workingHour
+     * is where the figure is actually stated. Undefined means nobody has agreed one. */
+    contractHours?: number;
+    rate: number;
+    positions: string[];
+    /** One entry per visible day of the horizon; null = day off. */
+    shifts: DaySlot[];
+    remarks: EmployeeRemark[];
+    section: string;
+    compGroup?: string;
+    mobile?: string;
+    dial?: string;
+    /** Outlets this person may be rostered at. */
+    locations?: string[];
+    payBasis?: 'hourly' | 'monthly';
+    /** The figure as agreed with them, in payBasis's unit — `rate` above is always the
+     * hourly figure derived from this and is what the grid actually costs shifts with. */
+    payAmount?: number;
+    maxHours?: number;
+    maxOtHours?: number;
+    otAfterDaily?: number;
+    preferences?: string[];
+    seniority?: 'senior' | 'junior' | '';
+    /** Recurring days off (full-timer) or days available (part-timer) — see
+     * EmployeeAvailHours above for why the grid does not read this. */
+    availDays?: boolean[];
+    availHours?: EmployeeAvailHours[];
+    /** POS sign-in code. Optional: rostering, costing and publishing never depend on it. */
+    passcode?: string;
+    masterUser?: boolean;
+}
+export interface Section {
+    id: string;
+    label: string;
+    roles: string[];
+    /** The "Unassigned" bucket — always present, never deletable. */
+    system?: boolean;
+}
+export interface OpenShift {
+    id: number;
+    dayIdx: number;
+    position: string;
+    required: number;
+    filledBy: number | null;
+    sen?: 'junior' | 'senior';
+    empType?: 'full' | 'part';
+    /** Optional custom label for this open shift, shown above the time on its card
+     * (e.g. "Weekend cover") — distinct from the position it asks for. */
+    name?: string;
+    /** Hours this record asks for. Defaults to the active shift template's hours at
+     * creation, but the shift popover lets a manager retime one open shift on its own. */
+    start: string;
+    end: string;
+    breakMins?: number;
+}
+export interface ShiftTemplate {
+    key: string;
+    label: string;
+    start: string;
+    end: string;
+    color: string;
+    active: boolean;
+    breakMins: number;
+}
+/** Coverage requirement for one shift template: position -> [Mon..Sun] headcount. */
+export type CoverageRow = Record<string, number[]>;
+/** What an hour costs, by the kind of day it falls on — the ScheduleSettings document's whole
+ * content. `regular` multiplies ORDINARY hours and `overtime` multiplies hours past the OT
+ * threshold; a NORMAL day has no `regular` because an ordinary hour at ordinary pay is 1×.
+ *
+ * REST_DAY is carried but unread: this board has no standing weekly rest-day pattern to decide
+ * which dates are rest days (see cellStateClasses), so nothing can ask for its rates yet. */
+export interface PayRate {
+    NORMAL: {
+        overtime: number;
+    };
+    REST_DAY: {
+        regular: number;
+        overtime: number;
+    };
+    PUBLIC_HOLIDAY: {
+        regular: number;
+        overtime: number;
+    };
+}
+export interface ScheduleRules {
+    coverage: Record<string, CoverageRow>;
+    openFrom: string;
+    openTo: string;
+    /** Per grid day (0 = Mon) trading windows straight off the outlet's own profile — one or
+     * more `{start, end}` pairs a day (a lunch/dinner split reads as two windows, not one that
+     * spans the gap between them), empty for a structurally closed day. `openFrom`/`openTo`
+     * above stay the widest span across the whole week: the coverage bar, day timeline and shift
+     * forms are still drawn against one axis for the whole board, not a different one per day. */
+    dayHours: Array<{
+        start: string;
+        end: string;
+    }>[];
+    payRate: PayRate;
+    otAfterDaily: number;
+    /** Weekly sales forecast (RM) — the stats row's editable input and the figure the
+     * per-day forecast curve distributes across the week. */
+    salesForecast: number;
+    /** Weekday indices (0 = Mon) the venue never opens on. Empty by default — this seed venue
+     * runs every day. Feeds copy-week's and export's "Closed" labeling. */
+    closedWeekdays: number[];
+    /** Labour cost target as a % of sales — Settings page "Labour budget" tab. */
+    labourTarget: number;
+    /** When true, the weekly labour cap is derived from salesForecast * labourTarget instead
+     * of being a standalone figure. */
+    budgetFromSales: boolean;
+    /** Weekly labour cap (RM), editable directly when budgetFromSales is false. */
+    budget: number;
+    /** Monthly OT cap (hours) — Settings page "Overtime" tab. */
+    otCapHours: number;
+    /** Monthly OT budget (RM), advisory only. */
+    otBudget: number;
+    notify: {
+        waConnected: boolean;
+        waNumber: string;
+        waDisplayName: string;
+        defaults: {
+            wa: boolean;
+            push: boolean;
+            email: boolean;
+        };
+    };
+}
+export interface PendingChange {
+    empId: number;
+    dayIdx: number;
+    kind: 'add' | 'change' | 'remove';
+    label: string;
+}
+export type NotifyChannel = 'wa' | 'push' | 'email';
+export interface ScheduleVersionSnapshot {
+    id: number;
+    name: string;
+    weekHours: number;
+    shifts: DaySlot[];
+}
+export interface ScheduleVersion {
+    v: number;
+    at: Date;
+    by: string;
+    note: string;
+    changeCount: number;
+    staffAffected: number;
+    snapshot: ScheduleVersionSnapshot[];
+}
+export type ScheduleStatusTone = 'neutral' | 'warn' | 'ok' | 'locked';
+export interface ScheduleStatusInfo {
+    tone: ScheduleStatusTone;
+    label: string;
+    hint: string;
+    allLocked: boolean;
+}
+/** Someone in the business's employee directory who is not yet on THIS outlet's schedule —
+ * they may already be scheduled elsewhere (see `otherOutlets`), or nowhere at all. Picking one
+ * puts a second, independent EmployeeProfiles document against their `employeeId`; it does not
+ * move or copy their profile from wherever else they work. */
+export interface ExistingStaffCandidate {
+    employeeId: string;
+    name: string;
+    /** Other outlets this person already has a POS/HR association with — not necessarily a
+     * scheduling profile there, just enough context to tell two same-named people apart and to
+     * warn against loaning someone who's clearly based elsewhere. */
+    otherOutlets: string[];
+}
+export interface CompGroupMeta {
+    basis: 'Hourly' | 'Monthly';
+    rate: number;
+    note: string;
+}
+/** A manager's note on a DATE, not on a shift — it survives every shift on that date being
+ * deleted, because a day with nothing rostered can still be an event day. The title is what
+ * makes the note visible on the day card; the description shows on hover. */
+export interface ScheduleDayNote {
+    title: string;
+    desc: string;
+}
+/** One named slice of a staffing-demand period: "of the 8 people, 2 on grill". Named rows are
+ * a PART of the period's headcount, never an addition to it — whatever they don't name is the
+ * "any position" remainder, which is derived and never stored. */
+export interface DemandRole {
+    position: string;
+    n: number;
+}
+/** A stretch of a day and how many people the floor needs across it. Deliberately not a shift:
+ * it carries no person and no times anybody works, so five staggered shifts can add up to the
+ * five people it asks for at 4pm without any of them being "the" shift for it. */
+export interface DemandPeriod {
+    from: string;
+    to: string;
+    n: number;
+    /** Absent and empty mean the same thing — "anybody" — so only a stated breakdown is kept. */
+    roles?: DemandRole[];
+}
+/** One slice of a day where neither what was asked for nor who is on the floor changes. The
+ * timeline draws one of these per segment and the day's percentage is their weighted sum. */
+export interface CoverageSegment {
+    from: number;
+    to: number;
+    required: number;
+    scheduled: number;
+    /** Heads asked for that nobody present answers — which is not the same as "too few bodies":
+     * eight people none of whom is a cook leaves a 2-grill ask two short with nobody missing. */
+    short: number;
+    over: number;
+    roles: Array<DemandRole & {
+        required: number;
+        got: number;
+        short: number;
+    }>;
+    /** The unnamed remainder of the period's headcount, and how much of it is covered. */
+    anyReq: number;
+    anyGot: number;
+    /** Nothing was asked for in these hours — an absence of a question, not a gap in one. */
+    none: boolean;
+}
+export type DemandApplyMode = 'day' | 'weekday' | 'weekdays' | 'custom';
+export interface NoticeBanner {
+    variant: 'holiday' | 'info' | 'warning';
+    dayIdx: number;
+    label: string;
+    detail: string;
+    action?: string;
+}
+/** One Auto-Schedule suggestion: put `empId` on `dayIdx` for the given hours/position.
+ * Phase 2 only ever proposes filling an empty day (an open shift or a coverage gap),
+ * so there is no 'change'/'remove' kind like the mockup's fuller engine. */
+export interface Proposal {
+    id: number;
+    empId: number;
+    dayIdx: number;
+    start: string;
+    end: string;
+    role: string;
+    /** Set when this proposal would fill a named OpenShift record. */
+    openId?: number;
+    status: 'pending' | 'rejected';
+}

package/dist/src/views/team/components/PortalConditionForm.vue.d.ts

@@ -17,21 +17,21 @@ type __VLS_Props = {
     title?: string;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    apply: () => any;
     "update-form": (payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any;
+    apply: () => any;
     "update-inherit-mode": (payload: {
         builder: ConditionBuilder;
         mode: "inherit" | "custom";
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onApply?: (() => any) | undefined;
     "onUpdate-form"?: ((payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any) | undefined;
+    onApply?: (() => any) | undefined;
     "onUpdate-inherit-mode"?: ((payload: {
         builder: ConditionBuilder;
         mode: "inherit" | "custom";

package/dist/src/views/team/condition-builders/ConditionBuilderForm.vue.d.ts

@@ -14,17 +14,17 @@ type __VLS_Slots = {} & {
     section?: (props: typeof __VLS_1) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    apply: () => any;
     "update-form": (payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any;
+    apply: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onApply?: (() => any) | undefined;
     "onUpdate-form"?: ((payload: {
         builder: ConditionBuilder;
         form: unknown;
     }) => any) | undefined;
+    onApply?: (() => any) | undefined;
 }>, {
     title: string;
     disable: boolean;