@zeniai/client-epic-state 5.0.82 → 5.0.83-betaRR0

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyList/archiveCardPolicyEpic.js

@@ -0,0 +1,42 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { removeCardPolicyTemplate } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../../responsePayload';
+import { archiveCardPolicy, updateArchiveCardPolicyFetchStatus, } from './cardPolicyListReducer';
+/**
+ * `DELETE /cards/1.0/policy-templates/{id}`. Modeled like
+ * `deleteBillEpic`: typed as bare `ZeniAPIResponse` (no `data` body
+ * expected) with `isSuccessStatus` driving the success branch. On
+ * success the entity slice drops the template via
+ * `removeCardPolicyTemplate(templateId)` and the view slice records
+ * `Completed` (also pruning the ID from `templateIds`).
+ */
+export const archiveCardPolicyEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(archiveCardPolicy.match), mergeMap((action) => {
+    const templateId = action.payload;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-templates/${templateId}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response)) {
+            const actions = [
+                removeCardPolicyTemplate(templateId),
+                updateArchiveCardPolicyFetchStatus({
+                    fetchState: 'Completed',
+                    templateId,
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return of(updateArchiveCardPolicyFetchStatus({
+                fetchState: 'Error',
+                error: response.status,
+                templateId,
+            }));
+        }
+    }), catchError((error) => of(updateArchiveCardPolicyFetchStatus({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Archive card-policy REST API call errored out' +
+            JSON.stringify(error)),
+        templateId,
+    }))));
+}));

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyList/cardPolicyListReducer.js

@@ -0,0 +1,72 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    templateIds: [],
+    fetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    archiveFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    archiveTargetTemplateId: undefined,
+};
+const cardPolicyList = createSlice({
+    name: 'cardPolicyList',
+    initialState,
+    reducers: {
+        /**
+         * Kick off the `GET /cards/1.0/policy-templates` request. The
+         * accompanying epic dispatches `updateCardPolicyTemplates(templates)`
+         * + `updateCardPolicyStats(stats)` on the entity slice and
+         * `updateCardPolicyListFetchStatus` here (also supplying the ordered
+         * `templateIds` on success).
+         */
+        fetchCardPolicyList(draft) {
+            draft.fetchState.fetchState = 'In-Progress';
+            draft.fetchState.error = undefined;
+        },
+        updateCardPolicyListFetchStatus(draft, action) {
+            draft.fetchState.fetchState = action.payload.fetchState;
+            draft.fetchState.error = action.payload.error;
+            if (action.payload.templateIds != null) {
+                draft.templateIds = action.payload.templateIds;
+            }
+        },
+        /**
+         * Kick off the `DELETE /cards/1.0/policy-templates/{id}` request.
+         * The accompanying epic dispatches `removeCardPolicyTemplate(id)` on
+         * the entity slice on success + `updateArchiveCardPolicyFetchStatus`
+         * here. The view layer also drops the ID from `templateIds` so the
+         * list stays in sync without re-fetching.
+         */
+        archiveCardPolicy: {
+            reducer(draft, action) {
+                draft.archiveFetchState.fetchState = 'In-Progress';
+                draft.archiveFetchState.error = undefined;
+                draft.archiveTargetTemplateId = action.payload;
+            },
+            prepare(templateId) {
+                return { payload: templateId };
+            },
+        },
+        updateArchiveCardPolicyFetchStatus(draft, action) {
+            draft.archiveFetchState.fetchState = action.payload.fetchState;
+            draft.archiveFetchState.error = action.payload.error;
+            if (action.payload.fetchState === 'Completed') {
+                if (action.payload.templateId != null) {
+                    draft.templateIds = draft.templateIds.filter((id) => id !== action.payload.templateId);
+                }
+                draft.archiveTargetTemplateId = undefined;
+            }
+            else if (action.payload.fetchState === 'Error') {
+                draft.archiveTargetTemplateId = undefined;
+            }
+        },
+        clearCardPolicyList(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchCardPolicyList, updateCardPolicyListFetchStatus, archiveCardPolicy, updateArchiveCardPolicyFetchStatus, clearCardPolicyList, } = cardPolicyList.actions;
+export default cardPolicyList.reducer;

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyList/cardPolicyListSelector.js

@@ -0,0 +1,21 @@
+import { getCardPolicyStats, getCardPolicyTemplatesByIds, } from '../../../../../entity/cardPolicy/cardPolicySelector';
+export function getCardPolicyListView(state) {
+    const { cardPolicyListState, cardPolicyState } = state;
+    return {
+        templates: getCardPolicyTemplatesByIds(cardPolicyState, cardPolicyListState.templateIds),
+        templateIds: cardPolicyListState.templateIds,
+        fetchState: cardPolicyListState.fetchState,
+        archiveFetchState: cardPolicyListState.archiveFetchState,
+        archiveTargetTemplateId: cardPolicyListState.archiveTargetTemplateId,
+        stats: getCardPolicyStats(cardPolicyState),
+    };
+}
+export function getCardPolicyListFetchState(state) {
+    return state.cardPolicyListState.fetchState;
+}
+export function getArchiveCardPolicyFetchState(state) {
+    return state.cardPolicyListState.archiveFetchState;
+}
+export function getCardPolicyTemplateIds(state) {
+    return state.cardPolicyListState.templateIds;
+}

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyList/cardPolicyListState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyList/fetchCardPolicyListEpic.js

@@ -0,0 +1,56 @@
+import { from, of } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { toCardPolicyStats, toCardPolicyTemplateList, } from '../../../../../entity/cardPolicy/cardPolicyPayload';
+import { updateCardPolicyStats, updateCardPolicyTemplates, } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../../responsePayload';
+import { fetchCardPolicyList, updateCardPolicyListFetchStatus, } from './cardPolicyListReducer';
+/**
+ * `GET /cards/1.0/policy-templates`. On success the response carries
+ * both the tenant-wide `stats` block and a `templates[]` array whose
+ * rows are wrapped in `{data: {cards_applied, template}}` (the same
+ * envelope the create endpoint returns). We split the result into
+ * three actions:
+ *
+ *   1. `updateCardPolicyTemplates` — full replace of the entity map.
+ *   2. `updateCardPolicyStats` — entity-level cached stats.
+ *   3. `updateCardPolicyListFetchStatus` — view lifecycle + ordered IDs.
+ */
+export const fetchCardPolicyListEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyList.match), 
+// `exhaustMap` (rather than `mergeMap`) so a duplicate
+// `fetchCardPolicyList` dispatched while the previous one is still
+// in flight is dropped instead of producing a second HTTP request.
+// This guards against React 18 StrictMode, which mount-cleanup-
+// remounts the screen's mount effect with a stale closure of
+// `listFetchState`, causing the same effect to dispatch this
+// action twice synchronously. Retry-after-error still works
+// because the previous inner observable has completed by the time
+// the user retries.
+exhaustMap(() => {
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-templates`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            const templates = toCardPolicyTemplateList(response.data);
+            const stats = toCardPolicyStats(response.data.stats);
+            const actions = [
+                updateCardPolicyTemplates(templates),
+                updateCardPolicyStats(stats),
+                updateCardPolicyListFetchStatus({
+                    fetchState: 'Completed',
+                    templateIds: templates.map((t) => t.templateId),
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return of(updateCardPolicyListFetchStatus({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(updateCardPolicyListFetchStatus({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch card-policy list REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyReducer.js

@@ -0,0 +1,45 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    createCardPolicyTemplateRequestState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    lastCreatedCardPolicyTemplateIds: [],
+    lastCreateCardPolicyTemplateErrors: [],
+};
+const createCardPolicy = createSlice({
+    name: 'createCardPolicy',
+    initialState,
+    reducers: {
+        createCardPolicyTemplates: {
+            reducer(draft, action) {
+                draft.createCardPolicyTemplateRequestState.fetchState = 'In-Progress';
+                draft.createCardPolicyTemplateRequestState.error = undefined;
+                draft.lastCreatedCardPolicyTemplateIds = [];
+                draft.lastCreateCardPolicyTemplateErrors = [];
+                // Mirrors `lastIssueSourceChatSessionId` so list/drawer can attribute the in-flight create to its AI CFO session.
+                draft.lastCreateCardPolicySourceChatSessionId =
+                    action.payload.sourceChatSessionId;
+            },
+            prepare(request) {
+                return { payload: request };
+            },
+        },
+        updateCreateCardPolicyTemplateRequestState(draft, action) {
+            draft.createCardPolicyTemplateRequestState.fetchState =
+                action.payload.fetchState;
+            draft.createCardPolicyTemplateRequestState.error = action.payload.error;
+            if (action.payload.templateIds != null) {
+                draft.lastCreatedCardPolicyTemplateIds = action.payload.templateIds;
+            }
+            if (action.payload.perItemErrors != null) {
+                draft.lastCreateCardPolicyTemplateErrors = action.payload.perItemErrors;
+            }
+        },
+        clearCreateCardPolicy(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { createCardPolicyTemplates, updateCreateCardPolicyTemplateRequestState, clearCreateCardPolicy, } = createCardPolicy.actions;
+export default createCardPolicy.reducer;

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicySelector.js

@@ -0,0 +1,39 @@
+export function getCreateCardPolicyTemplateRequestState(state) {
+    return state.createCardPolicyTemplateRequestState;
+}
+/**
+ * All template ids created by the most recent successful bulk submit
+ * (in BE return order). Empty array before any submit or after
+ * `clearCreateCardPolicy`. Multi-policy AI CFO submit reads this; the
+ * single-policy `getLastCreatedCardPolicyTemplateId` selector below is a
+ * convenience for the manual-create routing flow.
+ */
+export function getLastCreatedCardPolicyTemplateIds(state) {
+    return state.lastCreatedCardPolicyTemplateIds;
+}
+/**
+ * Convenience selector returning the first id of the most recent submit
+ * — kept ergonomic for the single-create page's "navigate to detail on
+ * success" logic, which only ever creates one template. Returns
+ * `undefined` when no submit has succeeded or when the list is empty.
+ */
+export function getLastCreatedCardPolicyTemplateId(state) {
+    return state.lastCreatedCardPolicyTemplateIds[0];
+}
+/**
+ * Per-item errors returned by the bulk POST when one or more templates
+ * failed to persist. Empty on full success; populated on partial success
+ * so the UI can render a "N of M created" banner alongside the navigate /
+ * close behaviour driven by the lifecycle selector.
+ */
+export function getLastCreateCardPolicyTemplateErrors(state) {
+    return state.lastCreateCardPolicyTemplateErrors;
+}
+/**
+ * Chat session id that triggered the most recent bulk create — used by the
+ * card policy list screen and the AI CFO drawer to scope "creating…" and
+ * "created" placeholders to the active conversation.
+ */
+export function getLastCreateCardPolicySourceChatSessionId(state) {
+    return state.lastCreateCardPolicySourceChatSessionId;
+}

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyTemplateEpic.js

@@ -0,0 +1,53 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateCreatedCardPolicyTemplate } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { toBulkCreateCardPolicyTemplateError, toCreateCardPolicyTemplatesRequestBody, } from '../../../../../entity/cardPolicy/cardPolicyPayload';
+import { createZeniAPIStatus, isSuccessStatus } from '../../../../../responsePayload';
+import { createCardPolicyTemplates, updateCreateCardPolicyTemplateRequestState, } from './createCardPolicyReducer';
+/**
+ * `POST /cards/1.0/policy-templates` (bulk). Builds the bulk wire body
+ * from the camelCased action payload, sends one round-trip, and on
+ * success fans out:
+ *  - one `updateCreatedCardPolicyTemplate` on the entity slice per row
+ *    in `templates_created` (so the entity store is hydrated with every
+ *    created template), and
+ *  - one `updateCreateCardPolicyTemplateRequestState` with the ordered
+ *    id list + per-item errors so the view can render partial-success
+ *    UX without re-touching the wire types.
+ *
+ * Partial success (`errors.length > 0` with at least one template
+ * created) is still treated as `Completed` — the lifecycle is binary
+ * and the per-item errors live on the slice for the UI to inspect.
+ * Hard failures (non-success `status` or thrown errors) map to `Error`
+ * the same way they did pre-bulk.
+ */
+export const createCardPolicyTemplatesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(createCardPolicyTemplates.match), mergeMap((action) => {
+    const body = toCreateCardPolicyTemplatesRequestBody(action.payload);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-templates`, body)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            const { templates_created, errors } = response.data;
+            const createdTemplates = templates_created.map((row) => row.template);
+            const actions = [
+                ...createdTemplates.map((template) => updateCreatedCardPolicyTemplate(template)),
+                updateCreateCardPolicyTemplateRequestState({
+                    fetchState: 'Completed',
+                    perItemErrors: (errors ?? []).map(toBulkCreateCardPolicyTemplateError),
+                    templateIds: createdTemplates.map((template) => template.template_id),
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return of(updateCreateCardPolicyTemplateRequestState({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(updateCreateCardPolicyTemplateRequestState({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Create card-policy templates REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/fetchCardPolicyMccCategoriesEpic.js

@@ -0,0 +1,25 @@
+import { from, of } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { fetchCardPolicyMccCategories, updateCardPolicyMccCategories, updateCardPolicyMccCategoriesFailure, } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../../responsePayload';
+export const fetchCardPolicyMccCategoriesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyMccCategories.match), 
+// `exhaustMap` (rather than `mergeMap`) so a duplicate
+// `fetchCardPolicyMccCategories` dispatched while the previous one
+// is still in flight is dropped instead of producing a second HTTP
+// request. Both the Create and Edit policy screens dispatch this
+// on mount, and React 18 StrictMode invokes their mount effect
+// twice with a stale `mccCategoriesFetchState` closure — without
+// `exhaustMap` that yields two `/cards/mcc-codes` calls.
+exhaustMap(() => {
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/cards/mcc-codes`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            return from([updateCardPolicyMccCategories(response.data)]);
+        }
+        else {
+            return of(updateCardPolicyMccCategoriesFailure(response.status));
+        }
+    }), catchError((error) => of(updateCardPolicyMccCategoriesFailure(createZeniAPIStatus('Unexpected Error', 'Fetch card policy MCC categories REST API call errored out' +
+        JSON.stringify(error))))));
+}));

package/lib/esm/view/spendManagement/chargeCards/chargeCardList/chargeCardListSelector.js

@@ -87,6 +87,31 @@ export const getChargeCardListView = (state, includeCreditAccountDebitSummaryAnd
         hasDebitCard,
     };
 };
+/**
+ * Returns every enriched `ChargeCardWithUser` for the tenant, without
+ * applying the cards-list screen's `searchText` filter or its column
+ * `sortKey/sortOrder`. Used by surfaces that need the raw card universe
+ * decoupled from whatever the user has typed/sorted on the cards list
+ * (e.g. the Card Policy "Apply to Cards" picker, which owns its own
+ * search + sort UI). The list-screen's filter/sort state is intentionally
+ * left untouched so revisits to the cards list still restore the user's
+ * search.
+ */
+export const getAllChargeCardsWithUser = (state) => {
+    const { chargeCardListState, chargeCardState, chargeCardConfigState } = state;
+    const cards = getChargeCardsByIds(chargeCardState, chargeCardListState.cardIds);
+    const chargeCardsWithUser = getChargeCardsWithUser(cards, state);
+    const fetchState = reduceFetchState([
+        chargeCardListState,
+        chargeCardConfigState,
+    ]).fetchState;
+    return {
+        fetchState,
+        error: chargeCardListState.error,
+        cards: chargeCardsWithUser,
+        version: '1.0',
+    };
+};
 export const getMyPendingActivationChargeCardListView = (state) => {
     const { tenantState, chargeCardListState, chargeCardState } = state;
     const cards = getChargeCardsByIds(chargeCardState, chargeCardListState.cardIds);

package/lib/esm/view/spendManagement/chargeCards/issueChargeCard/aiCardCreationFormDraftTypes.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/spendManagement/chargeCards/issueChargeCard/buildAiCardCreationFormDraftSeed.js

@@ -0,0 +1,62 @@
+/**
+ * Build the initial `CardsFormDraft` + companion seed context for a
+ * fresh AI card-creation session. Used by the `seedAiCardCreationFormDraft`
+ * reducer.
+ *
+ * Branches on `initialData.mode`:
+ * - `review`: step-1 team rows start fully checked. Step-2 `cardRows`
+ *   is left empty — `deriveAiCardRowsFromTeams` materializes it on
+ *   subsequent `updateAiCardCreationFormDraft` dispatches.
+ * - `create`: no step-1 list — seed `cardRows` directly from the AI's
+ *   suggested cards (resolving owners via `allUsers`) and leave
+ *   `teamRows` empty.
+ */
+export const buildAiCardCreationFormDraftSeed = ({ initialData, allUsers, }) => {
+    const context = {
+        allUsers,
+        defaultCardOptionId: initialData.cardOptions[0]?.id,
+        mode: initialData.mode,
+        suggestedOwnerUserIdByTeamId: initialData.suggestedOwnerUserIdByTeamId,
+    };
+    if (initialData.mode === 'create') {
+        return {
+            context,
+            draft: {
+                teamRows: [],
+                cardRows: initialData.cardRows.map((seed) => buildCardRowFromSeed(seed, allUsers)),
+            },
+        };
+    }
+    const teamRows = initialData.teamRows.map((row) => ({
+        cardKind: row.cardKind,
+        id: row.id,
+        isChecked: true,
+        label: row.label,
+        value: row.avgMonthlySpend,
+        rightLabel: row.recommendedLimit,
+        rightSubLabel: row.recommendedLimitCadence,
+    }));
+    return {
+        context,
+        draft: {
+            teamRows,
+            cardRows: [],
+        },
+    };
+};
+const buildCardRowFromSeed = (seed, allUsers) => {
+    const selectedUser = seed.suggestedOwnerUserId != null
+        ? allUsers.find((user) => user.userId === seed.suggestedOwnerUserId)
+        : undefined;
+    return {
+        cardKind: seed.cardKind,
+        id: seed.id,
+        label: seed.label,
+        cardOptionId: seed.cardOptionId,
+        owner: {
+            allUsers,
+            selectedUser,
+        },
+        recommendedLimit: seed.recommendedLimit,
+    };
+};

package/lib/esm/view/spendManagement/chargeCards/issueChargeCard/deriveAiCardRowsFromTeams.js

@@ -0,0 +1,47 @@
+/**
+ * Derive the step-2 `cardRows` from the user's step-1 team selection.
+ *
+ * Behaviour:
+ * - One output row per `teamRow.isChecked === true`, in the same order.
+ * - When a team is still checked AND we have a previous row for it, the
+ *   previous row is preserved verbatim — so user edits made in step 2
+ *   aren't blown away when an upstream watchHandler re-derives.
+ * - Newly-included teams fall back to:
+ *     - `cardOptionId = defaultCardOptionId`
+ *     - `selectedUser = the User whose userId === suggestedOwnerUserIdByTeamId[teamId]`
+ *     - `recommendedLimit = numeric parse of `teamRow.rightLabel` (e.g. "$20,000")`
+ */
+export const deriveAiCardRowsFromTeams = ({ teamRows, prevCardRows = [], allUsers, defaultCardOptionId, suggestedOwnerUserIdByTeamId, }) => {
+    const prevById = new Map(prevCardRows.map((row) => [row.id, row]));
+    const userById = new Map(allUsers.map((user) => [user.userId, user]));
+    return teamRows
+        .filter((row) => row.isChecked)
+        .map((teamRow) => {
+        const previous = prevById.get(teamRow.id);
+        if (previous != null) {
+            return previous;
+        }
+        const suggestedUserId = suggestedOwnerUserIdByTeamId[teamRow.id];
+        const selectedUser = suggestedUserId != null ? userById.get(suggestedUserId) : undefined;
+        return {
+            cardKind: teamRow.cardKind,
+            id: teamRow.id,
+            label: teamRow.label,
+            cardOptionId: defaultCardOptionId ?? '',
+            owner: {
+                allUsers,
+                selectedUser,
+            },
+            recommendedLimit: parseLimitToFloat(teamRow.rightLabel),
+        };
+    });
+};
+// Best-effort numeric parse of an AI-provided limit string like "$20,000".
+const parseLimitToFloat = (raw) => {
+    const cleaned = raw.replace(/[^0-9.-]/g, '');
+    if (cleaned.length === 0) {
+        return undefined;
+    }
+    const parsed = Number(cleaned);
+    return Number.isFinite(parsed) ? parsed : undefined;
+};

package/lib/esm/view/spendManagement/chargeCards/issueChargeCard/issueChargeCardEpic.js

@@ -7,7 +7,7 @@ import { updateAllUsers } from '../../../../entity/user/userReducer';
 import { updateUserRoles } from '../../../../entity/userRole/userRoleReducer';
 import { createZeniAPIStatus, isSuccessStatus, } from '../../../../responsePayload';
 import { updateChargeCardList } from '../chargeCardList/chargeCardListReducer';
-import { issueChargeCardSuccessOrFailure, issueChargeCards, updateChargeCardCount, updateDebitCardCount, updateLastSelfIssuedDebitCardId, } from './issueChargeCardReducer';
+import { issueChargeCardSuccessOrFailure, issueChargeCards, updateChargeCardCount, updateDebitCardCount, updateLastIssuedCardIds, updateLastSelfIssuedDebitCardId, } from './issueChargeCardReducer';
 export const issueChargeCardEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(issueChargeCards.match), switchMap(() => {
     const state = state$.value;
     const loggedInUserId = state$.value.tenantState.loggedInUser?.userId;
@@ -87,7 +87,7 @@ export const issueChargeCardEpic = (actions$, state$, zeniAPI) => actions$.pipe(
             actions.push(updateChargeCards(issuedCards), updateAllUsers({ users: response.data.users }), updateUserRoles(response.data.user_roles), updateChargeCardList({
                 chargeCardListPayload: response.data,
                 keepExistingListItems: true,
-            }), updateAddresses(response.data.addresses), updateChargeCardCount(response.data?.cards_count_by_user_id ?? []), updateDebitCardCount(response.data?.debit_cards_count_by_deposit_account_id ?? {}), issueChargeCardSuccessOrFailure({ fetchState: 'Completed' }));
+            }), updateAddresses(response.data.addresses), updateChargeCardCount(response.data?.cards_count_by_user_id ?? []), updateDebitCardCount(response.data?.debit_cards_count_by_deposit_account_id ?? {}), updateLastIssuedCardIds(issuedCards.map((card) => card.card_id)), issueChargeCardSuccessOrFailure({ fetchState: 'Completed' }));
             if (issuedCards.length === 1 &&
                 (issuedCards[0].card_type.code ===
                     'business_virtual_debit_card' ||

package/lib/esm/view/spendManagement/chargeCards/issueChargeCard/issueChargeCardReducer.js

@@ -1,4 +1,6 @@
 import { createSlice } from '@reduxjs/toolkit';
+import { buildAiCardCreationFormDraftSeed } from './buildAiCardCreationFormDraftSeed';
+import { deriveAiCardRowsFromTeams } from './deriveAiCardRowsFromTeams';
 export const initialState = {
     depositAccountIds: [],
     depositAccountsFetchState: { fetchState: 'Not-Started', error: undefined },
@@ -14,6 +16,7 @@ export const initialState = {
     },
     activeChargeCardCount: {},
     activeDebitCardCountByDepositAccountId: {},
+    lastIssuedCardIds: [],
 };
 const issueChargeCard = createSlice({
     name: 'issueChargeCard',
@@ -34,14 +37,19 @@ const issueChargeCard = createSlice({
             },
         },
         issueChargeCards: {
-            prepare() {
-                return { payload: {} };
+            prepare(payload) {
+                return { payload: payload ?? {} };
             },
-            reducer(draft) {
+            reducer(draft, action) {
                 draft.saveStatus.fetchState = 'In-Progress';
                 draft.saveStatus.error = undefined;
+                draft.lastIssueSourceChatSessionId = action.payload.sourceChatSessionId;
+                draft.lastIssuedCardIds = [];
             },
         },
+        updateLastIssuedCardIds(draft, action) {
+            draft.lastIssuedCardIds = action.payload;
+        },
         updateChargeCardsLocalStore(draft, action) {
             draft.localData = action.payload;
         },
@@ -49,6 +57,8 @@ const issueChargeCard = createSlice({
             draft.localData = [...initialState.localData];
             draft.saveStatus = initialState.saveStatus;
             draft.lastSelfIssuedDebitCardId = undefined;
+            draft.lastIssueSourceChatSessionId = undefined;
+            draft.lastIssuedCardIds = [];
         },
         updateLastSelfIssuedDebitCardId(draft, action) {
             draft.lastSelfIssuedDebitCardId = action.payload;
@@ -124,10 +134,58 @@ const issueChargeCard = createSlice({
             draft.depositAccountsFetchState.fetchState = action.payload.fetchState;
             draft.depositAccountsFetchState.error = action.payload.error;
         },
+        /**
+         * Seed the AI card-creation form draft + companion context from the
+         * AI's `interactive_form` payload. Dispatched once when the
+         * `CardsCreationInteractiveForm` mounts (or the AI payload arrives).
+         */
+        seedAiCardCreationFormDraft: {
+            reducer(draft, action) {
+                const { draft: nextDraft, context } = buildAiCardCreationFormDraftSeed({
+                    allUsers: action.payload.allUsers,
+                    initialData: action.payload.initialData,
+                });
+                draft.aiCardCreationFormDraft = nextDraft;
+                draft.aiCardCreationFormDraftContext = context;
+            },
+            prepare(allUsers, initialData) {
+                return { payload: { allUsers, initialData } };
+            },
+        },
+        /**
+         * Replace the form draft from the component's `watchHandler`. In
+         * `review` mode, step-2 `cardRows` is re-derived from `teamRows`
+         * selections so user step-1 edits propagate into step 2 without the
+         * component owning a separate transition handler. The action's own
+         * `cardRows` is passed in as `prevCardRows` (RHF holds the user's
+         * latest step-2 edits) so derivation preserves them for teams that
+         * are still checked and drops rows whose team got unchecked.
+         */
+        updateAiCardCreationFormDraft(draft, action) {
+            const context = draft.aiCardCreationFormDraftContext;
+            if (context == null || context.mode === 'create') {
+                draft.aiCardCreationFormDraft = action.payload;
+                return;
+            }
+            draft.aiCardCreationFormDraft = {
+                teamRows: action.payload.teamRows,
+                cardRows: deriveAiCardRowsFromTeams({
+                    teamRows: action.payload.teamRows,
+                    prevCardRows: action.payload.cardRows,
+                    allUsers: context.allUsers,
+                    defaultCardOptionId: context.defaultCardOptionId,
+                    suggestedOwnerUserIdByTeamId: context.suggestedOwnerUserIdByTeamId,
+                }),
+            };
+        },
+        clearAiCardCreationFormDraft(draft) {
+            draft.aiCardCreationFormDraft = undefined;
+            draft.aiCardCreationFormDraftContext = undefined;
+        },
         clearIssueChargeCard(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { issueChargeCards, updateChargeCardsLocalStore, updateLastSelfIssuedDebitCardId, issueChargeCardSuccessOrFailure, resetIssueChargeCardForm, updateCustomAddressId, updateChargeCardCount, updateDebitCardCount, fetchIssueCardPage, updateDepositAccountsInCards, fetchDepositAccountListForCards, updateDepositAccountListForCardsFetchStatus, clearIssueChargeCard, } = issueChargeCard.actions;
+export const { issueChargeCards, updateChargeCardsLocalStore, updateLastSelfIssuedDebitCardId, updateLastIssuedCardIds, issueChargeCardSuccessOrFailure, resetIssueChargeCardForm, updateCustomAddressId, updateChargeCardCount, updateDebitCardCount, fetchIssueCardPage, updateDepositAccountsInCards, fetchDepositAccountListForCards, updateDepositAccountListForCardsFetchStatus, seedAiCardCreationFormDraft, updateAiCardCreationFormDraft, clearAiCardCreationFormDraft, clearIssueChargeCard, } = issueChargeCard.actions;
 export default issueChargeCard.reducer;