@classytic/revenue 1.1.2 → 1.1.4

package/dist/money-CvrDOijQ.mjs

@@ -0,0 +1,271 @@
+//#region src/shared/utils/formatters/money.ts
+/** Supported currencies with their decimal places */
+const CURRENCIES = {
+	USD: {
+		code: "USD",
+		decimals: 2,
+		symbol: "$",
+		name: "US Dollar"
+	},
+	EUR: {
+		code: "EUR",
+		decimals: 2,
+		symbol: "€",
+		name: "Euro"
+	},
+	GBP: {
+		code: "GBP",
+		decimals: 2,
+		symbol: "£",
+		name: "British Pound"
+	},
+	BDT: {
+		code: "BDT",
+		decimals: 2,
+		symbol: "৳",
+		name: "Bangladeshi Taka"
+	},
+	INR: {
+		code: "INR",
+		decimals: 2,
+		symbol: "₹",
+		name: "Indian Rupee"
+	},
+	JPY: {
+		code: "JPY",
+		decimals: 0,
+		symbol: "¥",
+		name: "Japanese Yen"
+	},
+	CNY: {
+		code: "CNY",
+		decimals: 2,
+		symbol: "¥",
+		name: "Chinese Yuan"
+	},
+	AED: {
+		code: "AED",
+		decimals: 2,
+		symbol: "د.إ",
+		name: "UAE Dirham"
+	},
+	SAR: {
+		code: "SAR",
+		decimals: 2,
+		symbol: "﷼",
+		name: "Saudi Riyal"
+	},
+	SGD: {
+		code: "SGD",
+		decimals: 2,
+		symbol: "S$",
+		name: "Singapore Dollar"
+	},
+	AUD: {
+		code: "AUD",
+		decimals: 2,
+		symbol: "A$",
+		name: "Australian Dollar"
+	},
+	CAD: {
+		code: "CAD",
+		decimals: 2,
+		symbol: "C$",
+		name: "Canadian Dollar"
+	}
+};
+/**
+* Money class - immutable money representation
+*/
+var Money = class Money {
+	amount;
+	currency;
+	constructor(amount, currency) {
+		if (!Number.isInteger(amount)) throw new Error(`Money amount must be integer (smallest unit). Got: ${amount}`);
+		this.amount = amount;
+		this.currency = currency.toUpperCase();
+	}
+	/**
+	* Create money from smallest unit (cents, paisa)
+	* @example Money.cents(1999, 'USD') // $19.99
+	*/
+	static cents(amount, currency = "USD") {
+		return new Money(Math.round(amount), currency);
+	}
+	/**
+	* Create money from major unit (dollars, taka)
+	* @example Money.of(19.99, 'USD') // $19.99 (stored as 1999 cents)
+	*/
+	static of(amount, currency = "USD") {
+		const config = CURRENCIES[currency.toUpperCase()] ?? { decimals: 2 };
+		const multiplier = Math.pow(10, config.decimals);
+		return new Money(Math.round(amount * multiplier), currency);
+	}
+	/**
+	* Create zero money
+	*/
+	static zero(currency = "USD") {
+		return new Money(0, currency);
+	}
+	static usd(cents) {
+		return Money.cents(cents, "USD");
+	}
+	static eur(cents) {
+		return Money.cents(cents, "EUR");
+	}
+	static gbp(pence) {
+		return Money.cents(pence, "GBP");
+	}
+	static bdt(paisa) {
+		return Money.cents(paisa, "BDT");
+	}
+	static inr(paisa) {
+		return Money.cents(paisa, "INR");
+	}
+	static jpy(yen) {
+		return Money.cents(yen, "JPY");
+	}
+	/**
+	* Add two money values (must be same currency)
+	*/
+	add(other) {
+		this.assertSameCurrency(other);
+		return new Money(this.amount + other.amount, this.currency);
+	}
+	/**
+	* Subtract money (must be same currency)
+	*/
+	subtract(other) {
+		this.assertSameCurrency(other);
+		return new Money(this.amount - other.amount, this.currency);
+	}
+	/**
+	* Multiply by a factor (rounds to nearest integer)
+	*/
+	multiply(factor) {
+		return new Money(Math.round(this.amount * factor), this.currency);
+	}
+	/**
+	* Divide by a divisor (rounds to nearest integer)
+	*/
+	divide(divisor) {
+		if (divisor === 0) throw new Error("Cannot divide by zero");
+		return new Money(Math.round(this.amount / divisor), this.currency);
+	}
+	/**
+	* Calculate percentage
+	* @example money.percentage(10) // 10% of money
+	*/
+	percentage(percent) {
+		return this.multiply(percent / 100);
+	}
+	/**
+	* Allocate money among recipients (handles rounding)
+	* @example Money.usd(100).allocate([1, 1, 1]) // [34, 33, 33] cents
+	*/
+	allocate(ratios) {
+		const total = ratios.reduce((a, b) => a + b, 0);
+		if (total === 0) throw new Error("Ratios must sum to more than 0");
+		let remainder = this.amount;
+		const results = [];
+		for (let i = 0; i < ratios.length; i++) {
+			const share = Math.floor(this.amount * ratios[i] / total);
+			results.push(new Money(share, this.currency));
+			remainder -= share;
+		}
+		for (let i = 0; i < remainder; i++) results[i] = new Money(results[i].amount + 1, this.currency);
+		return results;
+	}
+	/**
+	* Split equally among n recipients
+	*/
+	split(parts) {
+		return this.allocate(Array(parts).fill(1));
+	}
+	isZero() {
+		return this.amount === 0;
+	}
+	isPositive() {
+		return this.amount > 0;
+	}
+	isNegative() {
+		return this.amount < 0;
+	}
+	equals(other) {
+		return this.amount === other.amount && this.currency === other.currency;
+	}
+	greaterThan(other) {
+		this.assertSameCurrency(other);
+		return this.amount > other.amount;
+	}
+	lessThan(other) {
+		this.assertSameCurrency(other);
+		return this.amount < other.amount;
+	}
+	greaterThanOrEqual(other) {
+		return this.greaterThan(other) || this.equals(other);
+	}
+	lessThanOrEqual(other) {
+		return this.lessThan(other) || this.equals(other);
+	}
+	/**
+	* Get amount in major unit (dollars, taka)
+	*/
+	toUnit() {
+		const config = CURRENCIES[this.currency] ?? { decimals: 2 };
+		return this.amount / Math.pow(10, config.decimals);
+	}
+	/**
+	* Format for display
+	* @example Money.usd(1999).format() // "$19.99"
+	*/
+	format(locale = "en-US") {
+		return new Intl.NumberFormat(locale, {
+			style: "currency",
+			currency: this.currency
+		}).format(this.toUnit());
+	}
+	/**
+	* Format without currency symbol
+	*/
+	formatAmount(locale = "en-US") {
+		const config = CURRENCIES[this.currency] ?? { decimals: 2 };
+		return new Intl.NumberFormat(locale, {
+			minimumFractionDigits: config.decimals,
+			maximumFractionDigits: config.decimals
+		}).format(this.toUnit());
+	}
+	/**
+	* Convert to JSON-serializable object
+	*/
+	toJSON() {
+		return {
+			amount: this.amount,
+			currency: this.currency
+		};
+	}
+	/**
+	* Create from JSON
+	*/
+	static fromJSON(json) {
+		return new Money(json.amount, json.currency);
+	}
+	toString() {
+		return `${this.currency} ${this.amount}`;
+	}
+	assertSameCurrency(other) {
+		if (this.currency !== other.currency) throw new Error(`Currency mismatch: ${this.currency} vs ${other.currency}. Convert first.`);
+	}
+};
+/**
+* Helper functions for legacy compatibility
+*/
+function toSmallestUnit(amount, currency = "USD") {
+	return Money.of(amount, currency).amount;
+}
+function fromSmallestUnit(amount, currency = "USD") {
+	return Money.cents(amount, currency).toUnit();
+}
+
+//#endregion
+export { fromSmallestUnit as n, toSmallestUnit as r, Money as t };

package/dist/money-DPG8AtJ8.d.mts

@@ -0,0 +1,112 @@
+//#region src/shared/utils/formatters/money.d.ts
+/**
+ * Money Utility - Integer-safe currency handling
+ * @classytic/revenue
+ *
+ * Never use floating point for money!
+ * All amounts stored as smallest unit (cents, paisa, etc.)
+ *
+ * Inspired by: Stripe, Dinero.js, tc39/proposal-decimal
+ */
+interface MoneyValue {
+  /** Amount in smallest currency unit (cents, paisa, etc.) */
+  readonly amount: number;
+  /** ISO 4217 currency code */
+  readonly currency: string;
+}
+/**
+ * Money class - immutable money representation
+ */
+declare class Money implements MoneyValue {
+  readonly amount: number;
+  readonly currency: string;
+  private constructor();
+  /**
+   * Create money from smallest unit (cents, paisa)
+   * @example Money.cents(1999, 'USD') // $19.99
+   */
+  static cents(amount: number, currency?: string): Money;
+  /**
+   * Create money from major unit (dollars, taka)
+   * @example Money.of(19.99, 'USD') // $19.99 (stored as 1999 cents)
+   */
+  static of(amount: number, currency?: string): Money;
+  /**
+   * Create zero money
+   */
+  static zero(currency?: string): Money;
+  static usd(cents: number): Money;
+  static eur(cents: number): Money;
+  static gbp(pence: number): Money;
+  static bdt(paisa: number): Money;
+  static inr(paisa: number): Money;
+  static jpy(yen: number): Money;
+  /**
+   * Add two money values (must be same currency)
+   */
+  add(other: Money): Money;
+  /**
+   * Subtract money (must be same currency)
+   */
+  subtract(other: Money): Money;
+  /**
+   * Multiply by a factor (rounds to nearest integer)
+   */
+  multiply(factor: number): Money;
+  /**
+   * Divide by a divisor (rounds to nearest integer)
+   */
+  divide(divisor: number): Money;
+  /**
+   * Calculate percentage
+   * @example money.percentage(10) // 10% of money
+   */
+  percentage(percent: number): Money;
+  /**
+   * Allocate money among recipients (handles rounding)
+   * @example Money.usd(100).allocate([1, 1, 1]) // [34, 33, 33] cents
+   */
+  allocate(ratios: number[]): Money[];
+  /**
+   * Split equally among n recipients
+   */
+  split(parts: number): Money[];
+  isZero(): boolean;
+  isPositive(): boolean;
+  isNegative(): boolean;
+  equals(other: Money): boolean;
+  greaterThan(other: Money): boolean;
+  lessThan(other: Money): boolean;
+  greaterThanOrEqual(other: Money): boolean;
+  lessThanOrEqual(other: Money): boolean;
+  /**
+   * Get amount in major unit (dollars, taka)
+   */
+  toUnit(): number;
+  /**
+   * Format for display
+   * @example Money.usd(1999).format() // "$19.99"
+   */
+  format(locale?: string): string;
+  /**
+   * Format without currency symbol
+   */
+  formatAmount(locale?: string): string;
+  /**
+   * Convert to JSON-serializable object
+   */
+  toJSON(): MoneyValue;
+  /**
+   * Create from JSON
+   */
+  static fromJSON(json: MoneyValue): Money;
+  toString(): string;
+  private assertSameCurrency;
+}
+/**
+ * Helper functions for legacy compatibility
+ */
+declare function toSmallestUnit(amount: number, currency?: string): number;
+declare function fromSmallestUnit(amount: number, currency?: string): number;
+//#endregion
+export { toSmallestUnit as i, MoneyValue as n, fromSmallestUnit as r, Money as t };

package/dist/{payment.enums-C1BiGlRa.d.ts → payment.enums-HAuAS9Pp.d.mts}

@@ -1,3 +1,4 @@
+//#region src/enums/payment.enums.d.ts
 /**
  * Payment Enums
  * @classytic/revenue
@@ -9,11 +10,11 @@
  * Payment Status - Library-managed states
  */
 declare const PAYMENT_STATUS: {
-    readonly PENDING: "pending";
-    readonly VERIFIED: "verified";
-    readonly FAILED: "failed";
-    readonly REFUNDED: "refunded";
-    readonly CANCELLED: "cancelled";
+  readonly PENDING: "pending";
+  readonly VERIFIED: "verified";
+  readonly FAILED: "failed";
+  readonly REFUNDED: "refunded";
+  readonly CANCELLED: "cancelled";
 };
 type PaymentStatus = typeof PAYMENT_STATUS;
 type PaymentStatusValue = PaymentStatus[keyof PaymentStatus];
@@ -49,21 +50,21 @@ declare const PAYMENT_STATUS_VALUES: PaymentStatusValue[];
  * Add your own: bkash, nagad, rocket, paypal, razorpay, flutterwave, etc.
  */
 declare const PAYMENT_GATEWAY_TYPE: {
-    readonly MANUAL: "manual";
-    readonly STRIPE: "stripe";
-    readonly SSLCOMMERZ: "sslcommerz";
+  readonly MANUAL: "manual";
+  readonly STRIPE: "stripe";
+  readonly SSLCOMMERZ: "sslcommerz";
 };
 type PaymentGatewayType = typeof PAYMENT_GATEWAY_TYPE;
 type PaymentGatewayTypeValue = PaymentGatewayType[keyof PaymentGatewayType];
 declare const PAYMENT_GATEWAY_TYPE_VALUES: PaymentGatewayTypeValue[];
 declare const GATEWAY_TYPES: {
-    readonly MANUAL: "manual";
-    readonly STRIPE: "stripe";
-    readonly SSLCOMMERZ: "sslcommerz";
+  readonly MANUAL: "manual";
+  readonly STRIPE: "stripe";
+  readonly SSLCOMMERZ: "sslcommerz";
 };
 declare const GATEWAY_TYPE_VALUES: PaymentGatewayTypeValue[];
 declare function isPaymentStatus(value: unknown): value is PaymentStatusValue;
 declare function isPaymentGatewayType(value: unknown): value is PaymentGatewayTypeValue;
 declare const isGatewayType: typeof isPaymentGatewayType;
-
-export { GATEWAY_TYPES as G, type PaymentStatusValue as P, type PaymentGatewayTypeValue as a, isPaymentGatewayType as b, PAYMENT_STATUS as c, type PaymentStatus as d, PAYMENT_STATUS_VALUES as e, PAYMENT_GATEWAY_TYPE as f, type PaymentGatewayType as g, PAYMENT_GATEWAY_TYPE_VALUES as h, isPaymentStatus as i, GATEWAY_TYPE_VALUES as j, isGatewayType as k };
+//#endregion
+export { PAYMENT_STATUS as a, PaymentGatewayTypeValue as c, isGatewayType as d, isPaymentGatewayType as f, PAYMENT_GATEWAY_TYPE_VALUES as i, PaymentStatus as l, GATEWAY_TYPE_VALUES as n, PAYMENT_STATUS_VALUES as o, isPaymentStatus as p, PAYMENT_GATEWAY_TYPE as r, PaymentGatewayType as s, GATEWAY_TYPES as t, PaymentStatusValue as u };

package/dist/payment.enums-tEFVa-Xp.mjs

@@ -0,0 +1,69 @@
+//#region src/enums/payment.enums.ts
+/**
+* Payment Enums
+* @classytic/revenue
+*
+* Library-managed payment enums only.
+* Users define their own payment methods in their schema.
+*/
+/**
+* Payment Status - Library-managed states
+*/
+const PAYMENT_STATUS = {
+	PENDING: "pending",
+	VERIFIED: "verified",
+	FAILED: "failed",
+	REFUNDED: "refunded",
+	CANCELLED: "cancelled"
+};
+const PAYMENT_STATUS_VALUES = Object.values(PAYMENT_STATUS);
+/**
+* Common gateway type constants for convenience
+*
+* ⚠️ IMPORTANT: These are NOT restrictions - just common reference values
+*
+* You can register ANY custom gateway provider by passing it to createRevenue():
+*
+* @example
+* ```typescript
+* const revenue = createRevenue({
+*   providers: {
+*     manual: new ManualProvider(),
+*     bkash: new BkashProvider(),      // ✅ Custom gateway
+*     nagad: new NagadProvider(),      // ✅ Custom gateway
+*     stripe: new StripeProvider(),    // ✅ Custom gateway
+*     paypal: new PaypalProvider(),    // ✅ Any gateway you want
+*   }
+* });
+*
+* // Use by name
+* await revenue.monetization.create({ gateway: 'bkash', ... });
+* ```
+*
+* Reference values:
+* - MANUAL: Built-in manual provider (@classytic/revenue-manual)
+* - STRIPE: Stripe provider (build with @classytic/revenue-stripe)
+* - SSLCOMMERZ: SSLCommerz provider (build with @classytic/revenue-sslcommerz)
+*
+* Add your own: bkash, nagad, rocket, paypal, razorpay, flutterwave, etc.
+*/
+const PAYMENT_GATEWAY_TYPE = {
+	MANUAL: "manual",
+	STRIPE: "stripe",
+	SSLCOMMERZ: "sslcommerz"
+};
+const PAYMENT_GATEWAY_TYPE_VALUES = Object.values(PAYMENT_GATEWAY_TYPE);
+const GATEWAY_TYPES = PAYMENT_GATEWAY_TYPE;
+const GATEWAY_TYPE_VALUES = PAYMENT_GATEWAY_TYPE_VALUES;
+const paymentStatusSet = new Set(PAYMENT_STATUS_VALUES);
+const paymentGatewayTypeSet = new Set(PAYMENT_GATEWAY_TYPE_VALUES);
+function isPaymentStatus(value) {
+	return typeof value === "string" && paymentStatusSet.has(value);
+}
+function isPaymentGatewayType(value) {
+	return typeof value === "string" && paymentGatewayTypeSet.has(value);
+}
+const isGatewayType = isPaymentGatewayType;
+
+//#endregion
+export { PAYMENT_STATUS as a, isPaymentGatewayType as c, PAYMENT_GATEWAY_TYPE_VALUES as i, isPaymentStatus as l, GATEWAY_TYPE_VALUES as n, PAYMENT_STATUS_VALUES as o, PAYMENT_GATEWAY_TYPE as r, isGatewayType as s, GATEWAY_TYPES as t };