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

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

@@ -0,0 +1,14 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export type ScheduleViewMode = 'area' | 'employee';
+export type ScheduleGranularity = 'day' | 'week';
+/** State for the filter-bar's mode/granularity selects. Granularity delegates straight to
+ * the board, which owns the day/week grid state — both area and employee grouping combine
+ * with either granularity. Outlet switching isn't modeled at all yet, so that control has
+ * no state here; it's a static label in the component. */
+export declare function useScheduleFilterBar(board: ScheduleBoardApi): {
+    mode: import("vue").Ref<ScheduleViewMode, ScheduleViewMode>;
+    granularity: import("vue").Ref<import("./useScheduleBoard").ScheduleGranularity, import("./useScheduleBoard").ScheduleGranularity>;
+    setMode: (value: ScheduleViewMode) => boolean;
+    setGranularity: (value: ScheduleGranularity) => boolean;
+};
+export type ScheduleFilterBarApi = ReturnType<typeof useScheduleFilterBar>;

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

@@ -0,0 +1,80 @@
+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): {
+    state: {
+        open: boolean;
+        pinned: boolean;
+        peek: boolean;
+        wide: boolean;
+        left: number;
+        top: number;
+    };
+    ctx: import("vue").Ref<{
+        from: number;
+        to: number;
+        required: number;
+        scheduled: number;
+        short: number;
+        over: number;
+        roles: {
+            position: string;
+            n: number;
+            required: number;
+            got: number;
+            short: number;
+        }[];
+        anyReq: number;
+        anyGot: number;
+        none: boolean;
+        dayIdx: number;
+    } | null, (CoverageSegment & {
+        dayIdx: number;
+    }) | {
+        from: number;
+        to: number;
+        required: number;
+        scheduled: number;
+        short: number;
+        over: number;
+        roles: {
+            position: string;
+            n: number;
+            required: number;
+            got: number;
+            short: number;
+        }[];
+        anyReq: number;
+        anyGot: number;
+        none: boolean;
+        dayIdx: number;
+    } | null>;
+    view: import("vue").ComputedRef<{
+        crew: number;
+        peak: number;
+        when: string;
+        day: string;
+        none: boolean;
+        required: number;
+        scheduled: number;
+        short: number;
+        over: number;
+        missing: {
+            short: number;
+            position: string;
+        }[];
+        missingNote: string;
+    } | null>;
+    segEnter: (dayIdx: number, from: number, to: number, anchor: HTMLElement) => void;
+    segLeave: () => void;
+    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/useScheduleLeave.d.ts

@@ -0,0 +1,59 @@
+import type { LeaveSlot } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export type TimeOffSelection = 'OFF_DAY' | 'ANNUAL' | 'MEDICAL' | 'EMERGENCY' | 'UNPAID';
+export declare const TIME_OFF_OPTIONS: Array<{
+    value: TimeOffSelection;
+    label: string;
+}>;
+export type ScheduleLeaveMode = 'all' | 'am' | 'pm';
+export interface ScheduleLeaveState {
+    open: boolean;
+    empId: number | null;
+    dayIdx: number | null;
+    /** Booking a new record, rather than editing one that is already on the day. */
+    isNew: boolean;
+    selection: TimeOffSelection;
+    mode: ScheduleLeaveMode;
+}
+/** The leave editor — V6.2's "Book leave" dialog: a reason, how much of the day it covers, and
+ * what that does to the person's availability. Opened from the add popup's Off day / Leave rows
+ * (booking) and from an existing leave card (editing, or approving a pending request). */
+export declare function useScheduleLeave(board: ScheduleBoardApi): {
+    state: {
+        open: boolean;
+        empId: number | null;
+        dayIdx: number | null;
+        isNew: boolean;
+        selection: TimeOffSelection;
+        mode: ScheduleLeaveMode;
+    };
+    employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
+    activeSlot: import("vue").ComputedRef<LeaveSlot | null>;
+    options: import("vue").ComputedRef<({
+        readonly mode: "all";
+        readonly name: "Full day";
+    } | {
+        readonly mode: "am";
+        readonly name: "Half day AM";
+    } | {
+        readonly mode: "pm";
+        readonly name: "Half day PM";
+    })[]>;
+    span: import("vue").ComputedRef<{
+        from: string;
+        to: string;
+        hours: number;
+    }>;
+    valid: import("vue").ComputedRef<boolean>;
+    selectionLabel: import("vue").ComputedRef<string>;
+    dayLabel: import("vue").ComputedRef<string>;
+    hoursText: import("vue").ComputedRef<string>;
+    coverText: import("vue").ComputedRef<"Full day" | "Half day AM" | "Half day PM">;
+    openFor: (empId: number, dayIdx: number, reason?: string | null) => void;
+    close: () => void;
+    save: () => Promise<void>;
+    approve: () => Promise<void>;
+    reject: () => void;
+    remove: () => Promise<void>;
+};
+export type ScheduleLeaveApi = ReturnType<typeof useScheduleLeave>;

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

@@ -0,0 +1,15 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleCoverageBadge {
+    position: string;
+    required: number;
+    scheduled: number;
+    short: boolean;
+}
+/** Coverage badges for a day's header card — required vs. scheduled headcount per
+ * position, from the single active shift template's coverage matrix. */
+export declare function useScheduleLegend(board: ScheduleBoardApi): {
+    coveragePositions: import("vue").ComputedRef<string[]>;
+    coverageForDay: (dayIdx: number) => ScheduleCoverageBadge[];
+    dayIsShort: (dayIdx: number) => boolean;
+    dayCardTitle: (dayIdx: number) => string;
+};

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

@@ -0,0 +1,9 @@
+import type { useScheduleOnboardingWizard } from './useScheduleOnboardingWizard';
+import type { useScheduleSetupBanner } from './useScheduleSetupBanner';
+type SetupBannerApi = ReturnType<typeof useScheduleSetupBanner>;
+type OnboardingWizardApi = ReturnType<typeof useScheduleOnboardingWizard>;
+/** Coordinates the welcome banner and wizard without making SchedulePage own onboarding flow. */
+export declare function useScheduleOnboardingFlow(setupBanner: SetupBannerApi, wizard: OnboardingWizardApi): {
+    onWelcomeSetUp: () => void;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import type { Employee } from '../types';
+import type { FdtoScheduleEmployee } from '@feedmepos/hrm-schedule-contract';
+import type { TeamRow } from './onboarding-types';
+export interface OnboardingProfileRow {
+    emp: Employee;
+    row: TeamRow;
+}
+/** Writes the queued team and availability drafts once per employee. */
+export declare function saveOnboardingProfiles(pendingTeam: Set<number>, pendingAvail: Map<number, Array<{
+    dayOfWeek: number;
+    start: string;
+    end: string;
+}>>, rows: OnboardingProfileRow[], rawEmployee: (id: number) => FdtoScheduleEmployee | undefined): Promise<void>;