Prototype

interface Clonavel<T> {
  clonar(): T;
}

class Documento implements Clonavel<Documento> {
  constructor(
    public titulo: string,
    public blocos: string[],
    public config: { tema: string; margens: number },
  ) {}

  clonar(): Documento {
    // copia PROFUNDA: sem isso, o clone compartilha o array e o objeto
    return new Documento(
      this.titulo,
      [...this.blocos],
      { ...this.config },
    );
  }
}

// Registro de modelos prontos
class Registro {
  private modelos = new Map<string, Documento>();

  registrar(nome: string, p: Documento): void {
    this.modelos.set(nome, p);
  }

  criar(nome: string): Documento {
    const p = this.modelos.get(nome);
    if (!p) throw new Error("modelo desconhecido: " + nome);
    return p.clonar(); // o modelo nunca sai do registro
  }
}

const registro = new Registro();
registro.registrar(
  "contrato",
  new Documento("Contrato padrão", ["cláusula 1", "cláusula 2"], { tema: "formal", margens: 3 }),
);

const meu = registro.criar("contrato");
meu.blocos.push("cláusula extra");
console.log(registro.criar("contrato").blocos.length); // 2 — o modelo segue intacto

import copy

class Documento:
    def __init__(self, titulo, blocos, config):
        self.titulo, self.blocos, self.config = titulo, blocos, config

    def clonar(self):
        # copia PROFUNDA: sem isso o clone compartilha a lista e o dict
        return copy.deepcopy(self)

class Registro:
    def __init__(self):
        self._modelos = {}

    def registrar(self, nome, p):
        self._modelos[nome] = p

    def criar(self, nome):
        if nome not in self._modelos:
            raise KeyError("modelo desconhecido: " + nome)
        return self._modelos[nome].clonar()  # o modelo nunca sai

registro = Registro()
registro.registrar(
    "contrato",
    Documento("Contrato padrao", ["clausula 1", "clausula 2"], {"tema": "formal"}),
)

meu = registro.criar("contrato")
meu.blocos.append("clausula extra")
print(len(registro.criar("contrato").blocos))  # 2 — o modelo segue intacto