Утиліта NoInfer: прецизійний контроль місць виводу типів у дженериках

// Проблема до TypeScript 5.4: паразитний вивід об'єднання
function createColorPalette<T extends string>(
  allowedColors: T[],
  defaultColor: T // Ми хочемо, щоб defaultColor брався суворо з allowedColors!
) { /* ... */ }

// Розробник припустився помилки: 'emerald' відсутній у списку allowedColors!
createColorPalette(['red', 'blue'], 'emerald');
// ЗАМІСТЬ ПОМИЛКИ: TypeScript мовчки виводить T як ('red' | 'blue' | 'emerald')!
// Помилка в дефолті тихо розширила список дозволених кольорів, зруйнувавши валідацію!

+-------------------------------------------------------------------------+
|               Механіка виводу типів з утилітою NoInfer<T>               |
+-------------------------------------------------------------------------+
| Без NoInfer<T>:                                                         |
| fn<T>(candidates: T[], fallback: T)                                     |
|   1. candidates ('red' | 'blue') ──> КАНДИДАТ ДЛЯ T                     |
|   2. fallback ('emerald')        ──> КАНДИДАТ ДЛЯ T                     |
|   ПІДСУМОК T: ('red' | 'blue' | 'emerald')  (Тихий архітектурний баг!)  |
+-------------------------------------------------------------------------+
                                    │
                                    ▼ Рішення в TypeScript 5.4+
+-------------------------------------------------------------------------+
| З утилітою NoInfer<T>:                                                  |
| fn<T>(candidates: T[], fallback: NoInfer<T>)                            |
|   1. candidates ('red' | 'blue') ──> ЄДИНЕ ДЖЕРЕЛО ДЛЯ T                |
|   ПІДСУМОК T: ('red' | 'blue')                                          |
|   2. fallback перевіряється на assignability:                           |
|   'emerald' не входить до ('red' | 'blue') => ПОМИЛКА КОМПІЛЯЦІЇ!       |
+-------------------------------------------------------------------------+

export interface StateConfig<TContext> {
  readonly onEnter?: (context: TContext) => void;
  readonly onExit?: (context: TContext) => void;
}

export interface MachineDefinition<TState extends string, TContext> {
  readonly states: Record<TState, StateConfig<TContext>>;
  // Використання NoInfer<TState> гарантує, що initialState
  // не додасть до TState новий випадковий стан при помилці введення!
  readonly initialState: NoInfer<TState>;
  readonly context: TContext;
}

export class StateMachine<TState extends string, TContext> {
  private currentState: TState;
  private readonly context: TContext;
  private readonly states: Record<TState, StateConfig<TContext>>;

  constructor(definition: MachineDefinition<TState, TContext>) {
    this.currentState = definition.initialState;
    this.context = definition.context;
    this.states = definition.states;
  }

  public getState(): TState {
    return this.currentState;
  }

  /**
   * Метод переходу в наступний стан.
   * Аргумент nextState також захищений NoInfer<TState>!
   */
  public transitionTo(nextState: NoInfer<TState>): void {
    if (!(nextState in this.states)) {
      throw new Error(`Неприпустимий перехід у стан: ${nextState}`);
    }

    this.states[this.currentState]?.onExit?.(this.context);
    this.currentState = nextState;
    this.states[this.currentState]?.onEnter?.(this.context);
  }
}

/**
 * Фабрична функція створення стейт-машини
 */
export function createStateMachine<TState extends string, TContext>(
  definition: MachineDefinition<TState, TContext>
): StateMachine<TState, TContext> {
  return new StateMachine(definition);
}