@justifi/webcomponents 4.7.3 → 4.7.5

package/dist/esm/{Api-c65d3ed8.js → Api-0e88671c.js}

@@ -31,7 +31,7 @@ for (let i = 0; i < 256; ++i) {
 function unsafeStringify(arr, offset = 0) {
   // Note: Be careful editing this code!  It's been tuned for performance
   // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
 }
 
 const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
@@ -64,43 +64,43 @@ function v4(options, buf, offset) {
 }
 
 const Api = (authToken, apiOrigin) => {
-  async function getAuthorizationHeader() {
-    return {
-      'Authorization': `Bearer ${authToken}`,
-      'Idempotency-Key': v4(),
-      'Content-Type': 'application/json',
-    };
-  }
-  async function makeRequest(endpoint, method, params, body, signal) {
-    const url = `${apiOrigin}/v1/${endpoint}`;
-    const requestUrl = params ? `${url}?${new URLSearchParams(params)}` : url;
-    const response = await fetch(requestUrl, {
-      method: method,
-      headers: await getAuthorizationHeader(),
-      body: body,
-      signal: signal,
-    });
-    if (response) {
-      return response.status === 204 ? {} : response.json();
+    async function getAuthorizationHeader() {
+        return {
+            'Authorization': `Bearer ${authToken}`,
+            'Idempotency-Key': v4(),
+            'Content-Type': 'application/json',
+        };
     }
-    handleError(requestUrl);
-  }
-  async function get(endpoint, params, signal) {
-    return makeRequest(endpoint, 'GET', params, null, signal);
-  }
-  async function post(endpoint, body, params, signal) {
-    return makeRequest(endpoint, 'POST', params, body, signal);
-  }
-  async function patch(endpoint, body, params, signal) {
-    return makeRequest(endpoint, 'PATCH', params, body, signal);
-  }
-  async function destroy(endpoint, params, signal) {
-    return makeRequest(endpoint, 'DELETE', params, null, signal);
-  }
-  return { get, post, patch, destroy };
+    async function makeRequest(endpoint, method, params, body, signal) {
+        const url = `${apiOrigin}/v1/${endpoint}`;
+        const requestUrl = params ? `${url}?${new URLSearchParams(params)}` : url;
+        const response = await fetch(requestUrl, {
+            method: method,
+            headers: await getAuthorizationHeader(),
+            body: body,
+            signal: signal,
+        });
+        if (response) {
+            return response.status === 204 ? {} : response.json();
+        }
+        handleError(requestUrl);
+    }
+    async function get(endpoint, params, signal) {
+        return makeRequest(endpoint, 'GET', params, null, signal);
+    }
+    async function post(endpoint, body, params, signal) {
+        return makeRequest(endpoint, 'POST', params, body, signal);
+    }
+    async function patch(endpoint, body, params, signal) {
+        return makeRequest(endpoint, 'PATCH', params, body, signal);
+    }
+    async function destroy(endpoint, params, signal) {
+        return makeRequest(endpoint, 'DELETE', params, null, signal);
+    }
+    return { get, post, patch, destroy };
 };
 function handleError(requestUrl) {
-  console.error(`Error fetching from ${requestUrl}`);
+    console.error(`Error fetching from ${requestUrl}`);
 }
 
 export { Api as A };

package/dist/esm/{Pagination-31f770d6.js → Pagination-afc8f96d.js}

@@ -1,9 +1,9 @@
 const pagingDefaults = {
-  amount: 25,
-  start_cursor: '',
-  end_cursor: '',
-  has_previous: false,
-  has_next: false,
+    amount: 25,
+    start_cursor: '',
+    end_cursor: '',
+    has_previous: false,
+    has_next: false,
 };
 const ExtendedPagingDefaults = Object.assign(Object.assign({}, pagingDefaults), { handleClickNext: () => { }, handleClickPrevious: () => { } });
 

package/dist/esm/Payout-c42e3877.js

@@ -0,0 +1,179 @@
+var CaptureStrategy;
+(function (CaptureStrategy) {
+    CaptureStrategy["automatic"] = "automatic";
+    CaptureStrategy["manual"] = "manual";
+})(CaptureStrategy || (CaptureStrategy = {}));
+var PaymentMethodTypes;
+(function (PaymentMethodTypes) {
+    PaymentMethodTypes["card"] = "card";
+    PaymentMethodTypes["bankAccount"] = "bankAccount";
+})(PaymentMethodTypes || (PaymentMethodTypes = {}));
+var PaymentStatuses;
+(function (PaymentStatuses) {
+    PaymentStatuses["pending"] = "pending";
+    PaymentStatuses["authorized"] = "authorized";
+    PaymentStatuses["succeeded"] = "succeeded";
+    PaymentStatuses["failed"] = "failed";
+    PaymentStatuses["disputed"] = "disputed";
+    PaymentStatuses["fully_refunded"] = "fully_refunded";
+    PaymentStatuses["partially_refunded"] = "partially_refunded";
+})(PaymentStatuses || (PaymentStatuses = {}));
+var PaymentDisputedStatuses;
+(function (PaymentDisputedStatuses) {
+    // if a dispute is 'won', we don't show a dispute status, just general status
+    PaymentDisputedStatuses["lost"] = "lost";
+    PaymentDisputedStatuses["open"] = "open";
+})(PaymentDisputedStatuses || (PaymentDisputedStatuses = {}));
+class PaymentMethod {
+    constructor(paymentMethod) {
+        this.card = paymentMethod.card ? new Card(paymentMethod.card) : undefined;
+        this.bank_account = paymentMethod.bank_account
+            ? new BankAccount(paymentMethod.bank_account)
+            : undefined;
+    }
+    get payersName() {
+        if (this.card) {
+            return this.card.name;
+        }
+        else if (this.bank_account) {
+            return this.bank_account.name;
+        }
+        return null;
+    }
+    get lastFourDigits() {
+        if (this.card) {
+            return `**** ${this.card.acct_last_four}`;
+        }
+        else if (this.bank_account) {
+            return `**** ${this.bank_account.acct_last_four}`;
+        }
+        return null;
+    }
+}
+class BankAccount {
+    constructor(bankAccount) {
+        this.id = bankAccount.id;
+        this.acct_last_four = bankAccount.acct_last_four;
+        this.name = bankAccount.name;
+        this.brand = bankAccount.brand;
+        this.token = bankAccount.token;
+        this.created_at = bankAccount.created_at;
+        this.updated_at = bankAccount.updated_at;
+    }
+}
+class Card {
+    constructor(card) {
+        this.id = card.id || '';
+        this.acct_last_four = card.acct_last_four;
+        this.name = card.name;
+        this.brand = card.brand;
+        this.token = card.token;
+        this.created_at = card.created_at;
+        this.updated_at = card.updated_at;
+    }
+}
+class Payment {
+    constructor(payment) {
+        this.id = payment.id;
+        this.account_id = payment.account_id;
+        this.amount = payment.amount;
+        this.amount_disputed = payment.amount_disputed;
+        this.amount_refundable = payment.amount_refundable;
+        this.amount_refunded = payment.amount_refunded;
+        this.balance = payment.balance;
+        this.captured = payment.captured;
+        this.capture_strategy = payment.capture_strategy;
+        this.currency = payment.currency;
+        this.description = payment.description;
+        this.disputed = payment.disputed;
+        this.disputes = payment.disputes;
+        this.error_code = payment.error_code;
+        this.error_description = payment.error_description;
+        this.fee_amount = payment.fee_amount;
+        this.is_test = payment.is_test;
+        this.metadata = payment.metadata;
+        this.payment_method = new PaymentMethod(payment.payment_method);
+        this.payment_intent_id = payment.payment_intent_id;
+        this.refunded = payment.refunded;
+        this.status = payment.status;
+        this.created_at = payment.created_at;
+        this.updated_at = payment.updated_at;
+    }
+    get disputedStatus() {
+        const lost = this.disputes.some(dispute => dispute.status === PaymentDisputedStatuses.lost);
+        // if a dispute is 'won', we don't show a dispute status, just general status
+        if (!this.disputed) {
+            return null;
+        }
+        else if (lost) {
+            return PaymentDisputedStatuses.lost;
+        }
+        else {
+            return PaymentDisputedStatuses.open;
+        }
+    }
+}
+class PaymentBalanceTransaction {
+    constructor(balanceTransaction) {
+        this.id = balanceTransaction.id;
+        this.amount = balanceTransaction.amount;
+        this.balance = balanceTransaction.balance;
+        this.currency = balanceTransaction.currency;
+        this.financial_transaction_id = balanceTransaction.financial_transaction_id;
+        this.payment_id = balanceTransaction.payment_id;
+        this.payment_balance_txn_type = balanceTransaction.payment_balance_txn_type;
+        this.source_id = balanceTransaction.source_id;
+        this.source_type = balanceTransaction.source_type;
+        this.created_at = balanceTransaction.created_at;
+        this.updated_at = balanceTransaction.updated_at;
+    }
+    get displayTransactionId() {
+        return this.payment_balance_txn_type === 'payment_fee'
+            ? '--'
+            : this.source_id;
+    }
+}
+
+var PayoutStatuses;
+(function (PayoutStatuses) {
+    PayoutStatuses["paid"] = "paid";
+    PayoutStatuses["failed"] = "failed";
+    PayoutStatuses["forwarded"] = "forwarded";
+    PayoutStatuses["scheduled"] = "scheduled";
+    PayoutStatuses["in_transit"] = "in_transit";
+    PayoutStatuses["canceled"] = "canceled";
+})(PayoutStatuses || (PayoutStatuses = {}));
+var PayoutStatusesSafeNames;
+(function (PayoutStatusesSafeNames) {
+    PayoutStatusesSafeNames["paid"] = "Paid";
+    PayoutStatusesSafeNames["failed"] = "Failed";
+    PayoutStatusesSafeNames["forwarded"] = "Forwarded";
+    PayoutStatusesSafeNames["scheduled"] = "Scheduled";
+    PayoutStatusesSafeNames["in_transit"] = "In Transit";
+    PayoutStatusesSafeNames["canceled"] = "Canceled";
+})(PayoutStatusesSafeNames || (PayoutStatusesSafeNames = {}));
+class Payout {
+    constructor(payout) {
+        this.id = payout.id;
+        this.account_id = payout.account_id;
+        this.amount = payout.amount;
+        this.bank_account = payout.bank_account;
+        this.currency = payout.currency;
+        this.delivery_method = payout.delivery_method || 'standard';
+        this.description = payout.description;
+        this.deposits_at = payout.deposits_at;
+        this.fees_total = payout.fees_total;
+        this.refunds_count = payout.refunds_count;
+        this.refunds_total = payout.refunds_total;
+        this.payments_count = payout.payments_count;
+        this.payments_total = payout.payments_total;
+        this.payout_type = payout.payout_type;
+        this.other_total = payout.other_total;
+        this.status = payout.status;
+        this.metadata = payout.metadata;
+        this.created_at = payout.created_at;
+        this.updated_at = payout.updated_at;
+    }
+}
+
+export { PaymentBalanceTransaction as P, Payment as a, PaymentMethodTypes as b, Payout as c, PayoutStatuses as d, PayoutStatusesSafeNames as e };

package/dist/esm/SubAccount-b3ce8720.js

@@ -0,0 +1,105 @@
+import { h as formatPercentage, a as formatCurrency, f as formatDate, c as formatTime } from './utils-26c7dd12.js';
+
+var TagTypes;
+(function (TagTypes) {
+    TagTypes["neutral"] = "neutral";
+    TagTypes["info"] = "info";
+    TagTypes["success"] = "success";
+    TagTypes["warning"] = "warning";
+    TagTypes["error"] = "error";
+})(TagTypes || (TagTypes = {}));
+var SubAccountStatusType;
+(function (SubAccountStatusType) {
+    SubAccountStatusType["created"] = "created";
+    SubAccountStatusType["submitted"] = "submitted";
+    SubAccountStatusType["information_needed"] = "information_needed";
+    SubAccountStatusType["enabled"] = "enabled";
+    SubAccountStatusType["disabled"] = "disabled";
+    SubAccountStatusType["rejected"] = "rejected";
+    SubAccountStatusType["archived"] = "archived";
+})(SubAccountStatusType || (SubAccountStatusType = {}));
+var AccountType;
+(function (AccountType) {
+    AccountType["live"] = "live";
+    AccountType["test"] = "test";
+})(AccountType || (AccountType = {}));
+var BusinessType;
+(function (BusinessType) {
+    BusinessType["forProfit"] = "for_profit";
+    BusinessType["nonProfit"] = "non_profit";
+    BusinessType["government"] = "government_entity";
+    BusinessType["individual"] = "individual";
+})(BusinessType || (BusinessType = {}));
+var ForProfitStructure;
+(function (ForProfitStructure) {
+    ForProfitStructure["none"] = "";
+    ForProfitStructure["soleProprietorship"] = "sole_proprietorship";
+    ForProfitStructure["singleMember"] = "single_llc";
+    ForProfitStructure["multiMember"] = "multi_llc";
+    ForProfitStructure["privatePartnership"] = "private_partnership";
+    ForProfitStructure["privateCorp"] = "private_corporation";
+    ForProfitStructure["unincorporatedAssociation"] = "unincorporated_association";
+    ForProfitStructure["publicPartnership"] = "public_partnership";
+    ForProfitStructure["publicCorp"] = "public_corporation";
+})(ForProfitStructure || (ForProfitStructure = {}));
+var NonProfitStructure;
+(function (NonProfitStructure) {
+    NonProfitStructure["incorporated"] = "incorporated";
+    NonProfitStructure["unincorporated"] = "unincorporated";
+})(NonProfitStructure || (NonProfitStructure = {}));
+var GovernmentEntityStructure;
+(function (GovernmentEntityStructure) {
+    GovernmentEntityStructure["unit"] = "government_unit";
+    GovernmentEntityStructure["instrumentality"] = "government_instrumentality";
+    GovernmentEntityStructure["taxExempt"] = "tax_exempt_government_instrumentality";
+})(GovernmentEntityStructure || (GovernmentEntityStructure = {}));
+class SubAccount {
+    constructor(subAccount) {
+        this.findActiveRate = (subAccount, type) => {
+            return subAccount.application_fee_rates.find(rate => rate.rate_type === type);
+        };
+        this.getBasisPercentage = (rate) => {
+            return formatPercentage(rate === null || rate === void 0 ? void 0 : rate.basis_point_rate);
+        };
+        this.getTransactionFee = (rate) => {
+            return formatCurrency(rate === null || rate === void 0 ? void 0 : rate.transaction_fee);
+        };
+        this.getFormattedRate = (rate) => {
+            return rate ?
+                `${this.getBasisPercentage(rate)} + ${this.getTransactionFee(rate)}`
+                : 'Not set';
+        };
+        this.account_type = subAccount.account_type;
+        this.application_fee_rates = subAccount.application_fee_rates || [];
+        this.created_at = subAccount.created_at;
+        this.dateString = formatDate(subAccount.created_at);
+        this.timeString = formatTime(subAccount.created_at);
+        this.currency = subAccount.currency;
+        this.id = subAccount.id;
+        this.name = subAccount.name;
+        this.payout_ready = subAccount.payout_ready;
+        this.platform_account_id = subAccount.platform_account_id;
+        this.processing_ready = subAccount.processing_ready;
+        this.status = subAccount.status;
+        this.updated_at = subAccount.updated_at;
+        this.related_accounts = subAccount.related_accounts || {};
+        const activeCardRate = this.findActiveRate(subAccount, 'cc');
+        const activeAchRate = this.findActiveRate(subAccount, 'ach');
+        this.cardRate = this.getFormattedRate(activeCardRate);
+        this.achRate = this.getFormattedRate(activeAchRate);
+    }
+    get statusTagType() {
+        const typeMap = {
+            [SubAccountStatusType.enabled]: TagTypes.success,
+            [SubAccountStatusType.disabled]: TagTypes.error,
+            [SubAccountStatusType.rejected]: TagTypes.error,
+            [SubAccountStatusType.information_needed]: TagTypes.warning,
+            [SubAccountStatusType.submitted]: TagTypes.info,
+            [SubAccountStatusType.created]: TagTypes.neutral,
+            [SubAccountStatusType.archived]: TagTypes.neutral,
+        };
+        return typeMap[this.status];
+    }
+}
+
+export { SubAccount as S };