Предотвратите двойной вызов одного и того же геттера с помощью связанных геттеров

В качестве альтернативы вы можете избежать использования дочерних классов для проверки типов и просто использовать общий Proxy для всех ваших цветов и стилей, более того, вы можете ввести свойства Painter вместо использования string.

Это также позволяет вам вводить стили и цвета в любом порядке (хороший или плохой).

Хорошо, что вы можете определить цвета по умолчанию (например, белый фон и черный текст) и установить только стили текста. Я думаю, что это более гибко, чем использование дочерних классов, где вам НЕОБХОДИМО установить цвет для установки фона. Кажется, это неприятное ограничение.

Машинописная площадка

const colors = ['white', 'black', 'red', 'blue'] as const;
const styles = ['underline', 'bold', 'italic'] as const;

type Color = typeof colors[number];
type BgColor = keyof { [K in Color as `${K}Bg`]: never };
type Style = typeof styles[number];

// sets for faster lookups
const colorSet = new Set(colors);
const bgColorSet = new Set(colors.map(c => `${c}Bg`) as BgColor[]);
const styleSet = new Set(styles);

type AllStyles = Color | BgColor | Style;

type Decorator<T extends AllStyles = never> = Omit<{
    [K in Style]: Omit<Decorator<T | K>, K>
}, T> & Omit<{
    [K in Color]: Omit<Decorator<T | Color>, Color>
}, T> & Omit<{
    [K in BgColor]: Omit<Decorator<T | BgColor>, BgColor>
}, T> & 
Painter;

class Painter {
    protected textColor: Color | '' = ""
    protected bgColor: Color | '' = ""
    protected styles: Style[] = []

    paint() {
        console.info(this);
    }
    static create(): Decorator { 
        return new Proxy<Decorator>(new Painter as Decorator, {
            get(target, prop, proxy){               
                if (colorSet.has(prop as Color)){
                    target.textColor = prop as Color;
                }else if (bgColorSet.has(prop as BgColor)){
                    target.bgColor = prop as Color;
                }else if (styleSet.has(prop as Style)){
                    target.styles.push(prop as Style);
                }else {
                    return Reflect.get(target, prop, proxy);
                }
                return proxy;
            }
        });

    }
}

Painter.create().white.black.redBg.bold.underline.paint() // black is an error
Painter.create().white.blueBg.bold.underline.bold.paint() // I want to see error that says bold cannot be called twice.
Painter.create().white.redBg.underline.bold.underline.paint() // I want to see error that says underline cannot be called twice.
Painter.create().white.redBg.italic.underline.italic.underline.paint() // I want to see error that says underline and italics cannot be called twice.

Вам нужно StyleDecorator отслеживать, какие свойства уже были опущены. В противном случае вы просто забудете все, кроме самой последней операции. Это предотвратило бы painter.bold.bold, но не остановило бы painter.bold.underline.bold.

Вы хотите, чтобы свойство bold объекта StyleDecorator имело тип Omit<StyleDecorator, "bold" | K>, где K — это то, что вы уже пропустили. Это означает, что StyleDecorator должен быть общим в K, а это означает, что каждый раз, когда вы опускаете , вам также придется добавить имя текущего вызываемого метода к K через объединение.

Это выглядит так:

type StyleDecoratorWithout<K extends PropertyKey> = Omit<StyleDecorator<K>, K>;

class StyleDecorator<K extends PropertyKey = never> extends Painter {
    get bold() {
        this.styles.push('bold')
        return this as StyleDecoratorWithout<K | "bold">
    }
    get underline() {
        this.styles.push('underline')
        return this as StyleDecoratorWithout<K | "underline">
    }
    get italic() {
        this.styles.push('italic')
        return this as StyleDecoratorWithout<K | "italic">
    }
}

Painter.create().white.redBg.bold.underline.paint() // ok
Painter.create().white.blueBg.bold.underline.bold.paint() // error
Painter.create().white.redBg.underline.bold.underline.paint() // error
Painter.create().white.redBg.italic.underline.italic.underline.paint() // error

Итак, Painter.create().white относится к типу StyleDecorator<never>. Его свойство bold — StyleDecoratorWithour<"bold">, что означает, что он не имеет свойства "bold" (поскольку мы Omit установили "bold") и что любое из его других свойств будет включать "bold" в список вещей, которые следует опустить. Тогда его свойством underline является StyleDecoratorWithout<"bold" | "underline">, поэтому у него нет свойств "bold" и "underline". После этого вы можете получить доступ к свойству italic, которое StyleDecoratorWithout<"bold" | "underline" | "italic"> не имеет ни одного из этих трех свойств. Вам фактически запрещено легко получать доступ к одному и тому же свойству несколько раз в цепочке получения.

Это ответ на заданный вопрос.

Но учтите, что на самом деле это не мешает вам многократно обращаться к одному и тому же свойству без цепочки:

const p = Painter.create().white
p.bold;
p.bold;
console.info(p["styles"]) // ["bold", "bold"], oops

И если вам нужно предотвратить это, то вы обнаружите, что это практически невозможно в TypeScript (поскольку для этого потребуется отслеживать произвольное изменяемое состояние данной переменной, чего TypeScript не может сделать). Я бы рекомендовал вам убедиться фактический код может обрабатывать несколько обращений к свойству (скажем, не push() определяя, если оно уже существует; используйте Set возможно? Но это отступление от заданного вопроса.

Детская площадка, ссылка на код