law-common 10.21.1-beta.2 → 10.21.1-beta.3

package/dist/src/utils/entity.flow.util.d.ts

@@ -9,24 +9,24 @@ export type LeaveStatusActionPair = {
  * @param currentStatus - The current status of the leave
  * @param userPermissions - Array of permissions the user has
  * @param combineActions - Array of action values to combine into a single action
- * @param data - Optional function to provide additional visibility conditions based on the entity data
+ * @param actionLabels - Object mapping actions to custom labels
+ * @param data - Optional function to provide additional visibility conditions
  * @returns Array of available actions with labels and values
- * @throws Error if user has multiple permissions for a single action
  */
 export declare function getPermittedActions<T extends LeaveStatusActionPair, E>(entityFlowConfig: {
-    [key in T['status']]?: {
+    [key in T["status"]]?: {
         actions: {
-            [key in T['action']]?: {
+            [key in T["action"]]?: {
                 permissions: string[];
-                next: () => T['status'];
+                next: () => T["status"];
             };
         };
     };
-}, currentStatus: T['status'] | null, userPermissions: string[], combineActions?: T['action'][], actionLabels?: {
-    [key in T['action']]?: string;
+}, currentStatus: T["status"] | null, userPermissions: string[], combineActions?: T["action"][], actionLabels?: {
+    [key in T["action"]]?: string;
 }, data?: (a: E) => {
     [key: string]: () => boolean;
 }): {
     label: string;
-    value: T['action'] | string;
+    value: T["action"] | string;
 }[];

package/dist/src/utils/entity.flow.util.js

@@ -1,15 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPermittedActions = getPermittedActions;
+/**
+ * Converts an action or combined action to a value-label pair
+ * @param action - The action or combined action key
+ * @param actionLabels - Object mapping actions to custom labels
+ * @returns Object with label and value
+ */
+function convertToValueLabel(action, actionLabels) {
+    return {
+        label: actionLabels[action] || action,
+        value: action,
+    };
+}
+/**
+ * Filters actions based on user permissions and visibility conditions
+ * @param actionConfig - The actions configuration for the current status
+ * @param userPermissions - Array of permissions the user has
+ * @param data - Optional function to provide additional visibility conditions
+ * @returns Array of permitted action keys
+ * @throws Error if multiple permissions are found for a single action
+ */
+function _getPermittedActions(actionConfig, userPermissions, data) {
+    return Object.entries(actionConfig)
+        .filter(([actionKey, config]) => {
+        var _a;
+        const actionRequiredPermissions = (_a = config === null || config === void 0 ? void 0 : config.permissions) !== null && _a !== void 0 ? _a : [];
+        const matchingPermissions = actionRequiredPermissions.filter((permission) => userPermissions.includes(permission));
+        if (matchingPermissions.length > 1) {
+            throw new Error(`Multiple permissions found for action ${actionKey}: ${matchingPermissions.join(", ")}`);
+        }
+        return (matchingPermissions.length > 0 &&
+            (!data ||
+                !data({})[matchingPermissions[0]] ||
+                data({})[matchingPermissions[0]]()));
+    })
+        .map(([actionKey, _]) => actionKey);
+}
+/**
+ * Combines specified actions into a single action if all are present
+ * @param permittedActions - Array of permitted action keys
+ * @param combineActions - Array of actions to combine
+ * @returns Array of action keys, with combined action if applicable
+ */
+function combinePermittedActions(permittedActions, combineActions) {
+    if (combineActions.length === 0) {
+        return permittedActions;
+    }
+    const isCombinedActionPresent = combineActions.every((action) => permittedActions.includes(action));
+    if (isCombinedActionPresent) {
+        const combinedValue = combineActions.join("_");
+        return [
+            ...permittedActions.filter((action) => !combineActions.includes(action)),
+            combinedValue,
+        ];
+    }
+    return permittedActions;
+}
 /**
  * Gets available actions for a leave based on current status and user permissions
  * @param entityFlowConfig - The flow configuration for the entity
  * @param currentStatus - The current status of the leave
  * @param userPermissions - Array of permissions the user has
  * @param combineActions - Array of action values to combine into a single action
- * @param data - Optional function to provide additional visibility conditions based on the entity data
+ * @param actionLabels - Object mapping actions to custom labels
+ * @param data - Optional function to provide additional visibility conditions
  * @returns Array of available actions with labels and values
- * @throws Error if user has multiple permissions for a single action
  */
 function getPermittedActions(entityFlowConfig, currentStatus, userPermissions, combineActions = [], actionLabels = {}, data = (_) => ({})) {
     var _a;
@@ -18,34 +74,10 @@ function getPermittedActions(entityFlowConfig, currentStatus, userPermissions, c
         return [];
     }
     const actionConfig = ((_a = entityFlowConfig[currentStatus]) === null || _a === void 0 ? void 0 : _a.actions) || {};
-    // Filter actions based on user permissions
-    const permittedActions = Object.entries(actionConfig)
-        .filter(([actionKey, config]) => {
-        var _a;
-        const actionRequiredPermissions = (_a = config.permissions) !== null && _a !== void 0 ? _a : [];
-        const matchingPermissions = actionRequiredPermissions.filter((permission) => userPermissions.includes(permission));
-        // Check for multiple permissions
-        if (matchingPermissions.length > 1) {
-            throw new Error(`Multiple permissions found for action ${actionKey}: ${matchingPermissions.join(', ')}`);
-        }
-        return matchingPermissions.length > 0 && (!data || !data({})[matchingPermissions[0]] || data({})[matchingPermissions[0]]());
-    })
-        .map(([actionKey, _]) => ({
-        label: actionLabels[actionKey] || actionKey,
-        value: actionKey,
-    }));
-    // // Combine specified actions if all are present and combineActions is not empty
-    if (combineActions.length > 0) {
-        const isCombinedActionPresent = combineActions.every((action) => permittedActions.some((a) => a.value === action));
-        if (isCombinedActionPresent) {
-            return [
-                ...permittedActions.filter((action) => !combineActions.includes(action.value)),
-                {
-                    label: actionLabels[combineActions.join('_')] || combineActions.join('_'),
-                    value: combineActions.join('_'),
-                },
-            ];
-        }
-    }
-    return permittedActions;
+    // Get permitted actions
+    const permittedActions = _getPermittedActions(actionConfig, userPermissions, data);
+    // Combine actions if specified
+    const finalActions = combinePermittedActions(permittedActions, combineActions);
+    // Convert to value-label pairs
+    return finalActions.map((action) => convertToValueLabel(action, actionLabels));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "law-common",
- "version": "10.21.1-beta.2",
+ "version": "10.21.1-beta.3",
  "description": "",
  "main": "dist/index.js",
  "files": [