Swap Behaviour: Strategy and Decorator

// Every new rule is one more `if`, and the order of the ifs is the order of the rules, hidden.
export function parkingFee({ minutes, enterHour, vehicle }) {
  const hours = Math.ceil(minutes / 60);
  let fee;
  if (vehicle === 'bike') fee = hours * 10;
  else if (vehicle === 'truck') fee = hours * 40;
  else fee = hours * 20;

  if (minutes <= 10) fee = 0;                                       // grace period
  if (enterHour >= 22 || enterHour < 6) fee = Math.round(fee / 2);  // night discount
  if (fee > 100) fee = 100;                                         // cap
  return fee;
}

// A PricingStrategy is any object with fee(stay) that returns whole currency units.
export class HourlyRate {
  constructor(rate) { this.rate = rate; }
  fee({ minutes }) { return Math.ceil(minutes / 60) * this.rate; }  // every started hour counts
}

export class FlatRate {
  constructor(amount) { this.amount = amount; }
  fee() { return this.amount; }
}

export class Garage {
  constructor(pricing) { this.pricing = pricing; }  // handed in, never built in here
  checkout(stay) { return this.pricing.fee(stay); }
  switchTo(pricing) { this.pricing = pricing; }     // stadium night: swap while running
}

// Choosing at runtime is a strategy that picks another strategy.
export class ByVehicle {
  constructor(table, fallback) { this.table = table; this.fallback = fallback; }
  fee(stay) { return (this.table[stay.vehicle] ?? this.fallback).fee(stay); }
}

const isNight = (hour) => hour >= 22 || hour < 6;

// A decorator is a PricingStrategy that holds another one: same interface in, same interface out.
export class GracePeriod {
  constructor(inner, minutes) { this.inner = inner; this.minutes = minutes; }
  fee(stay) { return stay.minutes <= this.minutes ? 0 : this.inner.fee(stay); }
}

export class NightDiscount {
  constructor(inner, percentOff) { this.inner = inner; this.percentOff = percentOff; }
  fee(stay) {
    const fee = this.inner.fee(stay);
    if (!isNight(stay.enterHour)) return fee;
    return Math.floor((fee * (100 - this.percentOff) + 50) / 100);  // integer math, halves round up
  }
}

// One cap per stay. A cap per calendar day needs the stay split at midnight (see the parking lot question).
export class Cap {
  constructor(inner, max) { this.inner = inner; this.max = max; }
  fee(stay) { return Math.min(this.inner.fee(stay), this.max); }
}

import { HourlyRate } from './strategy.js';
import { Cap, NightDiscount } from './rules.js';

const base = new HourlyRate(20);

// Same three rules, two wrapping orders. Read from the inside out.
export const capThenDiscount = new NightDiscount(new Cap(base, 100), 50);  // the discount applies to the capped fee
export const discountThenCap = new Cap(new NightDiscount(base, 50), 100);  // the cap applies to what the driver pays

// In JavaScript a function is the simplest strategy, and a function that wraps a function is the simplest decorator.
export const hourly = (rate) => ({ minutes }) => Math.ceil(minutes / 60) * rate;

export const capped = (fee, max) => (stay) => Math.min(fee(stay), max);

export const nightly = (fee, percentOff) => (stay) => {
  const night = stay.enterHour >= 22 || stay.enterHour < 6;
  const base = fee(stay);
  return night ? Math.floor((base * (100 - percentOff) + 50) / 100) : base;
};

export const price = capped(nightly(hourly(20), 50), 100);  // cap(discount(base)): read from the inside out