javascript - Bör jag försöka tvinga inkapsling i Typescript?

Låt oss anta att jag har ett objekt som har och håller ett fält av objekt. När man arbetar med detta objekt vill jag säkerställa att ingen kan lägga till objekt direkt i fältet utan endast genom att använda lämplig metod. Utifrån kan man iterera över fältet och hämta objekt från det, men man ska inte kunna lägga till objekt. Om man behöver lägga till objekt måste man anropa instansfunktionen addItem.

Javascript stöder inte detta eftersom exponering av Array-objektet gör det möjligt för vem som helst att lägga till objekt i det.
Med Typescript kan jag använda en getter och returnera ReadOnlyArray-typ istället för Array-typ. Så mitt objekt skulle kunna se ut ungefär så här:

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

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

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

Alternativet är helt enkelt att exponera arrayen som egenskapen hos klassen:

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

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

Jag vet att jag egentligen inte kapslar in/döljer min array eftersom ReadOnlyArray bara är syntaktiskt socker, men det kan hjälpa till att förhindra att någon av misstag använder objektet på fel sätt.

Är detta värt ansträngningen och borde jag följa detta tillvägagångssätt eller helt enkelt exponera arrayen som en egenskap?
För att uttrycka frågan mer allmänt: Bör jag försöka upprätthålla OOP-inkapsling i Typescript/Javascript eller bör jag helt enkelt ignorera det eftersom det inte är idiomatiskt för Javascript?