《独立开发者的商业指南·收入与财务工程》6.2 折扣、年付与现金流

可承受月流失 = 55.11 ÷ 4,320 = 1.28%

// file: src/price/discount.ts
// tier: L1
// verify: node --test test/price/discount.test.ts

import { type Cents } from "../core/money.ts";
import { type Bps, applyRate, divide, ratio } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

const MONTHS_PER_YEAR = 12;

export type AnnualDiscountInput = {
  monthlyPriceCents: Cents;
  customers: number;
  discountBps: Bps;
  paymentFeeBps: Bps;
  costOfCapitalBps: Bps;
};

export type AnnualDiscountImpact = {
  annualListPerCustomerCents: Cents;
  annualPricePerCustomerCents: Cents;
  equivalentMonthlyCents: Cents;
  annualListCents: Cents;
  annualRevenueCents: Cents;
  giveUpCents: Cents;
  firstMonthMonthlyCashCents: Cents;
  cashPullForwardCents: Cents;
  deferredAtSigningCents: Cents;
  paymentSavingsCents: Cents;
  floatBenefitCents: Cents;
  netEconomicCostCents: Cents;
};

function isPositiveInteger(value: number): boolean {
  return Number.isInteger(value) && value > 0;
}

function checkRate(value: Bps, label: string): string | null {
  if (!Number.isInteger(value) || value < 0 || value > 10000) {
    return `${label} must be between 0 and 10000 bps`;
  }
  return null;
}

export function annualPlanPrice(
  monthlyPriceCents: Cents,
  discountBps: Bps,
): Result<Cents> {
  if (!isPositiveInteger(monthlyPriceCents)) {
    return fail("monthly price must be a positive integer amount in cents");
  }
  const rateError = checkRate(discountBps, "discount");
  if (rateError) {
    return fail(rateError);
  }
  return ok(
    applyRate(monthlyPriceCents * MONTHS_PER_YEAR, 10000 - discountBps),
  );
}

export function equivalentMonthlyPrice(annualPriceCents: Cents): Result<Cents> {
  if (!isPositiveInteger(annualPriceCents)) {
    return fail("annual price must be a positive integer amount in cents");
  }
  return ok(Math.round(annualPriceCents / MONTHS_PER_YEAR));
}

/** Elapsed month zero is signing, when the whole plan is still deferred. */
export function deferredBalance(
  annualPriceCents: Cents,
  months: number,
  elapsedMonths: number,
): Result<Cents> {
  if (!isPositiveInteger(annualPriceCents)) {
    return fail("annual price must be a positive integer amount in cents");
  }
  if (!isPositiveInteger(months)) {
    return fail("months must be a positive integer");
  }
  if (
    !Number.isInteger(elapsedMonths) ||
    elapsedMonths < 0 ||
    elapsedMonths > months
  ) {
    return fail("elapsed months must be between zero and the plan length");
  }
  return ok(
    Math.round((annualPriceCents * (months - elapsedMonths)) / months),
  );
}

/** Present value of twelve equal payments at the annual cost of capital. */
function presentValueOfMonthlyPayments(
  annualCents: Cents,
  annualRateBps: Bps,
): number {
  const monthlyRate = Math.pow(1 + ratio(annualRateBps), 1 / MONTHS_PER_YEAR) - 1;
  const payment = annualCents / MONTHS_PER_YEAR;
  let presentValue = 0;
  for (let month = 0; month < MONTHS_PER_YEAR; month += 1) {
    presentValue += payment / Math.pow(1 + monthlyRate, month);
  }
  return presentValue;
}

export function annualDiscountImpact(
  input: AnnualDiscountInput,
): Result<AnnualDiscountImpact> {
  if (!isPositiveInteger(input.monthlyPriceCents)) {
    return fail("monthly price must be a positive integer amount in cents");
  }
  if (!isPositiveInteger(input.customers)) {
    return fail("customers must be a positive integer");
  }
  for (const [value, label] of [
    [input.discountBps, "discount"],
    [input.paymentFeeBps, "payment fee"],
    [input.costOfCapitalBps, "cost of capital"],
  ] as const) {
    const rateError = checkRate(value, label);
    if (rateError) {
      return fail(rateError);
    }
  }

  const annualListPerCustomerCents = input.monthlyPriceCents * MONTHS_PER_YEAR;
  const annualPricePerCustomerCents = applyRate(
    annualListPerCustomerCents,
    10000 - input.discountBps,
  );
  const equivalentMonthlyCents = Math.round(
    annualPricePerCustomerCents / MONTHS_PER_YEAR,
  );
  const annualListCents = annualListPerCustomerCents * input.customers;
  const annualRevenueCents = annualPricePerCustomerCents * input.customers;
  const giveUpCents = annualListCents - annualRevenueCents;
  const firstMonthMonthlyCashCents =
    input.monthlyPriceCents * input.customers;
  const cashPullForwardCents =
    annualRevenueCents - firstMonthMonthlyCashCents;

  const monthlyPaymentFee =
    applyRate(input.monthlyPriceCents, input.paymentFeeBps) * MONTHS_PER_YEAR;
  const annualPaymentFee = applyRate(
    annualPricePerCustomerCents,
    input.paymentFeeBps,
  );
  const paymentSavingsCents =
    (monthlyPaymentFee - annualPaymentFee) * input.customers;

  const presentValue =
    presentValueOfMonthlyPayments(
      annualPricePerCustomerCents,
      input.costOfCapitalBps,
    ) * input.customers;
  const floatBenefitCents = Math.round(annualRevenueCents - presentValue);
  const netEconomicCostCents =
    giveUpCents - paymentSavingsCents - floatBenefitCents;

  return ok({
    annualListPerCustomerCents,
    annualPricePerCustomerCents,
    equivalentMonthlyCents,
    annualListCents,
    annualRevenueCents,
    giveUpCents,
    firstMonthMonthlyCashCents,
    cashPullForwardCents,
    deferredAtSigningCents: annualRevenueCents,
    paymentSavingsCents,
    floatBenefitCents,
    netEconomicCostCents,
  });
}

/** Monthly churn a cohort can tolerate while its LTV matches a target. */
export function requiredMonthlyChurnBps(
  contributionCents: Cents,
  targetLtvCents: Cents,
): Result<Bps> {
  if (!Number.isInteger(contributionCents) || contributionCents < 0) {
    return fail("contribution must be a non-negative integer amount in cents");
  }
  if (!isPositiveInteger(targetLtvCents)) {
    return fail("target LTV must be a positive integer amount in cents");
  }
  return ok(divide(contributionCents, targetLtvCents));
}

/** Net cash for a batch after discount, refunds and the channel fee. */
export function channelNetTotal(
  listPriceCents: Cents,
  units: number,
  discountBps: Bps,
  refundBps: Bps,
  channelFeeBps: Bps,
): Result<Cents> {
  if (!isPositiveInteger(listPriceCents)) {
    return fail("list price must be a positive integer amount in cents");
  }
  if (!isPositiveInteger(units)) {
    return fail("units must be a positive integer");
  }
  for (const [value, label] of [
    [discountBps, "discount"],
    [refundBps, "refund"],
    [channelFeeBps, "channel fee"],
  ] as const) {
    const rateError = checkRate(value, label);
    if (rateError) {
      return fail(rateError);
    }
  }
  const listTotal = listPriceCents * units;
  const afterDiscount = applyRate(listTotal, 10000 - discountBps);
  const afterRefund = applyRate(afterDiscount, 10000 - refundBps);
  return ok(applyRate(afterRefund, 10000 - channelFeeBps));
}

export function averageNetPerUnit(
  totalCents: Cents,
  units: number,
): Result<Cents> {
  if (!Number.isInteger(totalCents) || totalCents < 0) {
    return fail("total must be a non-negative integer amount in cents");
  }
  if (!isPositiveInteger(units)) {
    return fail("units must be a positive integer");
  }
  return ok(Math.round(totalCents / units));
}

/** A 20% discount needs 25% more units: 0.20 / (1 - 0.20). */
export function unitLiftToHoldNetBps(discountBps: Bps): Result<Bps> {
  if (
    !Number.isInteger(discountBps) ||
    discountBps < 0 ||
    discountBps >= 10000
  ) {
    return fail("discount must be between 0 and 9999 bps");
  }
  if (discountBps === 0) {
    return ok(0);
  }
  return ok(divide(discountBps, 10000 - discountBps));
}