@feedmepos/mf-hrm-portal 2.0.25 → 2.1.0-dev.2

package/dist/src/api/audit-log/index.d.ts

@@ -9,6 +9,9 @@ declare const AuditLogAPI: {
         actions?: string[];
         outcomes?: string[];
         feedmeAdminActors?: boolean;
+        search?: string;
+        searchUserIds?: string[];
+        searchSubjects?: string[];
     }): Promise<number>;
     read(params?: {
         limit?: number;
@@ -21,6 +24,9 @@ declare const AuditLogAPI: {
         actions?: string[];
         outcomes?: string[];
         feedmeAdminActors?: boolean;
+        search?: string;
+        searchUserIds?: string[];
+        searchSubjects?: string[];
     }): Promise<AuditLogEntry[]>;
     /**
      * FeedMe-admin options for the User filter. `actors` is the named admin list (internal

package/dist/src/components/CheckboxInput.vue.d.ts

@@ -141,8 +141,8 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
 }>> & Readonly<{
     "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
 }>, {
-    max: number;
     min: number;
+    max: number;
     disable: boolean;
     showAllToggle: string | boolean;
     includeDisabledOptionsWhenSelectAll: boolean;

package/dist/src/components/button/ResponsiveFabButton.vue.d.ts

@@ -1,3 +1,9 @@
 import { type FmButtonProps } from '@feedmepos/ui-library';
-declare const _default: import("vue").DefineComponent<FmButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FmButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+interface Props extends FmButtonProps {
+    /** Whether the page has a fixed bottom footer (e.g. a pagination bar) the mobile FAB should raise above. */
+    hasFooterBelow?: boolean;
+}
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    hasFooterBelow: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/table/EmptyDataTemplate/index.vue.d.ts

@@ -1,6 +1,7 @@
 interface Props {
     title: string;
     subtitle: string;
+    isOutlined?: boolean;
     action?: {
         text: string;
         icon?: string;
@@ -11,7 +12,9 @@ declare var __VLS_8: {};
 type __VLS_Slots = {} & {
     action?: (props: typeof __VLS_8) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    isOutlined: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/src/components/table/TableEmptyState.vue.d.ts

@@ -0,0 +1,31 @@
+import { type Breakpoints } from '@feedmepos/ui-library';
+interface Props {
+    title: string;
+    subtitle: string;
+    isEmpty: boolean;
+    isLoading?: boolean;
+    /**
+     * At what width do the column titles disappear? Below/at this breakpoint the message is
+     * styled as a standalone bordered card instead of blending flat under the table header. Must
+     * mirror the wrapped FmTable's own `shrink-at` prop (both default to "sm"); pass `false` if
+     * the table never collapses.
+     */
+    collapseAt?: Breakpoints | false;
+}
+declare var __VLS_1: {
+    isEmpty: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    isLoading: boolean;
+    collapseAt: Breakpoints | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/composables/useBasePermission.d.ts

@@ -7,6 +7,7 @@ export type CategoryGroup = {
     options: {
         label: string;
         value: string;
+        optionKey: string;
     }[];
     selectedSubjects: string[];
     isMultiAction: boolean;

package/dist/src/composables/useConditionDraft.d.ts

@@ -0,0 +1,40 @@
+import { type Ref } from 'vue';
+/**
+ * Local draft state for condition editing — tracks form field edits and
+ * inherit/custom mode changes for each builder, keyed by `${subject}::${builderKey}`.
+ *
+ * Drafts remain local until explicitly committed via `applyDrafts`. Closing
+ * a popover/menu without applying discards uncommitted changes.
+ */
+export interface DraftKey {
+    subject: string;
+    builderKey: string;
+}
+export interface ConditionDraft {
+    /** The local draft form value for this builder. */
+    formValue: unknown;
+    /** Local draft inherit/custom mode for builders under a cover subject. */
+    inheritMode?: 'inherit' | 'custom';
+}
+/**
+ * Creates a composable to manage local draft state for condition editing.
+ *
+ * @param committedSource - Ref to the committed state (e.g., modelValue, reportExtraConditions)
+ *   used to detect external changes and reset drafts accordingly
+ */
+export declare function useConditionDraft<T>(committedSource?: Ref<T>): {
+    drafts: Ref<Map<string, {
+        formValue: unknown;
+        inheritMode?: "inherit" | "custom" | undefined;
+    }> & Omit<Map<string, ConditionDraft>, keyof Map<any, any>>, Map<string, ConditionDraft> | (Map<string, {
+        formValue: unknown;
+        inheritMode?: "inherit" | "custom" | undefined;
+    }> & Omit<Map<string, ConditionDraft>, keyof Map<any, any>>)>;
+    setDraft: (key: DraftKey, draft: ConditionDraft) => void;
+    getDraft: (key: DraftKey) => ConditionDraft | undefined;
+    hasDraftsForSubject: (subject: string) => boolean;
+    getDraftsForSubject: (subject: string) => Map<string, ConditionDraft>;
+    clearDraftsForSubject: (subject: string) => void;
+    clearAllDrafts: () => void;
+    clearDraft: (key: DraftKey) => void;
+};

package/dist/src/composables/useCoverConditionOverride.d.ts

@@ -0,0 +1,61 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { FdoPermissionRule } from '@feedmepos/core/entity';
+import { type IFdtoPortalPermissionsWithVisibilityCondition } from '@feedmepos/hrm-permission';
+import { type ConditionBuilder, type ConditionSummary } from '@feedmepos/hrm-permission/condition-builder';
+/**
+ * Generic "category cover" machinery for the portal permission editor: any
+ * subject whose permission-definition category declares a cover (see
+ * `getCoverSubjectFor`) can have its condition-builder settings either
+ * inherit the cover subject's condition or hold a custom override — and the
+ * cover subject itself can push its condition down onto every individual
+ * override in the category.
+ *
+ * Zero knowledge of any specific subject, category, or builder lives here —
+ * everything is driven by the `defs` list (permission definitions carrying
+ * `category`/`isCategoryCover`) and the `ConditionBuilder` contract
+ * (`ownedFields`, `appliesToActions`, `summarizeForm`).
+ */
+/** The minimum shape the editor's per-row entry needs to expose for cover/inherit resolution. */
+export interface CoverConditionEntry {
+    /** Index of this subject's raw rule in the model, or null when no direct rule exists yet. */
+    index: number | null;
+    subject: string;
+    label: string;
+    actions: readonly string[];
+}
+/** Resolution handles passed to `onOverridesConflict` — the caller (UI) decides which to invoke. */
+export interface CoverOverrideResolution {
+    /** Strip this builder's fragment from every covered override rule (dropping a rule once it carries no more conditions and its actions are covered). */
+    override: () => void;
+    /** Leave every covered override rule untouched. */
+    keep: () => void;
+}
+export interface UpdateBuilderConditionOptions {
+    /** Create a direct rule even if the resulting condition is empty (used when explicitly switching to "custom"). */
+    forceCreateRule?: boolean;
+    afterCommit?: () => void;
+    /**
+     * Invoked instead of auto-resolving when this write touches a cover
+     * subject's row and other subjects in the same category hold a
+     * conditioned override on this builder. Omit only for callers that don't
+     * need a confirmation step — the write then defaults to keeping the
+     * overrides untouched (the non-destructive choice).
+     */
+    onOverridesConflict?: (resolution: CoverOverrideResolution) => void;
+}
+export interface BuilderConditionDraft {
+    builder: ConditionBuilder;
+    form: unknown;
+    mode: 'inherit' | 'custom';
+}
+export declare function useCoverConditionOverride(rules: Ref<FdoPermissionRule[]>, defs: ComputedRef<IFdtoPortalPermissionsWithVisibilityCondition[]>, updateRules: (next: FdoPermissionRule[]) => void): {
+    getCoverSubject: (subject: string) => string | undefined;
+    coverLabel: (subject: string) => string | undefined;
+    shouldShowInheritToggle: (entry: CoverConditionEntry, builder: ConditionBuilder) => boolean;
+    inheritMode: (entry: CoverConditionEntry, builder: ConditionBuilder) => "inherit" | "custom";
+    setInheritMode: (entry: CoverConditionEntry, builder: ConditionBuilder, mode: "inherit" | "custom") => void;
+    inheritedSummary: (entry: CoverConditionEntry, builder: ConditionBuilder, timeZone: string) => ConditionSummary | undefined;
+    getEffectiveActions: (subject: string) => readonly string[];
+    updateBuilderCondition: (entry: CoverConditionEntry, builder: ConditionBuilder, form: unknown, options?: UpdateBuilderConditionOptions) => void;
+    applyConditionDrafts: (entry: CoverConditionEntry, updates: BuilderConditionDraft[], options?: UpdateBuilderConditionOptions) => void;
+};

package/dist/src/helpers/business-timezone.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Business timezone resolution — a pure mapping from country code to IANA
+ * timezone, used as a fallback when a business has no explicit timezone
+ * configured. Kept independent of any store so it's testable in isolation;
+ * callers resolve the business/country from their own store and pass the
+ * plain values in.
+ */
+/** IANA timezone for a country code; falls back to the runtime's local zone for unknown/missing codes. */
+export declare function getCountryTimezone(country?: string): string;
+/** Minimal shape a business needs for timezone resolution. */
+export interface BusinessTimezoneSource {
+    timezone?: string;
+    timeZone?: string;
+    country?: string;
+}
+/**
+ * Resolve the effective IANA timezone for a business: an explicit business
+ * timezone field wins (`timezone`, then legacy `timeZone`), otherwise falls
+ * back to the country's default timezone (business's own country first, then
+ * `fallbackCountry`).
+ */
+export declare function resolveBusinessTimezone(business: BusinessTimezoneSource | undefined, fallbackCountry?: string): string;

package/dist/src/helpers/permission-set.d.ts

@@ -71,8 +71,10 @@ export declare function filterStalePermissions(permissions: FdoPermissionRule[],
  * `allCustomReports` positive grant, preventing redundant data from being saved.
  *
  * - If the cover rule has `manage` selected → every individual rule in that bucket is
- *   fully covered and dropped entirely.
- * - Otherwise, only covered non-manage actions are stripped from individual rules.
+ *   fully covered and dropped entirely only when the cover condition also covers the
+ *   individual rule.
+ * - Otherwise, only covered non-manage actions are stripped from individual rules when
+ *   the cover condition also covers the individual rule.
  *   If `manage` was present and any non-manage action is stripped (breaking the
  *   "manage = all non-manage selected" invariant), `manage` is also stripped.
  *   Rules that end up with no remaining actions are dropped.

package/dist/src/helpers/rule.d.ts

@@ -20,7 +20,8 @@ export declare function getMaxDiscount(rules: FdoPermissionRule[]): number;
 export declare function getManagableRestaurantIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
 export declare function hasAdminRule(rules: FdoPermissionRule[]): boolean;
 export declare function usableRoleIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
-export declare function fromValue(values: string[], maxDiscountPercentage: number): {
+export declare function extractReportExtraCondition(rule: FdoPermissionRule): Record<string, unknown> | undefined;
+export declare function fromValue(values: string[], maxDiscountPercentage: number, periodConditions?: Map<string, Record<string, unknown>>): {
     subject: string;
     actions: ("delete" | "create" | "update" | "read" | "manage")[];
     conditions: object;

package/dist/src/stores/permission-set.d.ts

@@ -1,5 +1,6 @@
 import type { IFdtoPermissionSet, IFdtoCreatePermissionSetReq, IFdtoUpdatePermissionSetReq } from '@/types/permission-set';
 export declare const usePermissionSetStore: () => {
+    isLoading: import("vue").Ref<boolean, boolean>;
     permissionSets: import("vue").Ref<{
         id: string;
         permissions: {
@@ -30,6 +31,7 @@ export declare const usePermissionSetStore: () => {
         name: string;
     }[]>;
     $state: {
+        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -75,12 +77,14 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "permissionSets">>;
+    }, "isLoading" | "permissionSets">>;
     $patch(partialState: import("pinia")._DeepPartial<{
+        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -98,6 +102,7 @@ export declare const usePermissionSetStore: () => {
         }[];
     }>): void;
     $patch<F extends (state: {
+        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -145,11 +150,12 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "permissionSets">>, options?: {
+    }, "isLoading" | "permissionSets">>, options?: {
         detached?: boolean;
     } & import("vue").WatchOptions): () => void;
     $onAction(callback: import("pinia").StoreOnActionListener<"permissionSet", Pick<{
@@ -182,11 +188,12 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "permissionSets">, Pick<{
+    }, "isLoading" | "permissionSets">, Pick<{
         permissionSets: import("vue").Ref<{
             id: string;
             permissions: {
@@ -216,6 +223,7 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
@@ -250,6 +258,7 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
+        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;

package/dist/src/types/audit-log.d.ts

@@ -1 +1 @@
-export type { AuditLogEntry, AuditLogMetadata, AuditLogOutcome, AuditLogResolvedFrom } from '@feedmepos/hrm-permission';
+export type { AuditLogEntry, AuditLogMetadata, AuditLogOperation, AuditLogOutcome, AuditLogResolvedFrom, } from '@feedmepos/hrm-permission';

package/dist/src/views/audit-log/event-line.d.ts

@@ -0,0 +1,13 @@
+export interface EventLineSource {
+    eventKey?: string;
+    params?: Record<string, string | number>;
+    operationLabel?: string;
+}
+type Translate = (key: string, params?: Record<string, unknown>) => string;
+export declare function splitEventKey(key: string): {
+    entity: string;
+    verb: string;
+} | null;
+export declare function humanizeSegment(segment: string): string;
+export declare function renderEventLine(t: Translate, source: EventLineSource): string;
+export {};