Prototype

type Cap = readonly [string, number];

// A configured object that is easier to copy and tweak than to build from scratch.
class FarePlan {
  constructor(
    public name: string,
    public unlock: number,
    public perMinute: number,
    public peak: Map<string, number>,   // hours -> price as a percentage of normal
    public caps: Cap[],                 // (period, most a rider pays in that period)
  ) {}

  clone(name: string): FarePlan {
    // new map and array: the copy shares nothing that can change
    return new FarePlan(name, this.unlock, this.perMinute, new Map(this.peak), [...this.caps]);
  }

  shallowCopy(name: string): FarePlan {
    // new object, but the same map and array inside it
    return new FarePlan(name, this.unlock, this.perMinute, this.peak, this.caps);
  }

  describe(): string {
    const peak = [...this.peak].map(([h, p]) => `${h} ${p}%`).join(", ");
    const caps = this.caps.map(([n, p]) => `${n} ${p}p`).join(", ");
    return `${this.name}: unlock ${this.unlock}p, ${this.perMinute}p/min, peak ${peak}, caps ${caps}`;
  }
}

// Keeps ready-made prototypes by name; new plans start as copies of them.
class PlanRegistry {
  private readonly prototypes = new Map<string, FarePlan>();

  add(plan: FarePlan): void { this.prototypes.set(plan.name, plan); }

  clone(key: string, newName: string): FarePlan {
    const proto = this.prototypes.get(key);
    if (!proto) throw new Error(`no prototype called '${key}'`);
    return proto.clone(newName);
  }
}

const registry = new PlanRegistry();
const standard = new FarePlan("standard", 100, 10, new Map([["07-09", 150], ["17-19", 150]]), [["daily", 1200]]);
registry.add(standard);
console.log(standard.describe());

const student = registry.clone("standard", "student");
student.unlock = 0;
student.peak.set("07-09", 120);
student.caps[0] = ["daily", 600];
console.log(student.describe());
console.log(`after the deep copy -> ${standard.describe()}`);

const weekend = standard.shallowCopy("weekend");
weekend.caps.push(["weekend", 800]);
console.log(`after the shallow copy -> ${standard.describe()}`);
try {
  registry.clone("night", "late");
} catch (e) {
  console.log(`rejected: ${(e as Error).message}`);
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    record Cap(String period, int pence) {}

    // A configured object that is easier to copy and tweak than to build from scratch.
    static class FarePlan {
        String name;
        int unlock, perMinute;
        final Map<String, Integer> peak;   // hours -> price as a percentage of normal
        final List<Cap> caps;              // (period, most a rider pays in that period)

        FarePlan(String name, int unlock, int perMinute, Map<String, Integer> peak, List<Cap> caps) {
            this.name = name; this.unlock = unlock; this.perMinute = perMinute; this.peak = peak; this.caps = caps;
        }

        // A copy method rather than Object.clone(): explicit about what is copied.
        FarePlan copy(String newName) {
            // new map and list: the copy shares nothing that can change
            return new FarePlan(newName, unlock, perMinute, new LinkedHashMap<>(peak), new ArrayList<>(caps));
        }

        FarePlan shallowCopy(String newName) {
            // new object, but the same map and list inside it
            return new FarePlan(newName, unlock, perMinute, peak, caps);
        }

        String describe() {
            String p = peak.entrySet().stream().map(e -> e.getKey() + " " + e.getValue() + "%").collect(Collectors.joining(", "));
            String c = caps.stream().map(x -> x.period() + " " + x.pence() + "p").collect(Collectors.joining(", "));
            return name + ": unlock " + unlock + "p, " + perMinute + "p/min, peak " + p + ", caps " + c;
        }
    }

    // Keeps ready-made prototypes by name; new plans start as copies of them.
    static class PlanRegistry {
        private final Map<String, FarePlan> prototypes = new HashMap<>();

        void add(FarePlan plan) { prototypes.put(plan.name, plan); }

        FarePlan copy(String key, String newName) {
            FarePlan proto = prototypes.get(key);
            if (proto == null) throw new IllegalArgumentException("no prototype called '" + key + "'");
            return proto.copy(newName);
        }
    }

    public static void main(String[] args) {
        PlanRegistry registry = new PlanRegistry();
        Map<String, Integer> peak = new LinkedHashMap<>();
        peak.put("07-09", 150);
        peak.put("17-19", 150);
        FarePlan standard = new FarePlan("standard", 100, 10, peak, new ArrayList<>(List.of(new Cap("daily", 1200))));
        registry.add(standard);
        System.out.println(standard.describe());

        FarePlan student = registry.copy("standard", "student");
        student.unlock = 0;
        student.peak.put("07-09", 120);
        student.caps.set(0, new Cap("daily", 600));
        System.out.println(student.describe());
        System.out.println("after the deep copy -> " + standard.describe());

        FarePlan weekend = standard.shallowCopy("weekend");
        weekend.caps.add(new Cap("weekend", 800));
        System.out.println("after the shallow copy -> " + standard.describe());
        try {
            registry.copy("night", "late");
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
    }
}