@classytic/revenue 1.1.2 → 1.1.4

package/dist/split.enums-BrjabxIX.mjs

@@ -0,0 +1,86 @@
+//#region src/enums/subscription.enums.ts
+/**
+* Subscription Enums
+* @classytic/revenue
+*
+* All subscription-related enums and constants
+*/
+/**
+* Subscription Status
+*/
+const SUBSCRIPTION_STATUS = {
+	ACTIVE: "active",
+	PAUSED: "paused",
+	CANCELLED: "cancelled",
+	EXPIRED: "expired",
+	PENDING: "pending",
+	PENDING_RENEWAL: "pending_renewal",
+	INACTIVE: "inactive"
+};
+const SUBSCRIPTION_STATUS_VALUES = Object.values(SUBSCRIPTION_STATUS);
+/**
+* Supported plan intervals
+*/
+const PLAN_KEYS = {
+	MONTHLY: "monthly",
+	QUARTERLY: "quarterly",
+	YEARLY: "yearly"
+};
+const PLAN_KEY_VALUES = Object.values(PLAN_KEYS);
+const subscriptionStatusSet = new Set(SUBSCRIPTION_STATUS_VALUES);
+const planKeySet = new Set(PLAN_KEY_VALUES);
+function isSubscriptionStatus(value) {
+	return typeof value === "string" && subscriptionStatusSet.has(value);
+}
+function isPlanKey(value) {
+	return typeof value === "string" && planKeySet.has(value);
+}
+
+//#endregion
+//#region src/enums/split.enums.ts
+/**
+* Split Payment Enums
+* @classytic/revenue
+*
+* Enums for multi-party commission splits
+*/
+const SPLIT_TYPE = {
+	PLATFORM_COMMISSION: "platform_commission",
+	AFFILIATE_COMMISSION: "affiliate_commission",
+	REFERRAL_COMMISSION: "referral_commission",
+	PARTNER_COMMISSION: "partner_commission",
+	CUSTOM: "custom"
+};
+const SPLIT_TYPE_VALUES = Object.values(SPLIT_TYPE);
+const SPLIT_STATUS = {
+	PENDING: "pending",
+	DUE: "due",
+	PAID: "paid",
+	WAIVED: "waived",
+	CANCELLED: "cancelled"
+};
+const SPLIT_STATUS_VALUES = Object.values(SPLIT_STATUS);
+const PAYOUT_METHOD = {
+	BANK_TRANSFER: "bank_transfer",
+	MOBILE_WALLET: "mobile_wallet",
+	PLATFORM_BALANCE: "platform_balance",
+	CRYPTO: "crypto",
+	CHECK: "check",
+	MANUAL: "manual"
+};
+const PAYOUT_METHOD_VALUES = Object.values(PAYOUT_METHOD);
+const splitTypeSet = new Set(SPLIT_TYPE_VALUES);
+const splitStatusSet = new Set(SPLIT_STATUS_VALUES);
+const payoutMethodSet = new Set(PAYOUT_METHOD_VALUES);
+function isSplitType(value) {
+	return typeof value === "string" && splitTypeSet.has(value);
+}
+function isSplitStatus(value) {
+	return typeof value === "string" && splitStatusSet.has(value);
+}
+function isPayoutMethod(value) {
+	return typeof value === "string" && payoutMethodSet.has(value);
+}
+
+//#endregion
+export { SPLIT_TYPE as a, isSplitStatus as c, PLAN_KEY_VALUES as d, SUBSCRIPTION_STATUS as f, isSubscriptionStatus as h, SPLIT_STATUS_VALUES as i, isSplitType as l, isPlanKey as m, PAYOUT_METHOD_VALUES as n, SPLIT_TYPE_VALUES as o, SUBSCRIPTION_STATUS_VALUES as p, SPLIT_STATUS as r, isPayoutMethod as s, PAYOUT_METHOD as t, PLAN_KEYS as u };

package/dist/split.enums-DmskfLOM.d.mts

@@ -0,0 +1,43 @@
+//#region src/enums/split.enums.d.ts
+/**
+ * Split Payment Enums
+ * @classytic/revenue
+ *
+ * Enums for multi-party commission splits
+ */
+declare const SPLIT_TYPE: {
+  readonly PLATFORM_COMMISSION: "platform_commission";
+  readonly AFFILIATE_COMMISSION: "affiliate_commission";
+  readonly REFERRAL_COMMISSION: "referral_commission";
+  readonly PARTNER_COMMISSION: "partner_commission";
+  readonly CUSTOM: "custom";
+};
+type SplitType = typeof SPLIT_TYPE;
+type SplitTypeValue = SplitType[keyof SplitType];
+declare const SPLIT_TYPE_VALUES: SplitTypeValue[];
+declare const SPLIT_STATUS: {
+  readonly PENDING: "pending";
+  readonly DUE: "due";
+  readonly PAID: "paid";
+  readonly WAIVED: "waived";
+  readonly CANCELLED: "cancelled";
+};
+type SplitStatus = typeof SPLIT_STATUS;
+type SplitStatusValue = SplitStatus[keyof SplitStatus];
+declare const SPLIT_STATUS_VALUES: SplitStatusValue[];
+declare const PAYOUT_METHOD: {
+  readonly BANK_TRANSFER: "bank_transfer";
+  readonly MOBILE_WALLET: "mobile_wallet";
+  readonly PLATFORM_BALANCE: "platform_balance";
+  readonly CRYPTO: "crypto";
+  readonly CHECK: "check";
+  readonly MANUAL: "manual";
+};
+type PayoutMethod = typeof PAYOUT_METHOD;
+type PayoutMethodValue = PayoutMethod[keyof PayoutMethod];
+declare const PAYOUT_METHOD_VALUES: PayoutMethodValue[];
+declare function isSplitType(value: unknown): value is SplitTypeValue;
+declare function isSplitStatus(value: unknown): value is SplitStatusValue;
+declare function isPayoutMethod(value: unknown): value is PayoutMethodValue;
+//#endregion
+export { SPLIT_STATUS as a, SPLIT_TYPE_VALUES as c, SplitType as d, SplitTypeValue as f, isSplitType as h, PayoutMethodValue as i, SplitStatus as l, isSplitStatus as m, PAYOUT_METHOD_VALUES as n, SPLIT_STATUS_VALUES as o, isPayoutMethod as p, PayoutMethod as r, SPLIT_TYPE as s, PAYOUT_METHOD as t, SplitStatusValue as u };

package/dist/tax-BoCt5cEd.d.mts

@@ -0,0 +1,61 @@
+//#region src/shared/types/tax.d.ts
+/**
+ * Tax Types
+ * @classytic/revenue
+ *
+ * Type definitions for tax calculation
+ */
+/**
+ * Tax Configuration
+ * Apps provide this configuration based on their jurisdiction
+ *
+ * Philosophy: Apps know their tax rules, library does the math
+ *
+ * @example
+ * ```typescript
+ * // Australia - 10% GST
+ * const taxConfig: TaxConfig = {
+ *   isRegistered: true,
+ *   defaultRate: 0.10,
+ *   pricesIncludeTax: false,
+ *   exemptCategories: ['education', 'medical'],
+ * };
+ * ```
+ */
+interface TaxConfig {
+  /** Is the organization registered for tax collection? */
+  isRegistered: boolean;
+  /** Default tax rate (0-1, e.g., 0.15 = 15%) */
+  defaultRate: number;
+  /** Do displayed prices include tax? */
+  pricesIncludeTax: boolean;
+  /** Categories exempt from tax (e.g., groceries, education) */
+  exemptCategories?: string[];
+}
+/**
+ * Tax Calculation Result
+ * Returned by calculateTax() utility
+ */
+interface TaxCalculation {
+  /** Is tax applicable for this transaction? */
+  isApplicable: boolean;
+  /** Tax rate used (0-1) */
+  rate: number;
+  /** Base amount (before tax) */
+  baseAmount: number;
+  /** Tax amount */
+  taxAmount: number;
+  /** Total amount (base + tax) */
+  totalAmount: number;
+  /** Were prices tax-inclusive? */
+  pricesIncludeTax: boolean;
+  /** Tax type */
+  type?: TaxType;
+}
+/**
+ * Tax Type
+ * Indicates whether tax is collected or paid
+ */
+type TaxType = 'collected' | 'paid' | 'exempt';
+//#endregion
+export { TaxConfig as n, TaxType as r, TaxCalculation as t };

package/dist/tax-EQ15DO81.mjs

@@ -0,0 +1,162 @@
+import { C as ValidationError } from "./category-resolver-DV83N8ok.mjs";
+
+//#region src/shared/utils/calculators/tax.ts
+/**
+* Calculate tax for a transaction
+*
+* Handles both tax-inclusive and tax-exclusive pricing:
+* - Tax-exclusive: Customer pays baseAmount + tax
+* - Tax-inclusive: Customer pays totalAmount (which includes tax)
+*
+* @param amount - Transaction amount (in smallest currency unit, e.g., cents)
+* @param category - Transaction category (for exemption check)
+* @param config - Tax configuration from app
+* @returns Tax calculation result
+*
+* @example
+* ```typescript
+* // Tax-exclusive pricing (customer pays base + tax)
+* const result = calculateTax(10000, 'subscription', {
+*   isRegistered: true,
+*   defaultRate: 0.15,
+*   pricesIncludeTax: false,
+* });
+* // result = {
+* //   isApplicable: true,
+* //   rate: 0.15,
+* //   baseAmount: 10000,
+* //   taxAmount: 1500,
+* //   totalAmount: 11500,
+* //   pricesIncludeTax: false
+* // }
+*
+* // Tax-inclusive pricing (price already includes tax)
+* const result2 = calculateTax(11500, 'subscription', {
+*   isRegistered: true,
+*   defaultRate: 0.15,
+*   pricesIncludeTax: true,
+* });
+* // result2 = {
+* //   isApplicable: true,
+* //   rate: 0.15,
+* //   baseAmount: 10000,
+* //   taxAmount: 1500,
+* //   totalAmount: 11500,
+* //   pricesIncludeTax: true
+* // }
+* ```
+*/
+function calculateTax(amount, category, config) {
+	if (!config?.isRegistered || config.exemptCategories?.includes(category)) return {
+		isApplicable: false,
+		rate: 0,
+		baseAmount: amount,
+		taxAmount: 0,
+		totalAmount: amount,
+		pricesIncludeTax: false
+	};
+	const rate = config.defaultRate;
+	const [baseAmount, taxAmount, totalAmount] = config.pricesIncludeTax ? [
+		Math.round(amount / (1 + rate)),
+		Math.round(amount - amount / (1 + rate)),
+		amount
+	] : [
+		amount,
+		Math.round(amount * rate),
+		Math.round(amount * (1 + rate))
+	];
+	return {
+		isApplicable: true,
+		rate,
+		baseAmount,
+		taxAmount,
+		totalAmount,
+		pricesIncludeTax: config.pricesIncludeTax
+	};
+}
+/**
+* Get tax type based on transaction flow
+*
+* - Inflow transactions → tax is "collected" (you collect from customer)
+* - Outflow transactions → tax is "paid" (you pay to supplier)
+* - Exempt categories → "exempt"
+*
+* @param transactionFlow - 'inflow' or 'outflow'
+* @param category - Transaction category
+* @param exemptCategories - List of exempt categories
+* @returns Tax type
+*
+* @example
+* ```typescript
+* getTaxType('inflow', 'subscription', []) // 'collected'
+* getTaxType('outflow', 'refund', []) // 'paid'
+* getTaxType('inflow', 'education', ['education']) // 'exempt'
+* ```
+*/
+function getTaxType(transactionFlow, category, exemptCategories = []) {
+	if (exemptCategories.includes(category)) return "exempt";
+	return transactionFlow === "inflow" ? "collected" : "paid";
+}
+/**
+* Reverse tax calculation for refunds
+* When refunding a transaction, tax must be reversed proportionally
+*
+* @param originalTax - Tax from original transaction
+* @param originalAmount - Original transaction amount
+* @param refundAmount - Amount being refunded
+* @returns Reversed tax calculation
+*
+* @example
+* ```typescript
+* // Original: $100 + $15 tax = $115
+* const originalTax = {
+*   isApplicable: true,
+*   rate: 0.15,
+*   baseAmount: 10000,
+*   taxAmount: 1500,
+*   totalAmount: 11500,
+*   type: 'collected',
+* };
+*
+* // Refund 50% ($57.50)
+* const refundTax = reverseTax(originalTax, 11500, 5750);
+* // refundTax = {
+* //   isApplicable: true,
+* //   rate: 0.15,
+* //   baseAmount: 5000,
+* //   taxAmount: 750,
+* //   totalAmount: 5750,
+* //   type: 'paid',  // Reversed!
+* // }
+* ```
+*/
+function reverseTax(originalTax, originalAmount, refundAmount) {
+	if (!originalTax.isApplicable) return {
+		isApplicable: false,
+		rate: 0,
+		baseAmount: refundAmount,
+		taxAmount: 0,
+		totalAmount: refundAmount,
+		pricesIncludeTax: false
+	};
+	if (!originalAmount || originalAmount <= 0) throw new ValidationError("Original amount must be greater than 0", { originalAmount });
+	if (refundAmount < 0) throw new ValidationError("Refund amount cannot be negative", { refundAmount });
+	if (refundAmount > originalAmount) throw new ValidationError(`Refund amount (${refundAmount}) exceeds original amount (${originalAmount})`, {
+		refundAmount,
+		originalAmount
+	});
+	const refundRatio = refundAmount / originalAmount;
+	const reversedType = originalTax.type ? originalTax.type === "collected" ? "paid" : originalTax.type === "paid" ? "collected" : "exempt" : void 0;
+	return {
+		isApplicable: true,
+		rate: originalTax.rate,
+		baseAmount: Math.round(originalTax.baseAmount * refundRatio),
+		taxAmount: Math.round(originalTax.taxAmount * refundRatio),
+		totalAmount: Math.round(originalTax.totalAmount * refundRatio),
+		pricesIncludeTax: originalTax.pricesIncludeTax,
+		type: reversedType
+	};
+}
+
+//#endregion
+export { getTaxType as n, reverseTax as r, calculateTax as t };

package/dist/transaction.enums-pCyMFT4Z.mjs

@@ -0,0 +1,96 @@
+//#region src/enums/transaction.enums.ts
+/**
+* Transaction Enums
+* @classytic/revenue
+*
+* Library-managed transaction enums only.
+* Users should define their own categories and merge with these.
+*/
+/**
+* Transaction Flow - Directional money movement
+*
+* INFLOW: Money coming in (payments, subscriptions, purchases, receipts)
+* OUTFLOW: Money going out (refunds, payouts, expenses, disbursements)
+*
+* Industry-standard terminology compatible with QuickBooks, Xero, and other accounting systems.
+* Users can map categories to flow directions via transactionTypeMapping config.
+*
+* @example
+* // Revenue platform
+* { type: 'subscription', flow: 'inflow' }
+*
+* // Payroll platform
+* { type: 'salary', flow: 'outflow' }
+*
+* // Marketplace
+* { type: 'commission', flow: 'outflow' }  // Paying sellers
+* { type: 'platform_fee', flow: 'inflow' } // Platform revenue
+*/
+const TRANSACTION_FLOW = {
+	INFLOW: "inflow",
+	OUTFLOW: "outflow"
+};
+/** @deprecated Use TRANSACTION_FLOW instead */
+const TRANSACTION_TYPE = TRANSACTION_FLOW;
+const TRANSACTION_FLOW_VALUES = Object.values(TRANSACTION_FLOW);
+/** @deprecated Use TRANSACTION_FLOW_VALUES instead */
+const TRANSACTION_TYPE_VALUES = TRANSACTION_FLOW_VALUES;
+/**
+* Transaction Status - Library-managed states
+*/
+const TRANSACTION_STATUS = {
+	PENDING: "pending",
+	PAYMENT_INITIATED: "payment_initiated",
+	PROCESSING: "processing",
+	REQUIRES_ACTION: "requires_action",
+	VERIFIED: "verified",
+	COMPLETED: "completed",
+	FAILED: "failed",
+	CANCELLED: "cancelled",
+	EXPIRED: "expired",
+	REFUNDED: "refunded",
+	PARTIALLY_REFUNDED: "partially_refunded"
+};
+const TRANSACTION_STATUS_VALUES = Object.values(TRANSACTION_STATUS);
+/**
+* Categories managed by this library
+*
+* SUBSCRIPTION: Recurring subscription payments
+* PURCHASE: One-time purchases
+*
+* Users should spread these into their own category enums:
+*
+* @example
+* import { LIBRARY_CATEGORIES } from '@classytic/revenue';
+*
+* export const MY_CATEGORIES = {
+*   ...LIBRARY_CATEGORIES,
+*   SALARY: 'salary',
+*   RENT: 'rent',
+*   EQUIPMENT: 'equipment',
+* } as const;
+*/
+const LIBRARY_CATEGORIES = {
+	SUBSCRIPTION: "subscription",
+	PURCHASE: "purchase"
+};
+const LIBRARY_CATEGORY_VALUES = Object.values(LIBRARY_CATEGORIES);
+const transactionFlowSet = new Set(TRANSACTION_FLOW_VALUES);
+const transactionStatusSet = new Set(TRANSACTION_STATUS_VALUES);
+const libraryCategorySet = new Set(LIBRARY_CATEGORY_VALUES);
+function isLibraryCategory(value) {
+	return typeof value === "string" && libraryCategorySet.has(value);
+}
+function isTransactionFlow(value) {
+	return typeof value === "string" && transactionFlowSet.has(value);
+}
+/** @deprecated Use isTransactionFlow instead */
+function isTransactionType(value) {
+	return isTransactionFlow(value);
+}
+function isTransactionStatus(value) {
+	return typeof value === "string" && transactionStatusSet.has(value);
+}
+
+//#endregion
+export { TRANSACTION_STATUS as a, TRANSACTION_TYPE_VALUES as c, isTransactionStatus as d, isTransactionType as f, TRANSACTION_FLOW_VALUES as i, isLibraryCategory as l, LIBRARY_CATEGORY_VALUES as n, TRANSACTION_STATUS_VALUES as o, TRANSACTION_FLOW as r, TRANSACTION_TYPE as s, LIBRARY_CATEGORIES as t, isTransactionFlow as u };