Ввод карты общих функций с рекурсивным обратным вызовом в Typescript

Тип actions по своей сути является циклическим, и просить TypeScript определить такой тип для вас не будет работать очень хорошо. Хотя объявления классов обычно позволяют выводить типы одного свойства на основе выведенных типов других свойств, произвольные объектные литералы и функции обычно не работают таким образом.

Было бы гораздо проще определить простой интерфейс сопоставления имени действия с типом полезной нагрузки (например, ваш ActionTypes), а затем реализовать объект действия этого типа. Вы говорите, что это не идеальный опыт разработчика, но это лучше, чем пытаться перепрыгнуть через обручи, избегающие цикличности. В вашем примере не показано, как это выглядит, поэтому я бы сказал, что это наиболее разумная реализация.

Сначала мы меняем ваши типы на:

type ActionDef<AP, K extends keyof AP> =
    (payload: AP[K], triggerCallback: TriggerFunc<AP>) => void
type TriggerFunc<AP> =
    <K extends keyof AP>(actionName: K, payload: AP[K]) => void;
type ActionMap<AP> = { [K in keyof AP]: ActionDef<AP, K> }
declare function getTrigger<AP>(actions: ActionMap<AP>): TriggerFunc<AP>;

На самом деле я ничего не пишу с точки зрения типа действий (A); это просто типы полезных данных (AP) и ключей (K). Обратите внимание, что вам больше не нужно ограничивать что-либо типом действия, а также вам не нужно явно выводить что-либо при описании типов. И ActionDef нужно знать только ключ K из AP, соответствующий полезной нагрузке; он может вычислить полезную нагрузку как AP[K]. Наконец, функция getTrigger() выводит AP из сопоставленного типа ActionMap<AP> и возвращает TriggerFunc<AP>.

Хорошо, теперь для рабочего примера мы заранее определяем этот интерфейс отображения:

interface ActionTypes {
    action1: { x: number };
    action2: { y: string };
}

Тогда сборка actions происходит так же, как и раньше, за исключением того, что вы используете новые определения типов:

const action1 = ((payload, trigger) => {
    console.info('action1', payload)
    trigger('action2', { y: 'abc' })
}) satisfies ActionDef<ActionTypes, "action1">;

const action2 = ((payload, trigger) => {
    console.info('action2', payload)
    trigger('action1', { x: 123 })
}) satisfies ActionDef<ActionTypes, "action2">;

const actions = {
    action1,
    action2
}

const trigger = getTrigger(actions);

function triggerSomeActions() {
    trigger('action1', { x: 123 });
    trigger('action1', { x: 234 });
    trigger('action2', { y: 'abc' });
}

Мне это действительно кажется не очень плохим. Фактически, большая часть дублирования возникает из-за создания отдельного именованного функционального объекта для каждого действия перед его упаковкой в ​​actions. Определение их отдельно может быть важно для вас, но вы можете сократить избыточность, определив их напрямую:

const actions: ActionMap<ActionTypes> = {
    action1: ((payload, trigger) => {
        console.info('action1', payload)
        trigger('action2', { y: 'abc' })
    }),
    action2: ((payload, trigger) => {
        console.info('action2', payload)
        trigger('action1', { x: 123 })
    })
};

Это уже настолько кратко, что мне трудно представить что-то лучшее, предполагающее использование typeof или какого-либо другого косвенного обращения. Например, вы можете воспользоваться циклической обработкой объявлений class, создав класс ActionsClass, экземпляры которого вам нужны actions. Учитывая такой класс, вы можете определить соответствующий тип утилиты триггерной функции:

type ClassTrigger<T> =
    TriggerFunc<{ [K in keyof T]: T[K] extends (payload: infer P, ...a: any) => void ? P : never }>

А затем вместе определите ActionsClass и тип триггера:

type ACT = ClassTrigger<ActionsClass>;
class ActionsClass {
    action1(payload: { x: number }, trigger: ACT) {
        console.info('action1', payload);
        trigger('action2', { y: 'abc' });
    };
    action2(payload: { y: string }, trigger: ACT) {
        console.info('action2', payload);
        trigger('action1', { x: 123 })
    }
}
const actions = new ActionsClass();

Это позволяет достичь цели: не нужно писать action1, action2, {x: number} или {y: string} более одного раза (конечно, игнорируя вызовы trigger()) и не полагаясь на внешнее сопоставление ActionTypes. Но это так странно, и я скорее попрошу разработчиков определить их типы, чем скажу им, почему они создают класс, когда им нужен только один его экземпляр.

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