javascript - ¿Debería intentar hacer cumplir la encapsulación en Typescript?

Supongamos que tengo un objeto que mantiene un arreglo de elementos. Al trabajar con este objeto, me gustaría asegurarme de que nadie pueda agregar elementos directamente al arreglo, sino únicamente mediante el método apropiado. Desde fuera puedes iterar sobre el arreglo y obtener elementos de él, pero no deberías poder agregar elementos. Si necesitas agregar elementos, debes llamar a una función de instancia addItem.

Javascript no soporta esto ya que exponer el objeto Array permitirá a cualquiera agregar elementos a él.
Con Typescript puedo usar un getter y devolver el tipo ReadOnlyArray en lugar del tipo Array. Así que mi objeto podría verse algo así:

class SomeObject {
    #items: Array<string> = new Array<string>();

    get items() : ReadOnlyArray<string> {
        return #items;
    }

    addItem(item: string) {
        // do something special ...
        #items.push(item);
    }
}

La alternativa es simplemente exponer el arreglo como la propiedad de la clase:

class SomeObject {
    
    items: Array<string> = new Array<string>();

    addItem(item: string) {
        // do something special ...
        items.push(item);
    }
}

Sé que no estoy realmente encapsulando/ocultando mi arreglo ya que ReadOnlyArray es solo azúcar sintáctica, pero podría ayudar a prevenir que alguien use el objeto de manera incorrecta por accidente.

¿Vale la pena el esfuerzo y debería seguir este enfoque o simplemente exponer el arreglo como una propiedad?
Para poner la pregunta de manera más general: ¿Debería intentar hacer cumplir la encapsulación OOP en Typescript/Javascript o simplemente debería ignorarla porque no es idiomático en Javascript?