@zeniai/client-epic-state 5.2.60 → 5.2.62-beta0KB

package/lib/view/spendManagement/billPay/editBillView/editBillViewSelector.js

@@ -640,7 +640,7 @@ const getDueDate = (billStageCode, dueDate, invoiceDate, bookCloseDate) => {
 };
 exports.getDueDate = getDueDate;
 const getWithdrawFrom = (state, fromAccountId, fromAccountType, companyId, lastSelectedFromAccount) => {
-    const { paymentAccountState, depositAccountState, depositAccountListState, paymentAccountListState, } = state;
+    const { paymentAccountState, depositAccountState, paymentAccountListState } = state;
     if (fromAccountId != null) {
         const withdrawFromAsDepositAcc = (0, depositAccountSelector_1.getDepositAccountByDepositAccountId)(depositAccountState, fromAccountId);
         const withdrawFromAsPaymentAcc = (0, paymentAccountSelector_1.getPaymentAccountByPaymentAccountId)(paymentAccountState, fromAccountId);
@@ -654,42 +654,16 @@ const getWithdrawFrom = (state, fromAccountId, fromAccountType, companyId, lastS
         }
     }
     else {
-        return (0, exports.getDefaultWithdrawFromAccount)(state, depositAccountListState.accountIds, companyId ?? '', lastSelectedFromAccount);
+        return (0, exports.getDefaultWithdrawFromAccount)(state, companyId ?? '', lastSelectedFromAccount);
     }
     return undefined;
 };
 exports.getWithdrawFrom = getWithdrawFrom;
-const getDefaultWithdrawFromAccount = (state, depositAccounts, companyId, lastSelectedFromAccount) => {
+const getDefaultWithdrawFromAccount = (state, companyId, lastSelectedFromAccount) => {
     const { depositAccountState, paymentAccountState, paymentAccountListState } = state;
     const companyView = (0, getCompanyView_1.getCompanyView)(state, companyId, []);
     const primaryAccount = companyView?.company.company.companyBillPayInfo.primaryFundingAccount;
-    let defaultAccount = undefined;
-    // User paying bill for first time or previously paid with external account
-    if (lastSelectedFromAccount == null ||
-        lastSelectedFromAccount?.accountType === 'paymentAccount') {
-        if (depositAccounts.length === 0) {
-            defaultAccount = primaryAccount;
-        }
-        else {
-            if (primaryAccount?.accountType === 'depositAccount') {
-                defaultAccount = primaryAccount;
-            }
-        }
-    }
-    else {
-        // User paid with Zeni account previously
-        if (depositAccounts.length === 1) {
-            defaultAccount = lastSelectedFromAccount;
-        }
-        else {
-            if (primaryAccount?.accountType === 'depositAccount') {
-                defaultAccount = primaryAccount;
-            }
-            else {
-                defaultAccount = lastSelectedFromAccount;
-            }
-        }
-    }
+    const defaultAccount = primaryAccount ?? lastSelectedFromAccount;
     if (defaultAccount != null) {
         const defaultAccAsDepositAcc = (0, depositAccountSelector_1.getDepositAccountByDepositAccountId)(depositAccountState, defaultAccount?.accountId);
         const defaultAccAsPaymentAcc = (0, paymentAccountSelector_1.getPaymentAccountByPaymentAccountId)(paymentAccountState, defaultAccount?.accountId);

package/lib/view/transactionDetail/createTransaction/createTransactionLocalDataHelper.d.ts

@@ -0,0 +1,51 @@
+import { Recommendation, RecommendationWithCOT } from '../../../commonStateTypes/recommendationBase';
+import { TransactionCategory } from '../../../entity/transaction/stateTypes/transactionType';
+import { CreatableTransactionType, CreateTransactionLineLocalData, CreateTransactionLocalData, CreateTransactionLocalDataByType } from './createTransactionState';
+export declare const nextCreateTransactionLineId: () => string;
+/** Test-only: makes line ids predictable from the start of each case. */
+export declare const resetCreateTransactionLineIdCounter: () => void;
+export declare const createEmptyCreateTransactionLine: (postingType?: TransactionCategory) => CreateTransactionLineLocalData;
+/**
+ * The lines a freshly-opened form starts with. A journal entry is invalid with fewer than one
+ * debit and one credit, so it opens with both rather than making the user add the second row.
+ * Transfer has no lines at all.
+ */
+export declare const getDefaultCreateTransactionLines: (transactionType: CreatableTransactionType) => CreateTransactionLineLocalData[];
+/**
+ * A blank working copy for one type. Note this does NOT seed the date -- the reducer's initial
+ * state has to stay a pure constant so `clearAll` restores something stable. The date is seeded
+ * by initializeCreateTransactionLocalDataEpic, which runs when the form opens.
+ */
+export declare const getEmptyCreateTransactionLocalData: (transactionType: CreatableTransactionType) => CreateTransactionLocalData;
+export declare const getInitialCreateTransactionLocalDataByType: () => CreateTransactionLocalDataByType;
+/**
+ * What the form opens with: a blank copy plus today's date, the default line set, and the one
+ * payment_type the backend insists on for a check (qbo_purchase.py raises without it).
+ */
+export declare const getSeededCreateTransactionLocalData: (transactionType: CreatableTransactionType) => CreateTransactionLocalData;
+/**
+ * Merges a partial edit into the working copy. Lines are replaced wholesale when present --
+ * a partial line array would silently truncate the form.
+ */
+export declare const mergeCreateTransactionLocalData: (current: CreateTransactionLocalData, update: Partial<CreateTransactionLocalData>) => CreateTransactionLocalData;
+export declare const updateCreateTransactionLine: (lines: CreateTransactionLineLocalData[], lineId: string, update: Partial<CreateTransactionLineLocalData>) => CreateTransactionLineLocalData[];
+/**
+ * Recommendation -> RecommendationWithCOT. Chain-of-thought and recommendation feedback both
+ * need an existing transaction, so cot/reasoning are empty here by design; the dropdown only
+ * needs the entities to build its "Recommended" group.
+ */
+export declare const toRecommendationsWithCOT: (recommendations: Recommendation[]) => RecommendationWithCOT[];
+/**
+ * Applies a vendor's recommendations to one line: always refreshes the dropdown's "Recommended"
+ * group, but only prefills account/class when the field is still empty. Anything the user
+ * picked wins -- this follows the transaction-categorization helper, which prefills, rather
+ * than the detail-page helper, which only suggests.
+ */
+export declare const applyRecommendationsToCreateTransactionLine: (line: CreateTransactionLineLocalData, recommendations: Recommendation[], isAccountingClassesEnabled: boolean) => CreateTransactionLineLocalData;
+/**
+ * Undoes a prefill when the vendor is cleared. Only the fields the prefill wrote are removed --
+ * the per-field flags are what make the user's own choices distinguishable from ours, which is
+ * why they are not a single line-level boolean: a hand-picked account alongside a prefilled
+ * class is an ordinary state, and clearing must not take the account with it.
+ */
+export declare const clearRecommendationsFromCreateTransactionLine: (line: CreateTransactionLineLocalData) => CreateTransactionLineLocalData;

package/lib/view/transactionDetail/createTransaction/createTransactionLocalDataHelper.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearRecommendationsFromCreateTransactionLine = exports.applyRecommendationsToCreateTransactionLine = exports.toRecommendationsWithCOT = exports.updateCreateTransactionLine = exports.mergeCreateTransactionLocalData = exports.getSeededCreateTransactionLocalData = exports.getInitialCreateTransactionLocalDataByType = exports.getEmptyCreateTransactionLocalData = exports.getDefaultCreateTransactionLines = exports.createEmptyCreateTransactionLine = exports.resetCreateTransactionLineIdCounter = exports.nextCreateTransactionLineId = void 0;
+const zeniDayJS_1 = require("../../../zeniDayJS");
+const createTransactionState_1 = require("./createTransactionState");
+/**
+ * Monotonic counter for line row keys. These never leave the client -- the payload builder
+ * drops them -- so a counter is enough, and it keeps reducer tests deterministic in a way
+ * randomUUID would not.
+ */
+let lineIdCounter = 0;
+const nextCreateTransactionLineId = () => `create-transaction-line-${lineIdCounter++}`;
+exports.nextCreateTransactionLineId = nextCreateTransactionLineId;
+/** Test-only: makes line ids predictable from the start of each case. */
+const resetCreateTransactionLineIdCounter = () => {
+    lineIdCounter = 0;
+};
+exports.resetCreateTransactionLineIdCounter = resetCreateTransactionLineIdCounter;
+const createEmptyCreateTransactionLine = (postingType) => ({
+    id: (0, exports.nextCreateTransactionLineId)(),
+    postingType,
+});
+exports.createEmptyCreateTransactionLine = createEmptyCreateTransactionLine;
+/**
+ * The lines a freshly-opened form starts with. A journal entry is invalid with fewer than one
+ * debit and one credit, so it opens with both rather than making the user add the second row.
+ * Transfer has no lines at all.
+ */
+const getDefaultCreateTransactionLines = (transactionType) => {
+    if (transactionType === 'transfer') {
+        return [];
+    }
+    if (transactionType === 'journal_entry') {
+        return [
+            (0, exports.createEmptyCreateTransactionLine)('debit'),
+            (0, exports.createEmptyCreateTransactionLine)('credit'),
+        ];
+    }
+    return [(0, exports.createEmptyCreateTransactionLine)()];
+};
+exports.getDefaultCreateTransactionLines = getDefaultCreateTransactionLines;
+/**
+ * A blank working copy for one type. Note this does NOT seed the date -- the reducer's initial
+ * state has to stay a pure constant so `clearAll` restores something stable. The date is seeded
+ * by initializeCreateTransactionLocalDataEpic, which runs when the form opens.
+ */
+const getEmptyCreateTransactionLocalData = (transactionType) => ({
+    lines: [],
+    transactionType,
+});
+exports.getEmptyCreateTransactionLocalData = getEmptyCreateTransactionLocalData;
+const getInitialCreateTransactionLocalDataByType = () => createTransactionState_1.ALL_CREATABLE_TRANSACTION_TYPES.reduce((acc, transactionType) => {
+    acc[transactionType] =
+        (0, exports.getEmptyCreateTransactionLocalData)(transactionType);
+    return acc;
+}, {});
+exports.getInitialCreateTransactionLocalDataByType = getInitialCreateTransactionLocalDataByType;
+/**
+ * What the form opens with: a blank copy plus today's date, the default line set, and the one
+ * payment_type the backend insists on for a check (qbo_purchase.py raises without it).
+ */
+const getSeededCreateTransactionLocalData = (transactionType) => ({
+    ...(0, exports.getEmptyCreateTransactionLocalData)(transactionType),
+    lines: (0, exports.getDefaultCreateTransactionLines)(transactionType),
+    paymentType: transactionType === 'check' ? 'check' : undefined,
+    transactionDate: (0, zeniDayJS_1.dateNow)(),
+});
+exports.getSeededCreateTransactionLocalData = getSeededCreateTransactionLocalData;
+/**
+ * Merges a partial edit into the working copy. Lines are replaced wholesale when present --
+ * a partial line array would silently truncate the form.
+ */
+const mergeCreateTransactionLocalData = (current, update) => ({
+    ...current,
+    ...update,
+    lines: update.lines ?? current.lines,
+    // The type is keyed by the slice, never edited through a merge.
+    transactionType: current.transactionType,
+});
+exports.mergeCreateTransactionLocalData = mergeCreateTransactionLocalData;
+const updateCreateTransactionLine = (lines, lineId, update) => lines.map((line) => line.id === lineId ? { ...line, ...update, id: line.id } : line);
+exports.updateCreateTransactionLine = updateCreateTransactionLine;
+/**
+ * Recommendation -> RecommendationWithCOT. Chain-of-thought and recommendation feedback both
+ * need an existing transaction, so cot/reasoning are empty here by design; the dropdown only
+ * needs the entities to build its "Recommended" group.
+ */
+const toRecommendationsWithCOT = (recommendations) => recommendations.map((recommendation) => ({
+    account: recommendation.account != null
+        ? { ...recommendation.account, cot: [], reasoning: '' }
+        : undefined,
+    class: recommendation.class != null
+        ? { ...recommendation.class, cot: [], reasoning: '' }
+        : undefined,
+    vendor: recommendation.vendor != null
+        ? { ...recommendation.vendor, cot: [], reasoning: '' }
+        : undefined,
+}));
+exports.toRecommendationsWithCOT = toRecommendationsWithCOT;
+/**
+ * Applies a vendor's recommendations to one line: always refreshes the dropdown's "Recommended"
+ * group, but only prefills account/class when the field is still empty. Anything the user
+ * picked wins -- this follows the transaction-categorization helper, which prefills, rather
+ * than the detail-page helper, which only suggests.
+ */
+const applyRecommendationsToCreateTransactionLine = (line, recommendations, isAccountingClassesEnabled) => {
+    const top = recommendations[0];
+    const updated = {
+        ...line,
+        recommendationsWithCOT: (0, exports.toRecommendationsWithCOT)(recommendations),
+    };
+    if (line.accountQboId == null && top?.account?.qboId != null) {
+        updated.accountQboId = top.account.qboId;
+        updated.accountName = top.account.accountName;
+        updated.isAccountPreFilled = true;
+    }
+    if (isAccountingClassesEnabled &&
+        line.classId == null &&
+        top?.class?.classId != null) {
+        updated.classId = top.class.classId;
+        updated.isClassPreFilled = true;
+    }
+    return updated;
+};
+exports.applyRecommendationsToCreateTransactionLine = applyRecommendationsToCreateTransactionLine;
+/**
+ * Undoes a prefill when the vendor is cleared. Only the fields the prefill wrote are removed --
+ * the per-field flags are what make the user's own choices distinguishable from ours, which is
+ * why they are not a single line-level boolean: a hand-picked account alongside a prefilled
+ * class is an ordinary state, and clearing must not take the account with it.
+ */
+const clearRecommendationsFromCreateTransactionLine = (line) => {
+    const cleared = {
+        ...line,
+        recommendationsWithCOT: undefined,
+    };
+    if (line.isAccountPreFilled === true) {
+        cleared.accountQboId = undefined;
+        cleared.accountName = undefined;
+        cleared.isAccountPreFilled = undefined;
+    }
+    if (line.isClassPreFilled === true) {
+        cleared.classId = undefined;
+        cleared.isClassPreFilled = undefined;
+    }
+    return cleared;
+};
+exports.clearRecommendationsFromCreateTransactionLine = clearRecommendationsFromCreateTransactionLine;

package/lib/view/transactionDetail/createTransaction/createTransactionPayload.d.ts

@@ -0,0 +1,82 @@
+import { ID } from '../../../commonStateTypes/common';
+import { TransactionPayload } from '../../../entity/transaction/payloadTypes/transactionPayload';
+import { ZeniAPIResponse } from '../../../responsePayload';
+import { RootState } from '../../../rootStateTypes';
+import { CreateTransactionLocalData } from './createTransactionState';
+/**
+ * Wire types for POST /1.0/transactions/manage.
+ *
+ * Two things here are easy to get wrong and are deliberately explicit:
+ *
+ * 1. `line_detail_type` is snake_case. The PascalCase strings in the backend are Python
+ *    constant NAMES; ZENI_LINE_DETAIL_TYPE_TO_QBO_LINE_DETAIL_TYPE_MAP converts them for the
+ *    body the backend sends on to QuickBooks, never for ours.
+ * 2. The reference number uses two different keys depending on the QBO entity. check and
+ *    expense are Purchases and take `document_number`; everything else takes `document_id`.
+ */
+export interface CreateTransactionAccountPayload {
+    qbo_id: ID;
+    account_name?: string;
+}
+export interface CreateTransactionLineDetailPayload {
+    account?: CreateTransactionAccountPayload;
+    class?: Record<string, never> | {
+        qbo_id: ID;
+    };
+    /**
+     * journal_entry only, and it MUST sit inside line_detail. The write validator's docstring
+     * warns that a misplaced posting_type is silently dropped and then rejected by QBO.
+     */
+    posting_type?: 'credit' | 'debit';
+    vendor?: {
+        qbo_id: ID;
+    };
+}
+export interface CreateTransactionLinePayload {
+    amount: number;
+    line_detail: CreateTransactionLineDetailPayload;
+    line_detail_type: 'account_based_expense_line_detail' | 'item_based_expense_line_detail' | 'journal_entry_line_detail';
+    line_description?: string;
+}
+export interface CreateTransactionRemitToAddressPayload {
+    city?: string;
+    country?: string;
+    line1?: string;
+    postal_code?: string;
+    state?: string;
+}
+export interface CreateTransactionRequest extends Record<string, unknown> {
+    transaction_date: string;
+    transaction_type: string;
+    /** journal_entry reference number. */
+    document_id?: string;
+    /** check / credit_card_credit reference number (QBO Purchase). */
+    document_number?: string;
+    from_account_id?: ID;
+    /** credit_card_credit is modelled as a Purchase with Credit: true. */
+    is_credit?: boolean;
+    lines?: CreateTransactionLinePayload[];
+    payment_type?: string;
+    print_status?: string;
+    qbo_account_id?: ID;
+    remit_to_address?: CreateTransactionRemitToAddressPayload;
+    to_account_id?: ID;
+    total_amount?: number;
+    transaction_memo?: string;
+    vendor_id?: ID;
+}
+/**
+ * The create endpoint writes to QBO and returns the created entity; Zeni's own mirror is
+ * populated by the delta sync that runs afterwards, so this response is the only view of the
+ * new transaction the client gets immediately.
+ */
+export interface CreateTransactionPayload {
+    transactions: TransactionPayload[];
+}
+export type CreateTransactionResponse = ZeniAPIResponse<CreateTransactionPayload>;
+/**
+ * Builds the request body for one transaction type. One branch per type rather than a shared
+ * body with optional keys, because the types genuinely diverge -- transfer carries no lines at
+ * all, and journal_entry carries no header account.
+ */
+export declare const prepareCreateTransactionPayload: (state: RootState, localData: CreateTransactionLocalData) => CreateTransactionRequest;

package/lib/view/transactionDetail/createTransaction/createTransactionPayload.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareCreateTransactionPayload = void 0;
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const accountSelector_1 = require("../../../entity/account/accountSelector");
+const vendorSelector_1 = require("../../../entity/vendor/vendorSelector");
+const toRemitToAddressPayload = (address) => {
+    if (address == null) {
+        return undefined;
+    }
+    return {
+        line1: address.line1,
+        city: address.city,
+        state: address.state,
+        postal_code: address.postalCode,
+        country: address.country,
+    };
+};
+const toLinePayload = (line, transactionType) => {
+    const lineDetail = {};
+    if (line.accountQboId != null) {
+        lineDetail.account = {
+            qbo_id: line.accountQboId,
+            account_name: line.accountName,
+        };
+    }
+    // An empty object is what the confirmed payloads send when no class is chosen; sending the
+    // key with a qbo_id only once one is picked.
+    lineDetail.class = line.classId != null ? { qbo_id: line.classId } : {};
+    if (transactionType === 'journal_entry') {
+        lineDetail.posting_type = line.postingType;
+        if (line.vendorQboId != null) {
+            lineDetail.vendor = { qbo_id: line.vendorQboId };
+        }
+    }
+    return {
+        // The backend rejects a bool here, so this is always coerced to a number.
+        amount: line.amount?.amount ?? 0,
+        line_description: line.lineDescription,
+        line_detail_type: transactionType === 'journal_entry'
+            ? 'journal_entry_line_detail'
+            : 'account_based_expense_line_detail',
+        line_detail: lineDetail,
+    };
+};
+/** Resolves a Zeni account id to the QBO id the endpoint expects. */
+const toQboAccountId = (state, accountId) => {
+    if (accountId == null) {
+        return undefined;
+    }
+    return ((0, accountSelector_1.getAccountBase)(state.accountState, accountId, 'account_list')?.qboId ??
+        accountId);
+};
+/** Resolves a Zeni vendor id to its QBO id -- `vendor_id` on the wire is a QBO id. */
+const toQboVendorId = (state, vendorId) => {
+    if (vendorId == null) {
+        return undefined;
+    }
+    return (0, vendorSelector_1.getVendorByVendorId)(state.vendorState, vendorId)?.qboId ?? vendorId;
+};
+/**
+ * Builds the request body for one transaction type. One branch per type rather than a shared
+ * body with optional keys, because the types genuinely diverge -- transfer carries no lines at
+ * all, and journal_entry carries no header account.
+ */
+const prepareCreateTransactionPayload = (state, localData) => {
+    const { transactionType } = localData;
+    const base = {
+        transaction_type: transactionType,
+        transaction_date: localData.transactionDate?.format(timePeriod_1.DEFAULT_DATE_FORMAT) ?? '',
+        transaction_memo: localData.transactionMemo,
+    };
+    if (transactionType === 'transfer') {
+        return {
+            ...base,
+            from_account_id: toQboAccountId(state, localData.fromAccountId),
+            to_account_id: toQboAccountId(state, localData.toAccountId),
+            total_amount: localData.totalAmount?.amount ?? 0,
+        };
+    }
+    const lines = localData.lines.map((line) => toLinePayload(line, transactionType));
+    if (transactionType === 'journal_entry') {
+        return {
+            ...base,
+            document_id: localData.documentId,
+            lines,
+        };
+    }
+    const purchaseBase = {
+        ...base,
+        payment_type: localData.paymentType,
+        qbo_account_id: toQboAccountId(state, localData.qboAccountId),
+        vendor_id: toQboVendorId(state, localData.vendorId),
+        lines,
+    };
+    if (transactionType === 'check') {
+        return {
+            ...purchaseBase,
+            document_number: localData.documentNumber,
+            print_status: localData.printStatus,
+            remit_to_address: toRemitToAddressPayload(localData.remitToAddress),
+        };
+    }
+    if (transactionType === 'credit_card_credit') {
+        // credit_card_credit is not in the backend's SUPPORTED_TRANSACTION_WRITE_TYPES. QBO models
+        // it as a Purchase with Credit: true and qbo_purchase.py already honours is_credit for
+        // card payment types, so this sends `expense` + is_credit rather than a type the validator
+        // rejects outright. Confirm with backend before enabling the menu item.
+        return {
+            ...purchaseBase,
+            transaction_type: 'expense',
+            is_credit: true,
+            document_number: localData.documentNumber,
+        };
+    }
+    return purchaseBase;
+};
+exports.prepareCreateTransactionPayload = prepareCreateTransactionPayload;

package/lib/view/transactionDetail/createTransaction/createTransactionSelector.d.ts

@@ -0,0 +1,40 @@
+import { FetchState, FetchStateAndError } from '../../../commonStateTypes/common';
+import { Recommendation } from '../../../commonStateTypes/recommendationBase';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase } from '../../../entity/account/accountState';
+import { TransactionID } from '../../../entity/transaction/stateTypes/transactionID';
+import { Vendor } from '../../../entity/vendor/vendorState';
+import { RootState } from '../../../rootStateTypes';
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+import { CreatableTransactionType, CreateTransactionLocalData } from './createTransactionState';
+export interface CreateTransactionView extends SelectorView {
+    /**
+     * COA and class trees for the header account and the line dropdowns. The hierarchies rather
+     * than flat lists, because the create page builds its grouped "Recommended" / "All" options
+     * with the same helpers the detail page uses.
+     */
+    accountListNestedAccountHierarchy: NestedAccountHierarchyForReport[];
+    classListNestedAccountHierarchy: NestedClassHierarchyForReport[];
+    createStatus: FetchStateAndError;
+    localData: CreateTransactionLocalData;
+    transactionType: CreatableTransactionType;
+    /** Populated for transfer only; the COA would offer ineligible accounts. */
+    transferAccountsList: AccountBase[];
+    vendorList: Vendor[];
+    createdTransactionId?: TransactionID;
+}
+export declare const getCreateTransactionLocalData: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionLocalData;
+export declare const getCreateTransactionStatus: (state: RootState) => FetchStateAndError;
+/**
+ * The vendor recommendations backing the category/class dropdowns on the create page.
+ *
+ * No new state field is needed for this: getRecommendationsForEntity already returns
+ * fetchState alongside recommendations, so composing it here is enough for the page to show a
+ * line skeleton and hold Save while a fetch is in flight.
+ */
+export declare const getCreateTransactionVendorRecommendations: (state: RootState, vendorQboId?: string) => {
+    fetchState: FetchState;
+    recommendations?: Recommendation[];
+};
+export declare const getCreateTransactionView: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionView;

package/lib/view/transactionDetail/createTransaction/createTransactionSelector.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateTransactionView = exports.getCreateTransactionVendorRecommendations = exports.getCreateTransactionStatus = exports.getCreateTransactionLocalData = void 0;
+const accountListSelector_1 = require("../../accountList/accountListSelector");
+const classListSelector_1 = require("../../classList/classListSelector");
+const createTransferEntrySelector_1 = require("../../createTransferEntry/createTransferEntrySelector");
+const recommendationSelector_1 = require("../../recommendation/recommendationSelector");
+const getCreateTransactionLocalData = (state, transactionType) => state.transactionDetailState.createTransactionsState.newTransactionState[transactionType];
+exports.getCreateTransactionLocalData = getCreateTransactionLocalData;
+const getCreateTransactionStatus = (state) => state.transactionDetailState.createTransactionsState.createStatus;
+exports.getCreateTransactionStatus = getCreateTransactionStatus;
+/**
+ * The vendor recommendations backing the category/class dropdowns on the create page.
+ *
+ * No new state field is needed for this: getRecommendationsForEntity already returns
+ * fetchState alongside recommendations, so composing it here is enough for the page to show a
+ * line skeleton and hold Save while a fetch is in flight.
+ */
+const getCreateTransactionVendorRecommendations = (state, vendorQboId) => {
+    if (vendorQboId == null || vendorQboId === '') {
+        return { fetchState: 'Not-Started' };
+    }
+    const view = (0, recommendationSelector_1.getRecommendationsForEntity)(state, vendorQboId, 'vendor');
+    return {
+        fetchState: view.fetchState,
+        recommendations: view.recommendations,
+    };
+};
+exports.getCreateTransactionVendorRecommendations = getCreateTransactionVendorRecommendations;
+const getCreateTransactionView = (state, transactionType) => {
+    const { accountListState, classListState, transactionDetailState, vendorState, } = state;
+    const { createTransactionsState } = transactionDetailState;
+    return {
+        transactionType,
+        localData: createTransactionsState.newTransactionState[transactionType],
+        createStatus: createTransactionsState.createStatus,
+        createdTransactionId: createTransactionsState.createdTransactionId,
+        vendorList: Object.values(vendorState.vendorByID),
+        accountListNestedAccountHierarchy: (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, 'accountList'),
+        classListNestedAccountHierarchy: (0, classListSelector_1.getNestedClassListHierarchy)(classListState),
+        transferAccountsList: transactionType === 'transfer'
+            ? (0, createTransferEntrySelector_1.getResolvedTransferAccounts)(state).transferAccountsList
+            : [],
+        fetchState: createTransactionsState.createStatus.fetchState,
+        error: createTransactionsState.createStatus.error,
+    };
+};
+exports.getCreateTransactionView = getCreateTransactionView;

package/lib/view/transactionDetail/createTransaction/createTransactionState.d.ts

@@ -0,0 +1,81 @@
+import { Amount } from '../../../commonStateTypes/amount';
+import { ID } from '../../../commonStateTypes/common';
+import { RecommendationWithCOT } from '../../../commonStateTypes/recommendationBase';
+import { PaymentType } from '../../../entity/transaction/stateTypes/paymentType';
+import { PrintStatus } from '../../../entity/transaction/stateTypes/printStatus';
+import { TransactionCategory, TransactionType } from '../../../entity/transaction/stateTypes/transactionType';
+import { ZeniDate } from '../../../zeniDayJS';
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+export declare const ALL_CREATABLE_TRANSACTION_TYPES: readonly ["expense", "check", "credit_card_credit", "transfer", "journal_entry"];
+export type CreatableTransactionType = (typeof ALL_CREATABLE_TRANSACTION_TYPES)[number];
+/**
+ * The wire shape the create endpoint expects for a check's remit-to address. Deliberately not
+ * the CES AddressPayload, which carries `street: string[]` plus address_id/create_time/
+ * update_time that the create endpoint does not accept.
+ */
+export interface RemitToAddress {
+    city?: string;
+    country?: string;
+    line1?: string;
+    postalCode?: string;
+    state?: string;
+}
+export interface CreateTransactionLineLocalData {
+    /** Client-side row key only -- never sent. */
+    id: string;
+    accountName?: string;
+    accountQboId?: ID;
+    amount?: Amount;
+    classId?: ID;
+    /**
+     * Tracked per field, not per line. A line can have a hand-picked account and a prefilled
+     * class at the same time, and clearing the vendor must undo only the latter.
+     */
+    isAccountPreFilled?: boolean;
+    isClassPreFilled?: boolean;
+    lineDescription?: string;
+    /** journal_entry only. */
+    postingType?: TransactionCategory;
+    projectId?: ID;
+    /**
+     * Backs the "Recommended" group in the category/class dropdowns. Carries the COT shape the
+     * line-table row already expects, with empty cot/reasoning -- chain-of-thought needs an
+     * existing transaction, which a create does not have.
+     */
+    recommendationsWithCOT?: RecommendationWithCOT[];
+    /** journal_entry only -- the per-line name. */
+    vendorQboId?: ID;
+}
+export interface CreateTransactionLocalData {
+    /** Empty for transfer, which has no lines at all. */
+    lines: CreateTransactionLineLocalData[];
+    transactionType: CreatableTransactionType;
+    /** journal_entry reference number. */
+    documentId?: string;
+    /** check / credit_card_credit reference number. */
+    documentNumber?: string;
+    /** transfer */
+    fromAccountId?: ID;
+    paymentType?: PaymentType;
+    /** check only. */
+    printStatus?: PrintStatus;
+    qboAccountId?: ID;
+    /** check only. */
+    remitToAddress?: RemitToAddress;
+    toAccountId?: ID;
+    /** transfer only -- every other type derives its total from the lines. */
+    totalAmount?: Amount;
+    transactionDate?: ZeniDate;
+    transactionMemo?: string;
+    vendorId?: ID;
+}
+export type CreateTransactionLocalDataByType = Record<CreatableTransactionType, CreateTransactionLocalData>;
+/**
+ * Type-level guarantee that CreatableTransactionType stays a subset of TransactionType. If a
+ * value is ever added here that the entity layer does not know about, this line fails to
+ * compile rather than failing at the payload boundary.
+ */
+export type CreatableTransactionTypeIsTransactionType = CreatableTransactionType extends TransactionType ? true : never;

package/lib/view/transactionDetail/createTransaction/createTransactionState.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_CREATABLE_TRANSACTION_TYPES = void 0;
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+exports.ALL_CREATABLE_TRANSACTION_TYPES = [
+    'expense',
+    'check',
+    'credit_card_credit',
+    'transfer',
+    'journal_entry',
+];

package/lib/view/transactionDetail/createTransaction/epics/createTransactionEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { RootState } from '../../../../rootStateTypes';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { createTransaction, createTransactionSuccessOrFailure, initializeTransactionDetailLocalData, resetCreateTransactionLocalData } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof createTransaction> | ReturnType<typeof createTransactionSuccessOrFailure> | ReturnType<typeof resetCreateTransactionLocalData> | ReturnType<typeof initializeTransactionDetailLocalData> | ReturnType<typeof updateTransaction> | ReturnType<typeof openSnackbar>;
+export declare const createTransactionEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;