@zeniai/client-epic-state 5.1.0-betaSS3 → 5.1.0

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/applyExtractedPolicyToManualCardPolicyDraft.d.ts

@@ -0,0 +1,8 @@
+import { CardPolicyChipFieldValue, CardPolicyCreateFormDraft, ExtractedCardPolicyDataView } from './cardPolicyFormDraftTypes';
+export interface ApplyExtractedPolicyToManualCardPolicyDraftArgs {
+    categorySearchOptions: CardPolicyChipFieldValue[];
+    current: CardPolicyCreateFormDraft;
+    extracted: ExtractedCardPolicyDataView;
+    vendorSearchOptions: CardPolicyChipFieldValue[];
+}
+export declare const applyExtractedPolicyToManualCardPolicyDraft: ({ extracted, current, vendorSearchOptions, categorySearchOptions, }: ApplyExtractedPolicyToManualCardPolicyDraftArgs) => CardPolicyCreateFormDraft;

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/applyExtractedPolicyToManualCardPolicyDraft.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyExtractedPolicyToManualCardPolicyDraft = void 0;
+const cardPolicyChipIds_1 = require("./cardPolicyChipIds");
+const cardPolicyFormDraftTypes_1 = require("./cardPolicyFormDraftTypes");
+// Mirrors the AI variant plus name overwrite from `extracted.policyName`;
+// description / mode / cardSelections are preserved (extract API doesn't return them).
+const applyExtractedPolicyToManualCardPolicyDraft = ({ extracted, current, vendorSearchOptions, categorySearchOptions, }) => ({
+    ...current,
+    name: extracted.policyName ?? current.name,
+    description: current.description,
+    vendorPolicy: buildAllowBlockField({
+        allowList: extracted.allowedEntity.merchantNames,
+        blockList: extracted.blockedEntity.merchantNames,
+        currentAllowItems: current.vendorPolicy.allowItems,
+        currentBlockItems: current.vendorPolicy.blockItems,
+        universe: vendorSearchOptions,
+        matchOnCode: false,
+    }),
+    categoryPolicy: buildAllowBlockField({
+        allowList: extracted.allowedEntity.categoryCodes,
+        blockList: extracted.blockedEntity.categoryCodes,
+        currentAllowItems: current.categoryPolicy.allowItems,
+        currentBlockItems: current.categoryPolicy.blockItems,
+        universe: categorySearchOptions,
+        matchOnCode: true,
+    }),
+    limits: buildLimitRows({
+        current: current.limits,
+        transactionLimit: extracted.transactionLimit,
+        requiredReceiptThreshold: extracted.requiredReceiptThreshold,
+    }),
+});
+exports.applyExtractedPolicyToManualCardPolicyDraft = applyExtractedPolicyToManualCardPolicyDraft;
+const buildAllowBlockField = ({ allowList, blockList, currentAllowItems, currentBlockItems, universe, matchOnCode, }) => {
+    const allowItems = buildSideItems({
+        selectedValues: allowList,
+        currentItems: currentAllowItems,
+        universe,
+        matchOnCode,
+    });
+    const blockItems = buildSideItems({
+        selectedValues: blockList,
+        currentItems: currentBlockItems,
+        universe,
+        matchOnCode,
+    });
+    const mode = allowList.length === 0 && blockList.length > 0 ? 'block' : 'allow';
+    return { mode, allowItems, blockItems };
+};
+const buildSideItems = ({ selectedValues, currentItems, universe, matchOnCode, }) => {
+    const selectedKeys = new Set(selectedValues
+        .map((value) => normalizeKey(value))
+        .filter((key) => key != null));
+    const items = [];
+    const seenIds = new Set();
+    for (const item of currentItems) {
+        const key = normalizeKey(matchOnCode ? item.optionalCode : item.label);
+        const isSelected = key != null && selectedKeys.has(key);
+        items.push({ ...item, isSelected });
+        seenIds.add(item.id);
+        if (isSelected && key != null) {
+            selectedKeys.delete(key);
+        }
+    }
+    for (const option of universe) {
+        if (selectedKeys.size === 0) {
+            break;
+        }
+        const key = normalizeKey(matchOnCode ? option.optionalCode : option.label);
+        if (key == null || !selectedKeys.has(key) || seenIds.has(option.id)) {
+            continue;
+        }
+        items.push({ ...option, isSelected: true });
+        seenIds.add(option.id);
+        selectedKeys.delete(key);
+    }
+    for (const value of selectedValues) {
+        const key = normalizeKey(value);
+        if (key == null || !selectedKeys.has(key)) {
+            continue;
+        }
+        const id = matchOnCode
+            ? (0, cardPolicyChipIds_1.buildMccCategoryChipId)(value)
+            : (0, cardPolicyChipIds_1.buildVendorChipId)(value);
+        if (seenIds.has(id)) {
+            continue;
+        }
+        items.push({
+            id,
+            label: value,
+            isSelected: true,
+            ...(matchOnCode ? { optionalCode: value } : {}),
+        });
+        seenIds.add(id);
+        selectedKeys.delete(key);
+    }
+    return items;
+};
+const buildLimitRows = ({ current, transactionLimit, requiredReceiptThreshold, }) => current.map((row) => {
+    if (row.id === cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_TRANSACTION) {
+        return amountToLimitRow(row, transactionLimit);
+    }
+    if (row.id === cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT) {
+        return amountToLimitRow(row, requiredReceiptThreshold);
+    }
+    return row;
+});
+const amountToLimitRow = (row, amount) => {
+    if (amount > 0) {
+        return { ...row, isEnabled: true, amount };
+    }
+    return { ...row, isEnabled: false, amount: row.amount };
+};
+const normalizeKey = (value) => value == null || value.length === 0 ? undefined : value.toLowerCase().trim();

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/applyUploadPlanToAiCardPolicyDraft.d.ts

@@ -0,0 +1,13 @@
+import { CardPolicyUploadSource, CardPolicyWizardPlan } from '../../../../../entity/aiCfo/aiCfoState';
+import { AiCardPolicyFormDraftSeedContext, CardPolicyFormDraft } from './cardPolicyFormDraftTypes';
+export interface ApplyUploadPlanToAiCardPolicyDraftArgs {
+    context: AiCardPolicyFormDraftSeedContext;
+    current: CardPolicyFormDraft;
+    wizardPlan: CardPolicyWizardPlan;
+    source?: CardPolicyUploadSource;
+}
+export interface ApplyUploadPlanToAiCardPolicyDraftResult {
+    context: AiCardPolicyFormDraftSeedContext;
+    draft: CardPolicyFormDraft;
+}
+export declare const applyUploadPlanToAiCardPolicyDraft: ({ current, context, wizardPlan, source, }: ApplyUploadPlanToAiCardPolicyDraftArgs) => ApplyUploadPlanToAiCardPolicyDraftResult;

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/applyUploadPlanToAiCardPolicyDraft.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyUploadPlanToAiCardPolicyDraft = void 0;
+const buildAiCardPolicyFormDraftSeed_1 = require("./buildAiCardPolicyFormDraftSeed");
+// Re-derives Step 5 review from a fresh `wizardPlan` while preserving the
+// user's Step 2 `cardSelections` and Step 1 `limits`. No-op outside upload mode.
+const applyUploadPlanToAiCardPolicyDraft = ({ current, context, wizardPlan, source, }) => {
+    if (current.policyKind !== 'upload') {
+        return { draft: current, context };
+    }
+    const policiesReview = (0, buildAiCardPolicyFormDraftSeed_1.buildUploadReviewRows)(wizardPlan.step5Review.draftPolicies, context.cardsMasterList, context.categorySearchOptions);
+    return {
+        draft: {
+            ...current,
+            policiesReview,
+        },
+        context: {
+            ...context,
+            wizardPlan,
+            source: source ?? context.source,
+            suggestedPoliciesSeed: wizardPlan.step5Review.draftPolicies.map((draft) => ({
+                id: draft.id,
+                name: draft.name,
+                isChecked: true,
+            })),
+        },
+    };
+};
+exports.applyUploadPlanToAiCardPolicyDraft = applyUploadPlanToAiCardPolicyDraft;

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/buildAiCardPolicyFormDraftSeed.d.ts

@@ -0,0 +1,14 @@
+import { CardPolicyDraftPolicy, CardPolicyInitialData } from '../../../../../entity/aiCfo/aiCfoState';
+import { AiCardPolicyFormDraftSeedContext, CardPolicyCardSelectionRow, CardPolicyDefaultSeedSuggestions, CardPolicyFormDraft, CardPolicyLimitFieldValue, CardPolicyReviewRow, MccCategoryLike } from './cardPolicyFormDraftTypes';
+export interface BuildAiCardPolicyFormDraftSeedArgs extends CardPolicyDefaultSeedSuggestions {
+    initialData: CardPolicyInitialData;
+    cardsMasterList?: CardPolicyCardSelectionRow[];
+    categorySearchOptions?: MccCategoryLike[];
+}
+export interface BuildAiCardPolicyFormDraftSeedResult {
+    context: AiCardPolicyFormDraftSeedContext;
+    draft: CardPolicyFormDraft;
+}
+export declare const buildEmptyLimitRows: () => CardPolicyLimitFieldValue[];
+export declare const buildAiCardPolicyFormDraftSeed: ({ initialData, cardsMasterList, categorySearchOptions, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }: BuildAiCardPolicyFormDraftSeedArgs) => BuildAiCardPolicyFormDraftSeedResult;
+export declare const buildUploadReviewRows: (draftPolicies: CardPolicyDraftPolicy[], cardsMasterList: CardPolicyCardSelectionRow[], categorySearchOptions: MccCategoryLike[] | undefined) => CardPolicyReviewRow[];

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/buildAiCardPolicyFormDraftSeed.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUploadReviewRows = exports.buildAiCardPolicyFormDraftSeed = exports.buildEmptyLimitRows = void 0;
+const cardPolicyChipIds_1 = require("./cardPolicyChipIds");
+const cardPolicyFormDraftTypes_1 = require("./cardPolicyFormDraftTypes");
+const EMPTY_ALLOW_BLOCK = {
+    mode: 'allow',
+    allowItems: [],
+    blockItems: [],
+};
+const EMPTY_FORM_VALUES = {
+    vendorPolicy: EMPTY_ALLOW_BLOCK,
+    categoryPolicy: EMPTY_ALLOW_BLOCK,
+    cardSelections: [],
+    limits: [],
+    policiesReview: [],
+};
+const buildEmptyLimitRows = () => [
+    { id: cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_TRANSACTION, isEnabled: false },
+    { id: cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT, isEnabled: false },
+];
+exports.buildEmptyLimitRows = buildEmptyLimitRows;
+// Build the initial draft + seed context per `policyKind`:
+//  - auto: 1-step review with chip groups built eagerly from `draftPolicies`.
+//  - guided: 5-step wizard; Steps 1–4 from `draftPolicies[0]`, review re-derived.
+//  - upload: empty scaffold pre-recommendation; post-recommendation seeds review.
+const buildAiCardPolicyFormDraftSeed = ({ initialData, cardsMasterList = [], categorySearchOptions, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }) => {
+    const suggestedPoliciesSeed = buildSuggestedPoliciesSeed(initialData);
+    const wizardPlan = 'wizardPlan' in initialData ? initialData.wizardPlan : undefined;
+    const source = initialData.policyKind === 'upload' ? initialData.source : undefined;
+    const context = {
+        policyKind: initialData.policyKind,
+        cardsMasterList,
+        categorySearchOptions: categorySearchOptions ?? [],
+        suggestedAllowMerchants,
+        suggestedBlockMerchants,
+        suggestedAllowCategories,
+        suggestedBlockCategories,
+        suggestedPoliciesSeed,
+        wizardPlan,
+        source,
+    };
+    const draft = buildDraftFromInitialData({
+        initialData,
+        cardsMasterList,
+        categorySearchOptions,
+        suggestedAllowMerchants,
+        suggestedBlockMerchants,
+        suggestedAllowCategories,
+        suggestedBlockCategories,
+    });
+    return { draft, context };
+};
+exports.buildAiCardPolicyFormDraftSeed = buildAiCardPolicyFormDraftSeed;
+const buildDraftFromInitialData = ({ initialData, cardsMasterList, categorySearchOptions, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }) => {
+    const vendorAllowSeed = merchantsToChips(suggestedAllowMerchants);
+    const vendorBlockSeed = merchantsToChips(suggestedBlockMerchants);
+    const categoryAllowSeed = categoriesToChips(suggestedAllowCategories);
+    const categoryBlockSeed = categoriesToChips(suggestedBlockCategories);
+    if (initialData.policyKind === 'auto') {
+        const autoDraftPolicies = initialData.wizardPlan?.step5Review?.draftPolicies ?? [];
+        return {
+            ...EMPTY_FORM_VALUES,
+            policyKind: 'auto',
+            policiesReview: buildAutoReviewRows(autoDraftPolicies, cardsMasterList, categorySearchOptions),
+        };
+    }
+    if (initialData.policyKind === 'upload') {
+        const uploadDraftPolicies = initialData.wizardPlan?.step5Review?.draftPolicies;
+        if (uploadDraftPolicies == null) {
+            return {
+                ...EMPTY_FORM_VALUES,
+                policyKind: 'upload',
+                cardSelections: cardsMasterList.map((row) => ({
+                    ...row,
+                    isChecked: false,
+                })),
+                limits: (0, exports.buildEmptyLimitRows)(),
+            };
+        }
+        return {
+            ...EMPTY_FORM_VALUES,
+            policyKind: 'upload',
+            cardSelections: cardsMasterList.map((row) => ({
+                ...row,
+                isChecked: false,
+            })),
+            limits: (0, exports.buildEmptyLimitRows)(),
+            policiesReview: (0, exports.buildUploadReviewRows)(uploadDraftPolicies, cardsMasterList, categorySearchOptions),
+        };
+    }
+    // Guided
+    const draftPolicies = initialData.wizardPlan?.step5Review?.draftPolicies ?? [];
+    const primary = draftPolicies[0];
+    if (primary == null) {
+        return {
+            policyKind: 'guided',
+            vendorPolicy: buildAllowBlockFromSeeds(vendorAllowSeed, vendorBlockSeed),
+            categoryPolicy: buildAllowBlockFromSeeds(categoryAllowSeed, categoryBlockSeed),
+            cardSelections: cardsMasterList.map((row) => ({
+                ...row,
+                isChecked: false,
+            })),
+            limits: (0, exports.buildEmptyLimitRows)(),
+            policiesReview: [],
+        };
+    }
+    const mccCodeToCategory = buildMccCodeToCategoryMap(categorySearchOptions);
+    const vendorMode = inferAllowBlockMode(primary.allowedEntity.merchantNames.length, primary.blockedEntity.merchantNames.length);
+    const aiVendorAllow = draftMerchantsToChips(primary.allowedEntity.merchantNames);
+    const aiVendorBlock = draftMerchantsToChips(primary.blockedEntity.merchantNames);
+    const vendorPolicy = {
+        mode: vendorMode,
+        allowItems: mergeAiAndSeedChips(aiVendorAllow, vendorAllowSeed),
+        blockItems: mergeAiAndSeedChips(aiVendorBlock, vendorBlockSeed),
+    };
+    const categoryMode = inferAllowBlockMode(primary.allowedEntity.categoryCodes.length, primary.blockedEntity.categoryCodes.length);
+    const aiCategoryAllow = draftCategoryCodesToChips(primary.allowedEntity.categoryCodes, mccCodeToCategory);
+    const aiCategoryBlock = draftCategoryCodesToChips(primary.blockedEntity.categoryCodes, mccCodeToCategory);
+    const categoryPolicy = {
+        mode: categoryMode,
+        allowItems: mergeAiAndSeedChips(aiCategoryAllow, categoryAllowSeed),
+        blockItems: mergeAiAndSeedChips(aiCategoryBlock, categoryBlockSeed),
+    };
+    const cardSelections = cardsMasterList.map((row) => ({
+        ...row,
+        isChecked: primary.applyToCards.includes(row.id),
+    }));
+    const limits = [
+        {
+            id: cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_TRANSACTION,
+            isEnabled: primary.spendLimits.transaction > 0,
+            amount: primary.spendLimits.transaction > 0
+                ? primary.spendLimits.transaction
+                : undefined,
+        },
+        {
+            id: cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT,
+            isEnabled: primary.requiredReceiptThreshold > 0,
+            amount: primary.requiredReceiptThreshold > 0
+                ? primary.requiredReceiptThreshold
+                : undefined,
+        },
+    ];
+    return {
+        policyKind: 'guided',
+        vendorPolicy,
+        categoryPolicy,
+        cardSelections,
+        limits,
+        policiesReview: draftPolicies.map((p) => ({
+            id: p.id,
+            isChecked: true,
+            name: p.name,
+            chipGroups: [],
+        })),
+    };
+};
+const buildSuggestedPoliciesSeed = (initialData) => (initialData.wizardPlan?.step5Review?.draftPolicies ?? []).map((draft) => ({
+    id: draft.id,
+    name: draft.name,
+    isChecked: true,
+}));
+const merchantsToChips = (names) => (names ?? []).map((name) => (0, cardPolicyChipIds_1.toVendorChipFieldValue)(name, false));
+const categoriesToChips = (categories) => (categories ?? []).map((category) => (0, cardPolicyChipIds_1.toMccCategoryChipFieldValue)(category, false));
+const buildAllowBlockFromSeeds = (allowItems, blockItems) => {
+    if (allowItems.length === 0 && blockItems.length === 0) {
+        return EMPTY_ALLOW_BLOCK;
+    }
+    return { mode: 'allow', allowItems, blockItems };
+};
+const buildMccCodeToCategoryMap = (categories) => {
+    const map = new Map();
+    for (const category of categories ?? []) {
+        for (const code of category.mccCodes) {
+            if (!map.has(code)) {
+                map.set(code, category);
+            }
+        }
+    }
+    return map;
+};
+const buildOwnerSummaries = (cardIds, cardsMasterList) => {
+    const cardsById = new Map(cardsMasterList.map((card) => [card.id, card]));
+    const summaries = new Map();
+    for (const cardId of cardIds) {
+        const card = cardsById.get(cardId);
+        if (card == null) {
+            continue;
+        }
+        const existing = summaries.get(card.owner.userId);
+        if (existing != null) {
+            existing.cardIds.push(cardId);
+            continue;
+        }
+        summaries.set(card.owner.userId, {
+            userId: card.owner.userId,
+            displayName: card.owner.displayName,
+            cardIds: [cardId],
+        });
+    }
+    return Array.from(summaries.values());
+};
+const buildAutoReviewChipGroupsForDraft = (draft, cardsMasterList, mccCodeToCategory) => {
+    const groups = [];
+    if (draft.allowedEntity.merchantNames.length > 0) {
+        groups.push({
+            id: 'allowed-vendors',
+            label: 'Allowed Vendors',
+            chips: draft.allowedEntity.merchantNames.map((name) => ({
+                id: (0, cardPolicyChipIds_1.buildVendorChipId)(name),
+                label: name,
+                chipKind: 'positive',
+                isSelected: true,
+            })),
+        });
+    }
+    if (draft.blockedEntity.merchantNames.length > 0) {
+        groups.push({
+            id: 'blocked-vendors',
+            label: 'Blocked Vendors',
+            chips: draft.blockedEntity.merchantNames.map((name) => ({
+                id: (0, cardPolicyChipIds_1.buildVendorChipId)(name),
+                label: name,
+                chipKind: 'negative',
+                isSelected: true,
+            })),
+        });
+    }
+    if (draft.allowedEntity.categoryCodes.length > 0) {
+        groups.push({
+            id: 'allowed-categories',
+            label: 'Allowed Categories',
+            chips: draft.allowedEntity.categoryCodes.map((code) => {
+                const category = mccCodeToCategory.get(code);
+                const label = category != null ? `${category.name} (${code})` : code;
+                return {
+                    id: code,
+                    label,
+                    chipKind: 'positive',
+                    isSelected: true,
+                    optionalCode: code,
+                };
+            }),
+        });
+    }
+    if (draft.blockedEntity.categoryCodes.length > 0) {
+        groups.push({
+            id: 'restricted-categories',
+            label: 'Restricted Categories',
+            chips: draft.blockedEntity.categoryCodes.map((code) => {
+                const category = mccCodeToCategory.get(code);
+                const label = category != null ? `${category.name} (${code})` : code;
+                return {
+                    id: code,
+                    label,
+                    chipKind: 'negative',
+                    isSelected: true,
+                    optionalCode: code,
+                };
+            }),
+        });
+    }
+    if (draft.applyToCards.length > 0) {
+        const owners = buildOwnerSummaries(draft.applyToCards, cardsMasterList);
+        if (owners.length > 0) {
+            groups.push({
+                id: 'applied-to-cards',
+                label: 'Applied to Cards',
+                chips: owners.map((owner) => ({
+                    id: owner.userId,
+                    label: owner.displayName,
+                    chipKind: 'avatar',
+                    cardIds: owner.cardIds,
+                    isSelected: true,
+                })),
+            });
+        }
+    }
+    return groups;
+};
+const buildAutoReviewRows = (draftPolicies, cardsMasterList, categorySearchOptions) => {
+    const mccCodeToCategory = buildMccCodeToCategoryMap(categorySearchOptions);
+    return draftPolicies.map((draft) => ({
+        id: draft.id,
+        isChecked: true,
+        name: draft.name,
+        chipGroups: buildAutoReviewChipGroupsForDraft(draft, cardsMasterList, mccCodeToCategory),
+    }));
+};
+// Numeric value stashed on `optionalCode` so the bulk-submit builder can
+// recover it without re-parsing the label.
+const buildUploadLimitsChipGroup = (draft) => {
+    const transactionEnabled = draft.spendLimits.transaction > 0;
+    const receiptEnabled = draft.requiredReceiptThreshold > 0;
+    return {
+        id: 'limits',
+        label: 'Limits',
+        kind: 'limits',
+        chips: [
+            {
+                id: 'limit-transaction',
+                label: 'Transaction Limit',
+                helperText: 'Maximum amount per single transaction',
+                placeholder: '$0',
+                chipKind: 'positive',
+                isSelected: transactionEnabled,
+                optionalCode: transactionEnabled
+                    ? String(draft.spendLimits.transaction)
+                    : undefined,
+            },
+            {
+                id: 'limit-receipt',
+                label: 'Require Receipt',
+                helperText: 'Require a receipt above this amount',
+                placeholder: '$0',
+                chipKind: 'positive',
+                isSelected: receiptEnabled,
+                optionalCode: receiptEnabled
+                    ? String(draft.requiredReceiptThreshold)
+                    : undefined,
+            },
+        ],
+    };
+};
+const buildUploadReviewRows = (draftPolicies, cardsMasterList, categorySearchOptions) => {
+    const mccCodeToCategory = buildMccCodeToCategoryMap(categorySearchOptions);
+    return draftPolicies.map((draft) => {
+        const chipGroups = buildAutoReviewChipGroupsForDraft(draft, cardsMasterList, mccCodeToCategory);
+        chipGroups.push(buildUploadLimitsChipGroup(draft));
+        return {
+            id: draft.id,
+            isChecked: true,
+            name: draft.name,
+            chipGroups,
+        };
+    });
+};
+exports.buildUploadReviewRows = buildUploadReviewRows;
+// BE doesn't pre-select the radio: allow-wins when either side is populated,
+// otherwise default to allow. Matches `applyExtractedPolicyTo*FormValues`.
+const inferAllowBlockMode = (allowCount, blockCount) => {
+    if (allowCount > 0) {
+        return 'allow';
+    }
+    if (blockCount > 0) {
+        return 'block';
+    }
+    return 'allow';
+};
+const draftMerchantsToChips = (names) => names.map((name) => (0, cardPolicyChipIds_1.toVendorChipFieldValue)(name, true));
+const draftCategoryCodesToChips = (codes, mccCodeToCategory) => codes.map((code) => {
+    const category = mccCodeToCategory.get(code);
+    if (category != null) {
+        return (0, cardPolicyChipIds_1.toMccCategoryChipFieldValue)(category, true);
+    }
+    return {
+        id: code,
+        label: code,
+        isSelected: true,
+        optionalCode: code,
+        optionalCodes: [code],
+    };
+});
+const mergeAiAndSeedChips = (aiChips, seedChips) => {
+    const seenIds = new Set(aiChips.map((chip) => chip.id));
+    const extraSeeds = seedChips.filter((chip) => !seenIds.has(chip.id));
+    return [...aiChips, ...extraSeeds];
+};

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/buildManualCardPolicyFormDraftSeed.d.ts

@@ -0,0 +1,6 @@
+import { CardPolicyCardSelectionRow, CardPolicyCreateFormDraft, CardPolicyDefaultSeedSuggestions } from './cardPolicyFormDraftTypes';
+export interface BuildManualCardPolicyFormDraftSeedArgs extends CardPolicyDefaultSeedSuggestions {
+    cardsMasterList?: CardPolicyCardSelectionRow[];
+    defaultRequireReceiptAmount?: number;
+}
+export declare const buildManualCardPolicyFormDraftSeed: ({ cardsMasterList, defaultRequireReceiptAmount, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }: BuildManualCardPolicyFormDraftSeedArgs) => CardPolicyCreateFormDraft;

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/buildManualCardPolicyFormDraftSeed.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildManualCardPolicyFormDraftSeed = void 0;
+const buildAiCardPolicyFormDraftSeed_1 = require("./buildAiCardPolicyFormDraftSeed");
+const cardPolicyChipIds_1 = require("./cardPolicyChipIds");
+const cardPolicyFormDraftTypes_1 = require("./cardPolicyFormDraftTypes");
+const EMPTY_ALLOW_BLOCK = {
+    mode: 'allow',
+    allowItems: [],
+    blockItems: [],
+};
+// Mirrors the AI guided seed minus the wizard plan: BE suggestions land
+// `isSelected: false` so the user opts in explicitly.
+const buildManualCardPolicyFormDraftSeed = ({ cardsMasterList = [], defaultRequireReceiptAmount, suggestedAllowMerchants, suggestedBlockMerchants, suggestedAllowCategories, suggestedBlockCategories, }) => {
+    const vendorAllow = (suggestedAllowMerchants ?? []).map((name) => (0, cardPolicyChipIds_1.toVendorChipFieldValue)(name, false));
+    const vendorBlock = (suggestedBlockMerchants ?? []).map((name) => (0, cardPolicyChipIds_1.toVendorChipFieldValue)(name, false));
+    const categoryAllow = (suggestedAllowCategories ?? []).map((category) => (0, cardPolicyChipIds_1.toMccCategoryChipFieldValue)(category, false));
+    const categoryBlock = (suggestedBlockCategories ?? []).map((category) => (0, cardPolicyChipIds_1.toMccCategoryChipFieldValue)(category, false));
+    const vendorPolicy = vendorAllow.length === 0 && vendorBlock.length === 0
+        ? EMPTY_ALLOW_BLOCK
+        : { mode: 'allow', allowItems: vendorAllow, blockItems: vendorBlock };
+    const categoryPolicy = categoryAllow.length === 0 && categoryBlock.length === 0
+        ? EMPTY_ALLOW_BLOCK
+        : { mode: 'allow', allowItems: categoryAllow, blockItems: categoryBlock };
+    const limits = (0, buildAiCardPolicyFormDraftSeed_1.buildEmptyLimitRows)().map((row) => row.id === cardPolicyFormDraftTypes_1.CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT &&
+        defaultRequireReceiptAmount != null &&
+        defaultRequireReceiptAmount > 0
+        ? { ...row, amount: defaultRequireReceiptAmount }
+        : row);
+    return {
+        name: '',
+        description: '',
+        mode: 'strict',
+        vendorPolicy,
+        categoryPolicy,
+        cardSelections: cardsMasterList.map((row) => ({ ...row, isChecked: false })),
+        limits,
+    };
+};
+exports.buildManualCardPolicyFormDraftSeed = buildManualCardPolicyFormDraftSeed;

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyChipIds.d.ts

@@ -0,0 +1,7 @@
+import type { CardPolicyChipFieldValue, MccCategoryLike } from './cardPolicyFormDraftTypes';
+export declare const VENDOR_CHIP_ID_PREFIX = "vendor-";
+export declare const MCC_CHIP_ID_PREFIX = "mcc-";
+export declare const buildVendorChipId: (name: string) => string;
+export declare const buildMccCategoryChipId: (name: string) => string;
+export declare const toVendorChipFieldValue: (name: string, isSelected: boolean) => CardPolicyChipFieldValue;
+export declare const toMccCategoryChipFieldValue: (category: MccCategoryLike, isSelected: boolean) => CardPolicyChipFieldValue;

package/lib/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyChipIds.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMccCategoryChipFieldValue = exports.toVendorChipFieldValue = exports.buildMccCategoryChipId = exports.buildVendorChipId = exports.MCC_CHIP_ID_PREFIX = exports.VENDOR_CHIP_ID_PREFIX = void 0;
+// All chip-id producers MUST funnel through here — the picker's dedupe is content-blind
+// (`existing.id === option.id`), so vendors collapse on display name and MCC ids must
+// match the legacy convention saved templates use.
+exports.VENDOR_CHIP_ID_PREFIX = 'vendor-';
+exports.MCC_CHIP_ID_PREFIX = 'mcc-';
+const buildVendorChipId = (name) => `${exports.VENDOR_CHIP_ID_PREFIX}${name.trim().toLowerCase()}`;
+exports.buildVendorChipId = buildVendorChipId;
+const buildMccCategoryChipId = (name) => `${exports.MCC_CHIP_ID_PREFIX}${name}`;
+exports.buildMccCategoryChipId = buildMccCategoryChipId;
+const toVendorChipFieldValue = (name, isSelected) => ({
+    id: (0, exports.buildVendorChipId)(name),
+    label: name,
+    isSelected,
+});
+exports.toVendorChipFieldValue = toVendorChipFieldValue;
+const toMccCategoryChipFieldValue = (category, isSelected) => ({
+    id: (0, exports.buildMccCategoryChipId)(category.name),
+    label: category.name,
+    isSelected,
+    optionalCode: category.mccCodes[0],
+    optionalCodes: [...category.mccCodes],
+});
+exports.toMccCategoryChipFieldValue = toMccCategoryChipFieldValue;