@feedmepos/mf-hrm-portal 2.2.5-dev → 2.2.5-dev.10

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

@@ -0,0 +1,27 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+/** Column facts shared by the day header and every `.shift-cell` under it.
+ *
+ * The mockup builds these inline in its cell loop (`cell.className = 'shift-cell' + …`) and
+ * again in its header loop, which is exactly how the two drifted: closing a day painted the
+ * header and left the cells beneath it clean. One helper, both consumers.
+ *
+ * Two of the mockup's cell states are deliberately absent here:
+ *   - `wk-off` — this board has no standing weekly-off pattern to read (same reason
+ *     `otRateOn()` drops the mockup's rest-day case).
+ *   - `peek` / `week-start` — the mockup renders a multi-week horizon, so it has columns
+ *     outside the selected range and interior week boundaries. This board's visible range
+ *     is exactly one week, so neither can ever fire.
+ */
+export declare function isPastDate(date: Date): boolean;
+export declare function isWeekendDate(date: Date): boolean;
+/** Month-edge compares neighbours in the VISIBLE column order, not raw weekday
+ * index — a lone Daily-view column has no on-screen neighbour to differ from. */
+export declare function isMonthEdgeAt(board: ScheduleBoardApi, colIndex: number): boolean;
+export interface ScheduleCellState {
+    locked: boolean;
+    'closed-day': boolean;
+    'month-edge': boolean;
+    past: boolean;
+}
+/** The class object for one grid cell in column `colIndex` (its weekday is `dayIdx`). */
+export declare function cellStateClasses(board: ScheduleBoardApi, dayIdx: number, colIndex: number): ScheduleCellState;

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

@@ -0,0 +1,18 @@
+export interface ScheduleClashState {
+    open: boolean;
+    message: string;
+    onConfirm: (() => void) | null;
+}
+/** Generic Yes/No conflict-confirmation primitive — the mockup's `askClash`/clashModal,
+ * reused across several flows (leave clashes, overlapping shifts, etc). */
+export declare function useScheduleClashDetection(): {
+    state: {
+        open: boolean;
+        message: string;
+        onConfirm: (() => void) | null;
+    };
+    ask: (message: string, onConfirm: () => void) => void;
+    confirm: () => void;
+    close: () => void;
+};
+export type ScheduleClashDetectionApi = ReturnType<typeof useScheduleClashDetection>;

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

@@ -0,0 +1,19 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleCopySkipReport {
+    leave: number;
+    already: number;
+    hours: number;
+    full: number;
+    closed: number;
+}
+/** The mockup's Copy schedule feature (copyLastWeek/copyThisWeekForward), ported against this
+ * board's per-week-offset bucket cache instead of the mockup's absolute 91-day horizon. Split
+ * shifts (copyUnitsOf in the mockup) aren't ported — WorkSlot has no splitId concept in this
+ * data model, so each slot is copied as its own unit. */
+export declare function useScheduleCopyWeek(board: ScheduleBoardApi, handlers?: {
+    onDemandChanged?: () => void;
+}): {
+    copyLastWeek: (mode: "staffed" | "open") => Promise<void>;
+    copyThisWeekForward: (mode: "staffed" | "open") => Promise<void>;
+};
+export type ScheduleCopyWeekApi = ReturnType<typeof useScheduleCopyWeek>;

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

@@ -0,0 +1,43 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export declare function slotHours(start: string, end: string): number;
+export interface ScheduleDayCost {
+    hours: number;
+    otHours: number;
+    base: number;
+    ot: number;
+    total: number;
+}
+export interface SchedulePositionCost {
+    position: string;
+    base: number;
+    ot: number;
+    total: number;
+}
+export interface ScheduleSectionCost {
+    id: string;
+    label: string;
+    base: number;
+    ot: number;
+    total: number;
+    rows: SchedulePositionCost[];
+}
+export interface ScheduleOtRisk {
+    empId: number;
+    name: string;
+    hours: number;
+    contract: number;
+}
+/** Weekly labour cost + monthly OT gauge for the collapsible cost rail, built off one
+ * per-day breakdown so the rail's totals and the stats row's per-day figures can never
+ * disagree about what a day cost. */
+export declare function useScheduleCostRail(board: ScheduleBoardApi): {
+    collapsed: import("vue").Ref<boolean, boolean>;
+    byDay: import("vue").ComputedRef<ScheduleDayCost[]>;
+    weeklyCost: import("vue").ComputedRef<number>;
+    otHours: import("vue").ComputedRef<number>;
+    monthlyOtUsed: import("vue").ComputedRef<number>;
+    monthlyOtCapHours: number;
+    bySection: import("vue").ComputedRef<ScheduleSectionCost[]>;
+    otRisk: import("vue").ComputedRef<ScheduleOtRisk[]>;
+};
+export type ScheduleCostRailApi = ReturnType<typeof useScheduleCostRail>;

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

@@ -0,0 +1,48 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleDayNoteState {
+    open: boolean;
+    dayIdx: number | null;
+    left: number;
+    top: number;
+}
+export interface ScheduleDayNoteOptions {
+    /** Toasts for the writes that happen on the spot — closing a day, repricing it, saving. */
+    onToast?: (message: string) => void;
+}
+/** One decimal, always: "2×" reads as a count, and 1.5 beside a bare 2 in one sentence looks
+ * like two different kinds of number. Ported from the mockup's fmtRate(). */
+export declare function fmtRate(rate: number): string;
+/** The date card editor — opened by clicking a day card or its pencil. Everything on it is a
+ * fact about the DATE, applying to the whole column: a titled note, whether the venue opens,
+ * and whether the day bills at the holiday rate. Ported from the mockup's openDayNote() /
+ * saveDayNote() / dnToggleClosed() / dnToggleHoliday().
+ *
+ * The mockup re-renders the grid on the two toggles and rebuilds the popover from a stashed
+ * draft so half-typed text survives; Vue re-renders in place, so the draft just stays in the
+ * refs and there is nothing to stash. */
+export declare function useScheduleDayNote(board: ScheduleBoardApi, opts?: ScheduleDayNoteOptions): {
+    state: {
+        open: boolean;
+        dayIdx: number | null;
+        left: number;
+        top: number;
+    };
+    dayIdx: import("vue").ComputedRef<number | null>;
+    title: import("vue").Ref<string, string>;
+    desc: import("vue").Ref<string, string>;
+    savedNote: import("vue").ComputedRef<import("../types").ScheduleDayNote | null>;
+    hasSaved: import("vue").ComputedRef<boolean>;
+    whenLabel: import("vue").ComputedRef<string>;
+    isClosed: import("vue").ComputedRef<boolean>;
+    isAuto: import("vue").ComputedRef<boolean>;
+    rateApplies: import("vue").ComputedRef<boolean>;
+    closedHint: import("vue").ComputedRef<"Nothing is required or rostered on this date." | "The venue does not open — this date only.">;
+    holidayHint: import("vue").ComputedRef<string>;
+    openFor: (dayIdx: number, anchor: HTMLElement) => void;
+    close: () => void;
+    toggleClosed: () => void;
+    toggleHoliday: () => void;
+    save: () => void;
+    remove: () => void;
+};
+export type ScheduleDayNoteApi = ReturnType<typeof useScheduleDayNote>;

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

@@ -0,0 +1,77 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleRosterApi } from './useScheduleRoster';
+import type { ScheduleAreaBoardApi } from './useScheduleAreaBoard';
+declare function minToHHMM(m: number): string;
+export interface ScheduleTimelineBar {
+    key: string;
+    left: number;
+    width: number;
+    cls: string;
+    label: string;
+    sub?: string;
+    title: string;
+    brk?: {
+        left: number;
+        width: number;
+    };
+    laneTop?: number;
+    laneHeight?: number;
+    onClick?: () => void;
+}
+export interface ScheduleTimelineRow {
+    key: string;
+    kind: 'open' | 'employee' | 'position';
+    swatchColor?: string;
+    swatchClass?: string;
+    avatarInitials?: string;
+    avatarColor?: string;
+    name: string;
+    sub: string;
+    bars: ScheduleTimelineBar[];
+    minHeight?: number;
+    emptyText?: string;
+    onTrackClick?: () => void;
+}
+export interface ScheduleHourCell {
+    m: number;
+    clock: string;
+    open: boolean;
+    state: '' | 'short' | 'met' | 'over';
+    barHeightPct: number;
+    title: string;
+    n: number;
+}
+export declare function useScheduleDayTimeline(board: ScheduleBoardApi, roster: ScheduleRosterApi, areaBoard: ScheduleAreaBoardApi, handlers: {
+    onAddShift: (empId: number, dayIdx: number) => void;
+    onEditShift: (empId: number, dayIdx: number) => void;
+    onEditLeave: (empId: number, dayIdx: number) => void;
+    onOpenAssign: (openId: number) => void;
+    onAddAreaShift: (dayIdx: number, position: string) => void;
+}): {
+    dayIdx: import("vue").ComputedRef<number>;
+    axis: import("vue").ComputedRef<{
+        from: number;
+        to: number;
+        span: number;
+    }>;
+    hours: import("vue").ComputedRef<{
+        m: number;
+        clock: string;
+    }[]>;
+    isOpenHour: (m: number) => boolean;
+    openShiftsRow: import("vue").ComputedRef<ScheduleTimelineRow | null>;
+    employeeRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
+    positionTimelineRows: import("vue").ComputedRef<ScheduleTimelineRow[]>;
+    footer: import("vue").ComputedRef<{
+        cells: ScheduleHourCell[];
+        staffCount: number;
+        totalHours: number;
+        totalWages: number;
+        peakN: number;
+        lowN: number;
+        peakAt: number | undefined;
+    }>;
+    minToHHMM: typeof minToHHMM;
+};
+export type ScheduleDayTimelineApi = ReturnType<typeof useScheduleDayTimeline>;
+export {};

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

@@ -0,0 +1,76 @@
+import type { CoverageSegment, DaySlot, DemandPeriod, Employee, Proposal } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export declare function toMin(t: string): number;
+export declare function minToHHMM(m: number): string;
+/** Minutes from midnight for a start/end pair, with the end pushed past 1440 when it wraps —
+ * so an overnight stretch stays one interval rather than two that cross zero. */
+export declare function spanOf(start: string, end: string): [number, number];
+/** 12-hour clock for prose — the sheet and the popovers read as sentences, and "16:00" in the
+ * middle of one does not. */
+export declare function t12(hhmm: string): string;
+/** The timeline's two end labels — "8am", "10:30pm", meridiem spelled out. */
+export declare function minToShort(m: number): string;
+export declare function rangeText(from: number, to: number): string;
+export declare function roleTotalOf(p: DemandPeriod): number;
+/** The unnamed part of a period's headcount. Derived, never typed — so it cannot disagree with
+ * the total above it. Negative means the breakdown has overrun that total. */
+export declare function anyLeftOf(p: DemandPeriod): number;
+export interface ScheduleCoverageAxis {
+    from: number;
+    to: number;
+}
+/** Staffing demand, and coverage read against it.
+ *
+ * Storage follows this board's dayNotes rather than the mockup's flat `di` index: the mockup
+ * renders one long horizon so a day index identifies a date, but this board pages through
+ * weeks, and demand put on this Monday must not reappear on every other Monday. So a date's
+ * own demand is keyed by ISO date, and a standing weekday rule is keyed by weekday index.
+ *
+ * A date's own demand wins over the weekday rule it would otherwise inherit — "every Tuesday
+ * needs eight" is a standing statement, and "this Tuesday is different" has to be able to
+ * override it without rewriting the rule. */
+export declare function useScheduleDemand(board: ScheduleBoardApi): {
+    byDate: Record<string, DemandPeriod[]>;
+    byWeekday: Record<number, DemandPeriod[]>;
+    demandFor: (dayIdx: number) => DemandPeriod[];
+    hasDemandOn: (dayIdx: number) => boolean;
+    demandIsOwn: (dayIdx: number) => boolean;
+    setDateDemand: (dayIdx: number, periods: DemandPeriod[]) => void;
+    clearDateDemand: (dayIdx: number) => void;
+    setWeekdayDemand: (weekday: number, periods: DemandPeriod[]) => void;
+    coverageAxis: (dayIdx: number) => ScheduleCoverageAxis;
+    coverageSegments: (dayIdx: number) => CoverageSegment[];
+    setPreview: (items: Proposal[]) => void;
+    segmentsWith: (dayIdx: number, employees: Employee[]) => CoverageSegment[];
+    dayHeadcount: (dayIdx: number) => {
+        crew: number;
+        peak: number;
+    };
+    coverageImpact: (dayIdx: number, empId: number | null, slot: DaySlot) => {
+        when: string;
+        pctBefore: number;
+        pctAfter: number;
+        stillShort: number;
+        before: {
+            required: number;
+            scheduled: number;
+        };
+        after: {
+            required: number;
+            scheduled: number;
+        };
+        beforeSegs: CoverageSegment[];
+        afterSegs: CoverageSegment[];
+        axis: ScheduleCoverageAxis;
+    } | null;
+    coveragePct: (dayIdx: number) => number | null;
+    shortSegs: (dayIdx: number) => CoverageSegment[];
+    shortInRange: (dayIdx: number, start: string, end: string) => number;
+    biggestGap: (dayIdx: number) => CoverageSegment | null;
+    rangeSummary: import("vue").ComputedRef<{
+        live: number;
+        set: number;
+        shortDays: number;
+    }>;
+};
+export type ScheduleDemandApi = ReturnType<typeof useScheduleDemand>;

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

@@ -0,0 +1,45 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export type ScheduleSegState = 'met' | 'short' | 'over' | 'nodem';
+export interface ScheduleDemandSeg {
+    key: string;
+    from: number;
+    to: number;
+    state: ScheduleSegState;
+    /** Percentage of the day's axis this segment occupies — width means duration. */
+    width: string;
+    label: string;
+}
+export interface ScheduleDemandCell {
+    dayIdx: number;
+    closed: boolean;
+    /** No demand stated on this day — the cell carries its own "+ Set demand" instead. */
+    blank: boolean;
+    pct: number;
+    tone: '' | 'part' | 'short';
+    segs: ScheduleDemandSeg[];
+    hoursFrom: string;
+    hoursTo: string;
+    pctTitle: string;
+    title: string;
+}
+/** What the coverage band draws, one cell per visible day.
+ *
+ * The percentage is the headline and the strip is the reason — a day can be 81% covered with
+ * the missing fifth spread thinly or concentrated at six o'clock, and only one of those is a
+ * problem you act on tonight. */
+export declare function useScheduleDemandRow(board: ScheduleBoardApi, demand: ScheduleDemandApi): {
+    cellFor: (dayIdx: number) => ScheduleDemandCell;
+    cells: import("vue").ComputedRef<{
+        dayIdx: number;
+        colIndex: number;
+        cell: ScheduleDemandCell;
+    }[]>;
+    lead: import("vue").ComputedRef<{
+        blank: boolean;
+        name: string;
+        meta: string;
+    }>;
+    dayTitle: (dayIdx: number) => string;
+};
+export type ScheduleDemandRowApi = ReturnType<typeof useScheduleDemandRow>;

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

@@ -0,0 +1,145 @@
+import type { DemandApplyMode, DemandPeriod } from '../types';
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleDemandApi } from './useScheduleDemand';
+export interface ScheduleDemandSuggestion {
+    why: string;
+    periods: DemandPeriod[];
+}
+export interface ScheduleDemandSheetOptions {
+    onToast?: (message: string) => void;
+    /** Positions the breakdown can name — the same list the shift editor offers. */
+    positionOptions: () => string[];
+    /** Called instead of a toast when "+ Position breakdown" is pressed and there is no position
+     * to name yet — the page opens its Add Position popup for that period. */
+    onNeedPosition?: (periodIdx: number, roleIdx: number) => void;
+}
+/** The demand sheet — editing happens on a DRAFT, so Save is a real commit and closing is a
+ * real cancel. The sheet also carries the recurrence choice, because "every Tuesday" is a
+ * property of the statement being made rather than a second screen. */
+export declare function useScheduleDemandSheet(board: ScheduleBoardApi, demand: ScheduleDemandApi, opts: ScheduleDemandSheetOptions): {
+    open: import("vue").Ref<boolean, boolean>;
+    dayIdx: import("vue").Ref<number | null, number | null>;
+    periods: import("vue").Ref<{
+        from: string;
+        to: string;
+        n: number;
+        roles?: {
+            position: string;
+            n: number;
+        }[] | undefined;
+    }[], DemandPeriod[] | {
+        from: string;
+        to: string;
+        n: number;
+        roles?: {
+            position: string;
+            n: number;
+        }[] | undefined;
+    }[]>;
+    apply: import("vue").Ref<DemandApplyMode, DemandApplyMode>;
+    applyOptions: import("vue").ComputedRef<({
+        on: boolean;
+        key: "day";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "every";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "weekdays";
+        label: string;
+        sub: string;
+    } | {
+        on: boolean;
+        key: "custom";
+        label: string;
+        sub: string;
+    })[]>;
+    weekdayButtons: import("vue").ComputedRef<{
+        i: number;
+        label: string;
+        on: boolean;
+    }[]>;
+    toggleCustomDay: (i: number) => void;
+    applyNote: import("vue").ComputedRef<string>;
+    overlapWarning: import("vue").ComputedRef<string>;
+    whenLabel: import("vue").ComputedRef<string>;
+    openFor: (idx: number) => void;
+    close: () => void;
+    addPeriod: () => void;
+    removePeriod: (i: number) => void;
+    setHeads: (i: number, value: number | string) => void;
+    addRole: (i: number) => void;
+    addRoleNamed: (i: number, position: string) => void;
+    requestNewPosition: (i: number, k: number) => void;
+    removeRole: (i: number, k: number) => void;
+    setRoleCount: (i: number, k: number, value: number | string) => void;
+    setRolePosition: (i: number, k: number, position: string) => void;
+    anyLeft: (p: DemandPeriod) => number;
+    coverageRows: import("vue").ComputedRef<{
+        when: string;
+        required: number;
+        scheduled: number;
+        varies: boolean;
+        pct: number;
+        tone: "short" | "part" | "met" | "over";
+        note: string;
+    }[]>;
+    coverageTotal: import("vue").ComputedRef<{
+        required: number;
+        scheduled: number;
+        pct: number;
+        tone: "short" | "part" | "met" | "over";
+        note: string;
+    }>;
+    saving: import("vue").Ref<boolean, boolean>;
+    save: () => Promise<void>;
+    suggestion: import("vue").Ref<{
+        why: string;
+        periods: {
+            from: string;
+            to: string;
+            n: number;
+            roles?: {
+                position: string;
+                n: number;
+            }[] | undefined;
+        }[];
+    } | null, ScheduleDemandSuggestion | {
+        why: string;
+        periods: {
+            from: string;
+            to: string;
+            n: number;
+            roles?: {
+                position: string;
+                n: number;
+            }[] | undefined;
+        }[];
+    } | null>;
+    suggestionRows: import("vue").ComputedRef<{
+        when: string;
+        n: number;
+        word: string;
+    }[]>;
+    suggest: () => void;
+    acceptSuggestion: () => void;
+    dismissSuggestion: () => void;
+    canCopy: import("vue").ComputedRef<boolean>;
+    copyOpen: import("vue").Ref<boolean, boolean>;
+    copyPicks: Record<number, boolean>;
+    copyRows: import("vue").ComputedRef<{
+        dayIdx: number;
+        label: string;
+        sub: string;
+    }[]>;
+    copySub: import("vue").ComputedRef<string>;
+    openCopy: () => void;
+    closeCopy: () => void;
+    confirmCopy: () => Promise<void>;
+    setApply: (k: DemandApplyMode) => DemandApplyMode;
+};
+export type ScheduleDemandSheetApi = ReturnType<typeof useScheduleDemandSheet>;

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

@@ -0,0 +1,22 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleDragPayload {
+    empId: number;
+    dayIdx: number;
+}
+/** Native HTML5 drag & drop for moving an existing shift card between employee/day cells.
+ * The mockup's other drag source — a staff-rail row dragged onto an open shift — is an
+ * area-view feature (`r.draggable = viewMode === 'area'` there); this board is employee-view
+ * only, so that gesture doesn't exist here — filling an open shift goes through the Assign
+ * popover (click) instead. */
+export declare function useScheduleDragDrop(board: ScheduleBoardApi): {
+    dragging: import("vue").Ref<{
+        empId: number;
+        dayIdx: number;
+    } | null, ScheduleDragPayload | {
+        empId: number;
+        dayIdx: number;
+    } | null>;
+    startShiftDrag: (empId: number, dayIdx: number, ev: DragEvent) => void;
+    endDrag: () => void;
+    dropOnCell: (targetEmpId: number, targetDayIdx: number) => void;
+};

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

@@ -0,0 +1,41 @@
+import type { Employee, Proposal } from '../types';
+/** The one form every SMALL avatar wears — `.sc-av`, `.ch-av`, `.ap-av`, `.tl-av`, and the
+ * shift editor's `.sp2-who-av`. A tint of the person's colour behind their own colour, never a
+ * solid fill with white text: at 17–30px the initials are the only identifier, and knocking
+ * them out to white on a saturated disc costs the contrast that makes them legible.
+ *
+ * None of those classes declare a background of their own, so they REQUIRE this — a bare
+ * `<span class="sc-av">` renders as an invisible disc.
+ *
+ * The big identity avatars are the opposite case and take no inline style at all: `.emp-avatar`,
+ * `.dp-emp-av` and `.pub-change-av` are neutral in CSS, because a name sits right beside them
+ * and a filled disc would out-shout it. */
+export declare function avatarTint(color?: string | null): Record<string, string>;
+export interface ScheduleEmployeeLoad {
+    emp: Employee;
+    hours: number;
+    cost: number;
+    contract: number;
+    partTime: boolean;
+    /** Hours as a fraction of contract, capped at 1 — the load bar's width. */
+    pct: number;
+    barColor: string;
+    otHours: number;
+    /** Of `hours`, how many are auto-schedule suggestions not yet on the board. */
+    proposedHours: number;
+    /** The board's own hours as a fraction of contract: where the fill ends and the suggested part starts. */
+    boardPct: number;
+    /** The suggested part's width on the bar, as a fraction of contract. With no contract to measure
+     * against it fills the track, so suggested hours still show. */
+    proposedPct: number;
+}
+/** This person's live (not rejected) suggestions in the week on screen. */
+export declare function proposedSlotsOf(emp: Employee, proposalAt?: (empId: number, dayIdx: number) => Proposal | undefined): Pick<Proposal, 'start' | 'end'>[];
+/** One person's load against their contract, derived from the shifts actually on the board
+ * rather than from the stored `weekHours` field, so the bar can never disagree with the row
+ * of cards beside it.
+ *
+ * The staff rail (area view) and the grid's name column (employee view) are the same list of
+ * the same people; they used to be two pieces of markup reading two different numbers. This
+ * is the single one — the mockup's own note on empIdentityHTML(). */
+export declare function employeeLoadOf(emp: Employee, proposed?: Pick<Proposal, 'start' | 'end'>[]): ScheduleEmployeeLoad;

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

@@ -0,0 +1,35 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+import type { ScheduleAnchorRect } from './schedule-popover-position';
+export type ScheduleEmployeeMenuAction = 'profile' | 'edit' | 'hl' | 'remove';
+export interface ScheduleEmployeeMenuState {
+    open: boolean;
+    empId: number | null;
+    anchor: ScheduleAnchorRect | null;
+    left: number;
+    top: number;
+}
+/** The ⋯ menu on a team member's row — V6.2's #empMenu: profile, update, highlight, remove. The actions that need a page-level surface (profile panel,
+ * edit wizard, confirm dialog) come in as handlers; highlight lives here. */
+export declare function useScheduleEmployeeMenu(board: ScheduleBoardApi, handlers: {
+    onProfile: (empId: number) => void;
+    onEdit: (empId: number) => void;
+    onRemove: (empId: number) => void;
+}): {
+    state: {
+        open: boolean;
+        empId: number | null;
+        anchor: {
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+        } | null;
+        left: number;
+        top: number;
+    };
+    employee: import("vue").ComputedRef<import("../types").Employee | undefined>;
+    openFor: (empId: number, anchor: HTMLElement) => void;
+    close: () => void;
+    go: (action: ScheduleEmployeeMenuAction) => void;
+};
+export type ScheduleEmployeeMenuApi = ReturnType<typeof useScheduleEmployeeMenu>;

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

@@ -0,0 +1,16 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ScheduleEmployeeProfileState {
+    open: boolean;
+    empId: number | null;
+}
+/** Employee profile side sheet — opened from the staff-rail row menu or by clicking
+ * an employee's identity block. */
+export declare function useScheduleEmployeeProfile(board: ScheduleBoardApi): {
+    state: {
+        open: boolean;
+        empId: number | null;
+    };
+    employee: import("vue").ComputedRef<import("../types").Employee | null>;
+    openFor: (empId: number) => void;
+    close: () => void;
+};

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

@@ -0,0 +1,26 @@
+import type { ScheduleBoardApi } from './useScheduleBoard';
+export interface ExportShiftCell {
+    note: string;
+    shifts: {
+        when: string;
+        pos: string;
+    }[];
+}
+export interface ExportMatrix {
+    head: string[];
+    body: (string | ExportShiftCell)[][];
+    foot: string[];
+}
+/** 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. */
+export declare function useScheduleExport(board: ScheduleBoardApi): {
+    buildExportMatrix: () => ExportMatrix;
+    pdfPreviewOpen: import("vue").Ref<boolean, boolean>;
+    pdfHtml: import("vue").ComputedRef<string>;
+    openPdfPreview: () => void;
+    closePdfPreview: () => void;
+    printNow: () => void;
+    exportJpg: () => void;
+};
+export type ScheduleExportApi = ReturnType<typeof useScheduleExport>;

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>;