@zeniai/client-epic-state 5.0.92 → 5.0.93-beta0ND

package/lib/esm/view/onboardingView/customerView/onboardingCustomerViewState.js

@@ -26,3 +26,15 @@ export const ALL_ONBOARDING_STEPS = [
     ...ALL_ZENI_USER_ONBOARDING_STEPS_WITHOUT_ACCOUNT,
 ];
 export const toOnboardingStepType = (v) => stringToUnion(v, ALL_ONBOARDING_STEPS);
+export const emptyAiAgentsActivationCounts = {
+    customerCount: 0,
+    glAccountCount: 0,
+    targetTransactionCount: 0,
+    transactionCount: 0,
+    vendorCount: 0,
+};
+export const emptyAiAgentsActivationSubview = {
+    counts: emptyAiAgentsActivationCounts,
+    fetchStatus: { fetchState: 'Not-Started', error: undefined },
+    phases: [],
+};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyDetail/cardPolicyDetailReducer.js

@@ -0,0 +1,52 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    detailTemplateId: undefined,
+    detailFetchState: { fetchState: 'Not-Started', error: undefined },
+    updateFetchState: { fetchState: 'Not-Started', error: undefined },
+    formDraft: undefined,
+};
+const cardPolicyDetail = createSlice({
+    name: 'cardPolicyDetail',
+    initialState,
+    reducers: {
+        fetchCardPolicyDetail: {
+            reducer(draft, action) {
+                draft.detailTemplateId = action.payload;
+                draft.detailFetchState.fetchState = 'In-Progress';
+                draft.detailFetchState.error = undefined;
+                // Prevent a stale draft from a previous template leaking into the new edit session.
+                draft.formDraft = undefined;
+            },
+            prepare(templateId) {
+                return { payload: templateId };
+            },
+        },
+        updateCardPolicyDetailFetchStatus(draft, action) {
+            draft.detailFetchState.fetchState = action.payload.fetchState;
+            draft.detailFetchState.error = action.payload.error;
+        },
+        updateCardPolicyFormDraft(draft, action) {
+            draft.formDraft = action.payload;
+        },
+        updateCardPolicy: {
+            reducer(draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                draft.updateFetchState.fetchState = 'In-Progress';
+                draft.updateFetchState.error = undefined;
+            },
+            prepare(templateId) {
+                return { payload: templateId };
+            },
+        },
+        updateCardPolicyFetchStatus(draft, action) {
+            draft.updateFetchState.fetchState = action.payload.fetchState;
+            draft.updateFetchState.error = action.payload.error;
+        },
+        clearCardPolicyDetail(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchCardPolicyDetail, updateCardPolicyDetailFetchStatus, updateCardPolicyFormDraft, updateCardPolicy, updateCardPolicyFetchStatus, clearCardPolicyDetail, } = cardPolicyDetail.actions;
+export default cardPolicyDetail.reducer;

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyDetail/cardPolicyDetailSelector.js

@@ -0,0 +1,22 @@
+import { getCardPolicyTemplateById } from '../../../../../entity/cardPolicy/cardPolicySelector';
+export function getCardPolicyDetailView(state) {
+    const { cardPolicyDetailState, cardPolicyState } = state;
+    return {
+        templateId: cardPolicyDetailState.detailTemplateId,
+        template: cardPolicyDetailState.detailTemplateId != null
+            ? getCardPolicyTemplateById(cardPolicyState, cardPolicyDetailState.detailTemplateId)
+            : undefined,
+        formDraft: cardPolicyDetailState.formDraft,
+        detailFetchState: cardPolicyDetailState.detailFetchState,
+        updateFetchState: cardPolicyDetailState.updateFetchState,
+    };
+}
+export function getCardPolicyFormDraft(state) {
+    return state.cardPolicyDetailState.formDraft;
+}
+export function getCardPolicyDetailFetchState(state) {
+    return state.cardPolicyDetailState.detailFetchState;
+}
+export function getUpdateCardPolicyFetchState(state) {
+    return state.cardPolicyDetailState.updateFetchState;
+}

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyDetail/cardPolicyDetailState.js

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

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyDetail/fetchCardPolicyDetailEpic.js

@@ -0,0 +1,36 @@
+import { from, of } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { toCardPolicyEditFormDraft, toCardPolicyTemplate, } from '../../../../../entity/cardPolicy/cardPolicyPayload';
+import { updateCreatedCardPolicyTemplate } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../../responsePayload';
+import { fetchCardPolicyDetail, updateCardPolicyDetailFetchStatus, updateCardPolicyFormDraft, } from './cardPolicyDetailReducer';
+export const fetchCardPolicyDetailEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyDetail.match), 
+// `exhaustMap` drops React 18 StrictMode's duplicate mount dispatch instead of
+// emitting a second `/policy-templates/{id}` call.
+exhaustMap((action) => {
+    const templateId = action.payload;
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-templates/${templateId}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            const { template } = response.data;
+            const formDraft = toCardPolicyEditFormDraft(toCardPolicyTemplate(template));
+            const actions = [
+                updateCreatedCardPolicyTemplate(template),
+                updateCardPolicyFormDraft(formDraft),
+                updateCardPolicyDetailFetchStatus({ fetchState: 'Completed' }),
+            ];
+            return from(actions);
+        }
+        else {
+            return of(updateCardPolicyDetailFetchStatus({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(updateCardPolicyDetailFetchStatus({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch card-policy detail REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/cardPolicyDetail/updateCardPolicyEpic.js

@@ -0,0 +1,39 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { toUpdateCardPolicyTemplateRequestBody, } from '../../../../../entity/cardPolicy/cardPolicyPayload';
+import { updateCreatedCardPolicyTemplate } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { createZeniAPIStatus, isSuccessStatus } from '../../../../../responsePayload';
+import { updateCardPolicy, updateCardPolicyFetchStatus, } from './cardPolicyDetailReducer';
+export const updateCardPolicyEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(updateCardPolicy.match), mergeMap((action) => {
+    const templateId = action.payload;
+    const formDraft = state$.value.cardPolicyDetailState.formDraft;
+    if (formDraft == null) {
+        return of(updateCardPolicyFetchStatus({
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Missing form draft', `Cannot update card-policy ${templateId} — no formDraft is loaded.`),
+        }));
+    }
+    const body = toUpdateCardPolicyTemplateRequestBody(formDraft);
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-templates/${templateId}`, body)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            const { template } = response.data;
+            const actions = [
+                updateCreatedCardPolicyTemplate(template),
+                updateCardPolicyFetchStatus({ fetchState: 'Completed' }),
+            ];
+            return from(actions);
+        }
+        else {
+            return of(updateCardPolicyFetchStatus({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(updateCardPolicyFetchStatus({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Update card-policy REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));

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

@@ -0,0 +1,34 @@
+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';
+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,58 @@
+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: {
+        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;
+            }
+        },
+        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,38 @@
+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';
+export const fetchCardPolicyListEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyList.match), 
+// `exhaustMap` drops React 18 StrictMode's duplicate mount dispatch instead of
+// emitting a second `/policy-templates` call.
+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/applyAiCardPolicyFormDraftUpdate.js

@@ -0,0 +1,289 @@
+import { deriveAiPolicyReviewRowsFromInputs } from './deriveAiPolicyReviewRowsFromInputs';
+// Computes the next draft after a watchHandler flush, branching on policyKind:
+//  - auto: pass-through (review chip groups are canonical).
+//  - guided: bridge review chip edits back into source slices, then re-derive review.
+//  - upload: pass through user's review edits; patch "Applied to Cards" from `cardSelections`.
+export const applyAiCardPolicyFormDraftUpdate = ({ next, prev, context, }) => {
+    if (next.policyKind === 'auto') {
+        return next;
+    }
+    if (next.policyKind === 'upload') {
+        return applyUploadUpdate({ next, prev });
+    }
+    return applyGuidedUpdate({ next, prev, context });
+};
+const applyGuidedUpdate = ({ next, prev, context, }) => {
+    const bridged = bridgeGuidedPoliciesReviewToSources({ next, prev });
+    if (context == null) {
+        return bridged;
+    }
+    return {
+        ...bridged,
+        policiesReview: deriveAiPolicyReviewRowsFromInputs({
+            vendorPolicy: bridged.vendorPolicy,
+            categoryPolicy: bridged.categoryPolicy,
+            cardSelections: bridged.cardSelections,
+            limits: bridged.limits,
+            suggestedPoliciesSeed: context.suggestedPoliciesSeed,
+            prevPoliciesReview: bridged.policiesReview,
+        }),
+    };
+};
+const APPLIED_TO_CARDS_GROUP_ID = 'applied-to-cards';
+const LIMITS_GROUP_ID = 'limits';
+const applyUploadUpdate = ({ next, prev, }) => {
+    // Mirror review avatar/limits edits into source slices so bulk-submit (which
+    // reads `cardSelections` for upload's applyToCards) sees the latest intent.
+    const bridged = bridgeUploadPoliciesReviewToSources({ next, prev });
+    if (!haveCardSelectionsChanged(prev?.cardSelections, bridged.cardSelections)) {
+        return bridged;
+    }
+    return {
+        ...bridged,
+        policiesReview: patchUploadReviewWithAppliedCards(bridged.policiesReview, bridged.cardSelections),
+    };
+};
+const haveCardSelectionsChanged = (prevSelections, nextSelections) => {
+    const prevCheckedIds = (prevSelections ?? [])
+        .filter((row) => row.isChecked)
+        .map((row) => row.id);
+    const nextCheckedIds = nextSelections
+        .filter((row) => row.isChecked)
+        .map((row) => row.id);
+    if (prevCheckedIds.length !== nextCheckedIds.length) {
+        return true;
+    }
+    return prevCheckedIds.some((id, idx) => id !== nextCheckedIds[idx]);
+};
+const buildAppliedOwnerSummaries = (cardSelections) => {
+    const summaries = new Map();
+    for (const card of cardSelections) {
+        if (!card.isChecked) {
+            continue;
+        }
+        const existing = summaries.get(card.owner.userId);
+        if (existing != null) {
+            existing.cardIds.push(card.id);
+            continue;
+        }
+        summaries.set(card.owner.userId, {
+            userId: card.owner.userId,
+            displayName: card.owner.displayName,
+            cardIds: [card.id],
+        });
+    }
+    return Array.from(summaries.values());
+};
+// Inserted before "Limits" so visual order stays Vendors → Categories → Cards → Limits.
+export const patchUploadReviewWithAppliedCards = (reviewRows, cardSelections) => {
+    const owners = buildAppliedOwnerSummaries(cardSelections);
+    const cardChips = owners.map((owner) => ({
+        id: owner.userId,
+        label: owner.displayName,
+        chipKind: 'avatar',
+        cardIds: owner.cardIds,
+        isSelected: true,
+    }));
+    const cardsGroup = cardChips.length > 0
+        ? {
+            id: APPLIED_TO_CARDS_GROUP_ID,
+            label: 'Applied to Cards',
+            chips: cardChips,
+        }
+        : null;
+    return reviewRows.map((row) => {
+        const withoutCards = row.chipGroups.filter((group) => group.id !== APPLIED_TO_CARDS_GROUP_ID);
+        if (cardsGroup == null) {
+            return { ...row, chipGroups: withoutCards };
+        }
+        const limitsIdx = withoutCards.findIndex((group) => group.id === LIMITS_GROUP_ID);
+        if (limitsIdx === -1) {
+            return { ...row, chipGroups: [...withoutCards, cardsGroup] };
+        }
+        const before = withoutCards.slice(0, limitsIdx);
+        const after = withoutCards.slice(limitsIdx);
+        return { ...row, chipGroups: [...before, cardsGroup, ...after] };
+    });
+};
+// Routes per-chip diffs back to source slices: limits → `limits`, avatar →
+// `cardSelections`, positive/negative → `vendorPolicy` / `categoryPolicy`.
+const bridgeGuidedPoliciesReviewToSources = ({ next, prev, }) => {
+    if (prev == null || prev.policiesReview.length === 0) {
+        return next;
+    }
+    const reviewDiffs = collectReviewChipDiffs(prev.policiesReview, next.policiesReview);
+    if (reviewDiffs.length === 0) {
+        return next;
+    }
+    let limits = next.limits;
+    let cardSelections = next.cardSelections;
+    let vendorPolicy = next.vendorPolicy;
+    let categoryPolicy = next.categoryPolicy;
+    for (const diff of reviewDiffs) {
+        if (diff.groupKind === 'limits' || diff.chip.id.startsWith('limit-')) {
+            limits = applyLimitChipDiffToLimits(limits, diff);
+            continue;
+        }
+        if (diff.chip.chipKind === 'avatar') {
+            cardSelections = applyAvatarChipDiffToCardSelections(cardSelections, diff);
+            continue;
+        }
+        if (diff.changedFields.has('isSelected')) {
+            const writtenToVendor = tryWriteAllowBlock(vendorPolicy, diff);
+            if (writtenToVendor != null) {
+                vendorPolicy = writtenToVendor;
+                continue;
+            }
+            const writtenToCategory = tryWriteAllowBlock(categoryPolicy, diff);
+            if (writtenToCategory != null) {
+                categoryPolicy = writtenToCategory;
+            }
+        }
+    }
+    return {
+        ...next,
+        limits,
+        cardSelections,
+        vendorPolicy,
+        categoryPolicy,
+    };
+};
+// Upload only mirrors avatar chips into `cardSelections`; vendor/category/limit
+// chips are read by the wire directly from the review groups.
+const bridgeUploadPoliciesReviewToSources = ({ next, prev, }) => {
+    if (prev == null || prev.policiesReview.length === 0) {
+        return next;
+    }
+    const reviewDiffs = collectReviewChipDiffs(prev.policiesReview, next.policiesReview);
+    if (reviewDiffs.length === 0) {
+        return next;
+    }
+    let cardSelections = next.cardSelections;
+    for (const diff of reviewDiffs) {
+        if (diff.chip.chipKind === 'avatar') {
+            cardSelections = applyAvatarChipDiffToCardSelections(cardSelections, diff);
+        }
+    }
+    if (cardSelections === next.cardSelections) {
+        return next;
+    }
+    return { ...next, cardSelections };
+};
+const collectReviewChipDiffs = (prevRows, nextRows) => {
+    const prevById = new Map(prevRows.map((row) => [row.id, row]));
+    const diffs = [];
+    for (const row of nextRows) {
+        const prevRow = prevById.get(row.id);
+        if (prevRow == null) {
+            continue;
+        }
+        const prevGroupsById = new Map(prevRow.chipGroups.map((group) => [group.id, group]));
+        for (const group of row.chipGroups) {
+            const prevGroup = prevGroupsById.get(group.id);
+            if (prevGroup == null) {
+                continue;
+            }
+            const prevChipsById = new Map(prevGroup.chips.map((chip) => [chip.id, chip]));
+            for (const chip of group.chips) {
+                const prevChip = prevChipsById.get(chip.id);
+                if (prevChip == null) {
+                    continue;
+                }
+                const changed = new Set();
+                if (chip.isSelected !== prevChip.isSelected) {
+                    changed.add('isSelected');
+                }
+                if (chip.optionalCode !== prevChip.optionalCode) {
+                    changed.add('optionalCode');
+                }
+                if (changed.size > 0) {
+                    diffs.push({ chip, changedFields: changed, groupKind: group.kind });
+                }
+            }
+        }
+    }
+    return diffs;
+};
+const REVIEW_LIMIT_CHIP_ID_TO_LIMIT_ROW_ID = {
+    'limit-transaction': 'transactionLimit',
+    'limit-receipt': 'requireReceipt',
+};
+const applyLimitChipDiffToLimits = (limits, diff) => {
+    const mapped = REVIEW_LIMIT_CHIP_ID_TO_LIMIT_ROW_ID[diff.chip.id];
+    const directMatch = limits.find((row) => row.id === diff.chip.id) != null;
+    const rowId = mapped ?? (directMatch ? diff.chip.id : undefined);
+    if (rowId == null) {
+        return limits;
+    }
+    const idx = limits.findIndex((row) => row.id === rowId);
+    if (idx === -1) {
+        return limits;
+    }
+    let nextRow = limits[idx];
+    if (diff.changedFields.has('isSelected')) {
+        nextRow = { ...nextRow, isEnabled: diff.chip.isSelected === true };
+    }
+    if (diff.changedFields.has('optionalCode')) {
+        const raw = diff.chip.optionalCode;
+        const numericNext = raw != null && raw !== '' ? Number(raw) : undefined;
+        nextRow = { ...nextRow, amount: numericNext };
+    }
+    if (nextRow === limits[idx]) {
+        return limits;
+    }
+    const copy = limits.slice();
+    copy[idx] = nextRow;
+    return copy;
+};
+const applyAvatarChipDiffToCardSelections = (cardSelections, diff) => {
+    if (!diff.changedFields.has('isSelected')) {
+        return cardSelections;
+    }
+    const targetIds = diff.chip.cardIds != null && diff.chip.cardIds.length > 0
+        ? diff.chip.cardIds
+        : [diff.chip.id];
+    const targetSet = new Set(targetIds);
+    let mutated = false;
+    const next = cardSelections.map((row) => {
+        if (!targetSet.has(row.id)) {
+            return row;
+        }
+        const desired = diff.chip.isSelected === true;
+        if (row.isChecked === desired) {
+            return row;
+        }
+        mutated = true;
+        return { ...row, isChecked: desired };
+    });
+    return mutated ? next : cardSelections;
+};
+const tryWriteAllowBlock = (field, diff) => {
+    const desired = diff.chip.isSelected === true;
+    const written = tryFlipItemInSide(field.allowItems, diff, desired);
+    if (written != null) {
+        return { ...field, allowItems: written };
+    }
+    const writtenBlock = tryFlipItemInSide(field.blockItems, diff, desired);
+    if (writtenBlock != null) {
+        return { ...field, blockItems: writtenBlock };
+    }
+    return null;
+};
+const tryFlipItemInSide = (items, diff, desired) => {
+    let idx = items.findIndex((item) => item.id === diff.chip.id);
+    if (idx === -1 && diff.chip.optionalCode != null) {
+        // Auto/upload category chips key on raw MCC code; source items key on
+        // `mcc-{name}`. Match by code so the bridge round-trips both shapes.
+        idx = items.findIndex((item) => item.optionalCode === diff.chip.optionalCode ||
+            (item.optionalCodes ?? []).includes(diff.chip.optionalCode ?? ''));
+    }
+    if (idx === -1) {
+        return null;
+    }
+    if (items[idx].isSelected === desired) {
+        return items;
+    }
+    const copy = items.slice();
+    copy[idx] = { ...items[idx], isSelected: desired };
+    return copy;
+};